From c3b9f8c4582882cd1f768b0727eca75475bb4f94 Mon Sep 17 00:00:00 2001 From: James Taylor Date: Thu, 12 Jul 2018 23:40:30 -0700 Subject: [PATCH] track embedded python distribution --- .gitignore | 6 - python/brotli.py | 56 + python/gevent/__init__.py | 136 + python/gevent/_compat.py | 48 + python/gevent/_fileobjectcommon.py | 128 + python/gevent/_fileobjectposix.py | 285 + python/gevent/_semaphore.pxd | 23 + python/gevent/_semaphore.py | 269 + python/gevent/_socket2.py | 539 + python/gevent/_socket3.py | 1065 + python/gevent/_socketcommon.py | 343 + python/gevent/_ssl2.py | 436 + python/gevent/_ssl3.py | 661 + python/gevent/_sslgte279.py | 714 + python/gevent/_tblib.py | 431 + python/gevent/_threading.py | 515 + python/gevent/_util.py | 106 + python/gevent/_util_py2.py | 7 + python/gevent/ares.pyx | 454 + python/gevent/backdoor.py | 206 + python/gevent/baseserver.py | 402 + python/gevent/builtins.py | 125 + python/gevent/cares.pxd | 109 + python/gevent/cares_ntop.h | 7 + python/gevent/cares_pton.h | 8 + python/gevent/core.py | 22 + python/gevent/dnshelper.c | 159 + python/gevent/event.py | 448 + python/gevent/fileobject.py | 219 + python/gevent/gevent._semaphore.c | 8807 ++++++ python/gevent/gevent.ares.c | 14103 ++++++++++ python/gevent/gevent.ares.h | 48 + python/gevent/greenlet.py | 744 + python/gevent/hub.py | 1052 + python/gevent/libev/__init__.py | 0 python/gevent/libev/_corecffi_build.py | 75 + python/gevent/libev/_corecffi_cdef.c | 226 + python/gevent/libev/_corecffi_source.c | 45 + python/gevent/libev/callbacks.c | 225 + python/gevent/libev/callbacks.h | 43 + python/gevent/libev/corecext.ppyx | 1134 + python/gevent/libev/corecext.pyx | 2110 ++ python/gevent/libev/corecffi.py | 1132 + python/gevent/libev/gevent.corecext.c | 33465 +++++++++++++++++++++++ python/gevent/libev/libev.h | 66 + python/gevent/libev/libev.pxd | 208 + python/gevent/libev/libev_vfd.h | 223 + python/gevent/libev/stathelper.c | 187 + python/gevent/local.py | 293 + python/gevent/lock.py | 260 + python/gevent/monkey.py | 702 + python/gevent/os.py | 468 + python/gevent/pool.py | 759 + python/gevent/python.pxd | 17 + python/gevent/pywsgi.py | 1509 + python/gevent/queue.py | 605 + python/gevent/resolver_ares.py | 388 + python/gevent/resolver_thread.py | 71 + python/gevent/select.py | 244 + python/gevent/server.py | 255 + python/gevent/signal.py | 137 + python/gevent/socket.py | 106 + python/gevent/ssl.py | 26 + python/gevent/subprocess.py | 1480 + python/gevent/thread.py | 115 + python/gevent/threading.py | 231 + python/gevent/threadpool.py | 498 + python/gevent/timeout.py | 261 + python/gevent/util.py | 60 + python/gevent/win32util.py | 98 + python/gevent/wsgi.py | 15 + python/python.exe | Bin 0 -> 100504 bytes python/python3.dll | Bin 0 -> 58520 bytes python/python36._pth | 6 + python/python36.dll | Bin 0 -> 3611288 bytes python/python36.zip | Bin 0 -> 2238731 bytes python/pythonw.exe | Bin 0 -> 98968 bytes python/socks.py | 870 + python/sqlite3.dll | Bin 0 -> 1153176 bytes python/vcruntime140.dll | Bin 0 -> 89752 bytes 80 files changed, 81288 insertions(+), 6 deletions(-) create mode 100644 python/brotli.py create mode 100644 python/gevent/__init__.py create mode 100644 python/gevent/_compat.py create mode 100644 python/gevent/_fileobjectcommon.py create mode 100644 python/gevent/_fileobjectposix.py create mode 100644 python/gevent/_semaphore.pxd create mode 100644 python/gevent/_semaphore.py create mode 100644 python/gevent/_socket2.py create mode 100644 python/gevent/_socket3.py create mode 100644 python/gevent/_socketcommon.py create mode 100644 python/gevent/_ssl2.py create mode 100644 python/gevent/_ssl3.py create mode 100644 python/gevent/_sslgte279.py create mode 100644 python/gevent/_tblib.py create mode 100644 python/gevent/_threading.py create mode 100644 python/gevent/_util.py create mode 100644 python/gevent/_util_py2.py create mode 100644 python/gevent/ares.pyx create mode 100644 python/gevent/backdoor.py create mode 100644 python/gevent/baseserver.py create mode 100644 python/gevent/builtins.py create mode 100644 python/gevent/cares.pxd create mode 100644 python/gevent/cares_ntop.h create mode 100644 python/gevent/cares_pton.h create mode 100644 python/gevent/core.py create mode 100644 python/gevent/dnshelper.c create mode 100644 python/gevent/event.py create mode 100644 python/gevent/fileobject.py create mode 100644 python/gevent/gevent._semaphore.c create mode 100644 python/gevent/gevent.ares.c create mode 100644 python/gevent/gevent.ares.h create mode 100644 python/gevent/greenlet.py create mode 100644 python/gevent/hub.py create mode 100644 python/gevent/libev/__init__.py create mode 100644 python/gevent/libev/_corecffi_build.py create mode 100644 python/gevent/libev/_corecffi_cdef.c create mode 100644 python/gevent/libev/_corecffi_source.c create mode 100644 python/gevent/libev/callbacks.c create mode 100644 python/gevent/libev/callbacks.h create mode 100644 python/gevent/libev/corecext.ppyx create mode 100644 python/gevent/libev/corecext.pyx create mode 100644 python/gevent/libev/corecffi.py create mode 100644 python/gevent/libev/gevent.corecext.c create mode 100644 python/gevent/libev/libev.h create mode 100644 python/gevent/libev/libev.pxd create mode 100644 python/gevent/libev/libev_vfd.h create mode 100644 python/gevent/libev/stathelper.c create mode 100644 python/gevent/local.py create mode 100644 python/gevent/lock.py create mode 100644 python/gevent/monkey.py create mode 100644 python/gevent/os.py create mode 100644 python/gevent/pool.py create mode 100644 python/gevent/python.pxd create mode 100644 python/gevent/pywsgi.py create mode 100644 python/gevent/queue.py create mode 100644 python/gevent/resolver_ares.py create mode 100644 python/gevent/resolver_thread.py create mode 100644 python/gevent/select.py create mode 100644 python/gevent/server.py create mode 100644 python/gevent/signal.py create mode 100644 python/gevent/socket.py create mode 100644 python/gevent/ssl.py create mode 100644 python/gevent/subprocess.py create mode 100644 python/gevent/thread.py create mode 100644 python/gevent/threading.py create mode 100644 python/gevent/threadpool.py create mode 100644 python/gevent/timeout.py create mode 100644 python/gevent/util.py create mode 100644 python/gevent/win32util.py create mode 100644 python/gevent/wsgi.py create mode 100644 python/python.exe create mode 100644 python/python3.dll create mode 100644 python/python36._pth create mode 100644 python/python36.dll create mode 100644 python/python36.zip create mode 100644 python/pythonw.exe create mode 100644 python/socks.py create mode 100644 python/sqlite3.dll create mode 100644 python/vcruntime140.dll diff --git a/.gitignore b/.gitignore index 741084c..e792bf6 100644 --- a/.gitignore +++ b/.gitignore @@ -1,12 +1,6 @@ __pycache__/ *.py[cod] *$py.class -youtube_dl_old/ -python/ -gevent/ debug/ data/ banned_addresses.txt -youtube/common_old.py -youtube/common_older.py -youtube/watch_old.py diff --git a/python/brotli.py b/python/brotli.py new file mode 100644 index 0000000..d66966b --- /dev/null +++ b/python/brotli.py @@ -0,0 +1,56 @@ +# Copyright 2016 The Brotli Authors. All rights reserved. +# +# Distributed under MIT license. +# See file LICENSE for detail or copy at https://opensource.org/licenses/MIT + +"""Functions to compress and decompress data using the Brotli library.""" + +import _brotli + + +# The library version. +__version__ = _brotli.__version__ + +# The compression mode. +MODE_GENERIC = _brotli.MODE_GENERIC +MODE_TEXT = _brotli.MODE_TEXT +MODE_FONT = _brotli.MODE_FONT + +# The Compressor object. +Compressor = _brotli.Compressor + +# The Decompressor object. +Decompressor = _brotli.Decompressor + +# Compress a byte string. +def compress(string, mode=MODE_GENERIC, quality=11, lgwin=22, lgblock=0): + """Compress a byte string. + + Args: + string (bytes): The input data. + mode (int, optional): The compression mode can be MODE_GENERIC (default), + MODE_TEXT (for UTF-8 format text input) or MODE_FONT (for WOFF 2.0). + quality (int, optional): Controls the compression-speed vs compression- + density tradeoff. The higher the quality, the slower the compression. + Range is 0 to 11. Defaults to 11. + lgwin (int, optional): Base 2 logarithm of the sliding window size. Range + is 10 to 24. Defaults to 22. + lgblock (int, optional): Base 2 logarithm of the maximum input block size. + Range is 16 to 24. If set to 0, the value will be set based on the + quality. Defaults to 0. + + Returns: + The compressed byte string. + + Raises: + brotli.error: If arguments are invalid, or compressor fails. + """ + compressor = Compressor(mode=mode, quality=quality, lgwin=lgwin, + lgblock=lgblock) + return compressor.process(string) + compressor.finish() + +# Decompress a compressed byte string. +decompress = _brotli.decompress + +# Raised if compression or decompression fails. +error = _brotli.error diff --git a/python/gevent/__init__.py b/python/gevent/__init__.py new file mode 100644 index 0000000..65041cc --- /dev/null +++ b/python/gevent/__init__.py @@ -0,0 +1,136 @@ +# Copyright (c) 2009-2012 Denis Bilenko. See LICENSE for details. +""" +gevent is a coroutine-based Python networking library that uses greenlet +to provide a high-level synchronous API on top of libev event loop. + +See http://www.gevent.org/ for the documentation. +""" + +from __future__ import absolute_import + +from collections import namedtuple + +_version_info = namedtuple('version_info', + ('major', 'minor', 'micro', 'releaselevel', 'serial')) + +#: The programatic version identifier. The fields have (roughly) the +#: same meaning as :data:`sys.version_info` +#: Deprecated in 1.2. +version_info = _version_info(1, 2, 2, 'dev', 0) + +#: The human-readable PEP 440 version identifier +__version__ = '1.2.2' + + +__all__ = ['get_hub', + 'Greenlet', + 'GreenletExit', + 'spawn', + 'spawn_later', + 'spawn_raw', + 'iwait', + 'wait', + 'killall', + 'Timeout', + 'with_timeout', + 'getcurrent', + 'sleep', + 'idle', + 'kill', + 'signal', + 'fork', + 'reinit'] + + +import sys +if sys.platform == 'win32': + # trigger WSAStartup call + import socket # pylint:disable=unused-import,useless-suppression + del socket + +from gevent.hub import get_hub, iwait, wait +from gevent.greenlet import Greenlet, joinall, killall +joinall = joinall # export for pylint +spawn = Greenlet.spawn +spawn_later = Greenlet.spawn_later + +from gevent.timeout import Timeout, with_timeout +from gevent.hub import getcurrent, GreenletExit, spawn_raw, sleep, idle, kill, reinit +try: + from gevent.os import fork +except ImportError: + __all__.remove('fork') + +# See https://github.com/gevent/gevent/issues/648 +# A temporary backwards compatibility shim to enable users to continue +# to treat 'from gevent import signal' as a callable, to matter whether +# the 'gevent.signal' module has been imported first +from gevent.hub import signal as _signal_class +from gevent import signal as _signal_module + +# The object 'gevent.signal' must: +# - be callable, returning a gevent.hub.signal; +# - answer True to isinstance(gevent.signal(...), gevent.signal); +# - answer True to isinstance(gevent.signal(...), gevent.hub.signal) +# - have all the attributes of the module 'gevent.signal'; +# - answer True to isinstance(gevent.signal, types.ModuleType) (optional) + +# The only way to do this is to use a metaclass, an instance of which (a class) +# is put in sys.modules and is substituted for gevent.hub.signal. +# This handles everything except the last one. + + +class _signal_metaclass(type): + + def __getattr__(cls, name): + return getattr(_signal_module, name) + + def __setattr__(cls, name, value): + setattr(_signal_module, name, value) + + def __instancecheck__(cls, instance): + return isinstance(instance, _signal_class) + + def __dir__(cls): + return dir(_signal_module) + + +class signal(object): + + __doc__ = _signal_module.__doc__ + + def __new__(cls, *args, **kwargs): + return _signal_class(*args, **kwargs) + + +# The metaclass is applied after the class declaration +# for Python 2/3 compatibility +signal = _signal_metaclass(str("signal"), + (), + dict(signal.__dict__)) + +sys.modules['gevent.signal'] = signal +sys.modules['gevent.hub'].signal = signal + +del sys + + +# the following makes hidden imports visible to freezing tools like +# py2exe. see https://github.com/gevent/gevent/issues/181 + +def __dependencies_for_freezing(): + # pylint:disable=unused-variable + from gevent import core + from gevent import resolver_thread + from gevent import resolver_ares + from gevent import socket as _socket + from gevent import threadpool + from gevent import thread + from gevent import threading + from gevent import select + from gevent import subprocess + import pprint + import traceback + import signal as _signal + +del __dependencies_for_freezing diff --git a/python/gevent/_compat.py b/python/gevent/_compat.py new file mode 100644 index 0000000..96f5f93 --- /dev/null +++ b/python/gevent/_compat.py @@ -0,0 +1,48 @@ +# -*- coding: utf-8 -*- +""" +internal gevent python 2/python 3 bridges. Not for external use. +""" + +from __future__ import print_function, absolute_import, division + + +import sys + +PY2 = sys.version_info[0] == 2 +PY3 = sys.version_info[0] >= 3 +PYPY = hasattr(sys, 'pypy_version_info') + +## Types + +if PY3: + string_types = (str,) + integer_types = (int,) + text_type = str + +else: + import __builtin__ # pylint:disable=import-error + string_types = __builtin__.basestring, + text_type = __builtin__.unicode + integer_types = (int, __builtin__.long) + + +## Exceptions +if PY3: + def reraise(t, value, tb=None): # pylint:disable=unused-argument + if value.__traceback__ is not tb and tb is not None: + raise value.with_traceback(tb) + raise value + +else: + from gevent._util_py2 import reraise # pylint:disable=import-error,no-name-in-module + reraise = reraise # export + +## Functions +if PY3: + iteritems = dict.items + itervalues = dict.values + xrange = range +else: + iteritems = dict.iteritems # python 3: pylint:disable=no-member + itervalues = dict.itervalues # python 3: pylint:disable=no-member + xrange = __builtin__.xrange diff --git a/python/gevent/_fileobjectcommon.py b/python/gevent/_fileobjectcommon.py new file mode 100644 index 0000000..435f0d8 --- /dev/null +++ b/python/gevent/_fileobjectcommon.py @@ -0,0 +1,128 @@ + +try: + from errno import EBADF +except ImportError: + EBADF = 9 + +from io import TextIOWrapper + +class cancel_wait_ex(IOError): + + def __init__(self): + super(cancel_wait_ex, self).__init__( + EBADF, 'File descriptor was closed in another greenlet') + + +class FileObjectClosed(IOError): + + def __init__(self): + super(FileObjectClosed, self).__init__( + EBADF, 'Bad file descriptor (FileObject was closed)') + +class FileObjectBase(object): + """ + Internal base class to ensure a level of consistency + between FileObjectPosix and FileObjectThread + """ + + # List of methods we delegate to the wrapping IO object, if they + # implement them and we do not. + _delegate_methods = ( + # General methods + 'flush', + 'fileno', + 'writable', + 'readable', + 'seek', + 'seekable', + 'tell', + + # Read + 'read', + 'readline', + 'readlines', + 'read1', + + # Write + 'write', + 'writelines', + 'truncate', + ) + + + # Whether we are translating universal newlines or not. + _translate = False + + def __init__(self, io, closefd): + """ + :param io: An io.IOBase-like object. + """ + self._io = io + # We don't actually use this property ourself, but we save it (and + # pass it along) for compatibility. + self._close = closefd + + if self._translate: + # This automatically handles delegation. + self.translate_newlines(None) + else: + self._do_delegate_methods() + + + io = property(lambda s: s._io, + # Historically we either hand-wrote all the delegation methods + # to use self.io, or we simply used __getattr__ to look them up at + # runtime. This meant people could change the io attribute on the fly + # and it would mostly work (subprocess.py used to do that). We don't recommend + # that, but we still support it. + lambda s, nv: setattr(s, '_io', nv) or s._do_delegate_methods()) + + def _do_delegate_methods(self): + for meth_name in self._delegate_methods: + meth = getattr(self._io, meth_name, None) + implemented_by_class = hasattr(type(self), meth_name) + if meth and not implemented_by_class: + setattr(self, meth_name, self._wrap_method(meth)) + elif hasattr(self, meth_name) and not implemented_by_class: + delattr(self, meth_name) + + def _wrap_method(self, method): + """ + Wrap a method we're copying into our dictionary from the underlying + io object to do something special or different, if necessary. + """ + return method + + def translate_newlines(self, mode, *text_args, **text_kwargs): + wrapper = TextIOWrapper(self._io, *text_args, **text_kwargs) + if mode: + wrapper.mode = mode + self.io = wrapper + self._translate = True + + @property + def closed(self): + """True if the file is closed""" + return self._io is None + + def close(self): + if self._io is None: + return + + io = self._io + self._io = None + self._do_close(io, self._close) + + def _do_close(self, fobj, closefd): + raise NotImplementedError() + + def __getattr__(self, name): + if self._io is None: + raise FileObjectClosed() + return getattr(self._io, name) + + def __repr__(self): + return '<%s _fobj=%r%s>' % (self.__class__.__name__, self.io, self._extra_repr()) + + def _extra_repr(self): + return '' diff --git a/python/gevent/_fileobjectposix.py b/python/gevent/_fileobjectposix.py new file mode 100644 index 0000000..73551cf --- /dev/null +++ b/python/gevent/_fileobjectposix.py @@ -0,0 +1,285 @@ +from __future__ import absolute_import +import os +import io +from io import BufferedReader +from io import BufferedWriter +from io import BytesIO +from io import DEFAULT_BUFFER_SIZE +from io import RawIOBase +from io import UnsupportedOperation + +from gevent._fileobjectcommon import cancel_wait_ex +from gevent._fileobjectcommon import FileObjectBase +from gevent.hub import get_hub +from gevent.os import _read +from gevent.os import _write +from gevent.os import ignored_errors +from gevent.os import make_nonblocking + + +class GreenFileDescriptorIO(RawIOBase): + + # Note that RawIOBase has a __del__ method that calls + # self.close(). (In C implementations like CPython, this is + # the type's tp_dealloc slot; prior to Python 3, the object doesn't + # appear to have a __del__ method, even though it functionally does) + + _read_event = None + _write_event = None + + def __init__(self, fileno, mode='r', closefd=True): + RawIOBase.__init__(self) # Python 2: pylint:disable=no-member,non-parent-init-called + self._closed = False + self._closefd = closefd + self._fileno = fileno + make_nonblocking(fileno) + self._readable = 'r' in mode + self._writable = 'w' in mode + self.hub = get_hub() + + io_watcher = self.hub.loop.io + if self._readable: + self._read_event = io_watcher(fileno, 1) + + if self._writable: + self._write_event = io_watcher(fileno, 2) + + self._seekable = None + + def readable(self): + return self._readable + + def writable(self): + return self._writable + + def seekable(self): + if self._seekable is None: + try: + os.lseek(self._fileno, 0, os.SEEK_CUR) + except OSError: + self._seekable = False + else: + self._seekable = True + return self._seekable + + def fileno(self): + return self._fileno + + @property + def closed(self): + return self._closed + + def close(self): + if self._closed: + return + self.flush() + self._closed = True + if self._readable: + self.hub.cancel_wait(self._read_event, cancel_wait_ex) + if self._writable: + self.hub.cancel_wait(self._write_event, cancel_wait_ex) + fileno = self._fileno + if self._closefd: + self._fileno = None + os.close(fileno) + + # RawIOBase provides a 'read' method that will call readall() if + # the `size` was missing or -1 and otherwise call readinto(). We + # want to take advantage of this to avoid single byte reads when + # possible. This is highlighted by a bug in BufferedIOReader that + # calls read() in a loop when its readall() method is invoked; + # this was fixed in Python 3.3. See + # https://github.com/gevent/gevent/issues/675) + def __read(self, n): + if not self._readable: + raise UnsupportedOperation('read') + while True: + try: + return _read(self._fileno, n) + except (IOError, OSError) as ex: + if ex.args[0] not in ignored_errors: + raise + self.hub.wait(self._read_event) + + def readall(self): + ret = BytesIO() + while True: + data = self.__read(DEFAULT_BUFFER_SIZE) + if not data: + break + ret.write(data) + return ret.getvalue() + + def readinto(self, b): + data = self.__read(len(b)) + n = len(data) + try: + b[:n] = data + except TypeError as err: + import array + if not isinstance(b, array.array): + raise err + b[:n] = array.array(b'b', data) + return n + + def write(self, b): + if not self._writable: + raise UnsupportedOperation('write') + while True: + try: + return _write(self._fileno, b) + except (IOError, OSError) as ex: + if ex.args[0] not in ignored_errors: + raise + self.hub.wait(self._write_event) + + def seek(self, offset, whence=0): + return os.lseek(self._fileno, offset, whence) + +class FlushingBufferedWriter(BufferedWriter): + + def write(self, b): + ret = BufferedWriter.write(self, b) + self.flush() + return ret + +class FileObjectPosix(FileObjectBase): + """ + A file-like object that operates on non-blocking files but + provides a synchronous, cooperative interface. + + .. caution:: + This object is only effective wrapping files that can be used meaningfully + with :func:`select.select` such as sockets and pipes. + + In general, on most platforms, operations on regular files + (e.g., ``open('a_file.txt')``) are considered non-blocking + already, even though they can take some time to complete as + data is copied to the kernel and flushed to disk: this time + is relatively bounded compared to sockets or pipes, though. + A :func:`~os.read` or :func:`~os.write` call on such a file + will still effectively block for some small period of time. + Therefore, wrapping this class around a regular file is + unlikely to make IO gevent-friendly: reading or writing large + amounts of data could still block the event loop. + + If you'll be working with regular files and doing IO in large + chunks, you may consider using + :class:`~gevent.fileobject.FileObjectThread` or + :func:`~gevent.os.tp_read` and :func:`~gevent.os.tp_write` to bypass this + concern. + + .. note:: + Random read/write (e.g., ``mode='rwb'``) is not supported. + For that, use :class:`io.BufferedRWPair` around two instance of this + class. + + .. tip:: + Although this object provides a :meth:`fileno` method and so + can itself be passed to :func:`fcntl.fcntl`, setting the + :data:`os.O_NONBLOCK` flag will have no effect (reads will + still block the greenlet, although other greenlets can run). + However, removing that flag *will cause this object to no + longer be cooperative* (other greenlets will no longer run). + + You can use the internal ``fileio`` attribute of this object + (a :class:`io.RawIOBase`) to perform non-blocking byte reads. + Note, however, that once you begin directly using this + attribute, the results from using methods of *this* object + are undefined, especially in text mode. (See :issue:`222`.) + + .. versionchanged:: 1.1 + Now uses the :mod:`io` package internally. Under Python 2, previously + used the undocumented class :class:`socket._fileobject`. This provides + better file-like semantics (and portability to Python 3). + .. versionchanged:: 1.2a1 + Document the ``fileio`` attribute for non-blocking reads. + """ + + #: platform specific default for the *bufsize* parameter + default_bufsize = io.DEFAULT_BUFFER_SIZE + + def __init__(self, fobj, mode='rb', bufsize=-1, close=True): + """ + :param fobj: Either an integer fileno, or an object supporting the + usual :meth:`socket.fileno` method. The file *will* be + put in non-blocking mode using :func:`gevent.os.make_nonblocking`. + :keyword str mode: The manner of access to the file, one of "rb", "rU" or "wb" + (where the "b" or "U" can be omitted). + If "U" is part of the mode, IO will be done on text, otherwise bytes. + :keyword int bufsize: If given, the size of the buffer to use. The default + value means to use a platform-specific default + Other values are interpreted as for the :mod:`io` package. + Buffering is ignored in text mode. + + .. versionchanged:: 1.2a1 + + A bufsize of 0 in write mode is no longer forced to be 1. + Instead, the underlying buffer is flushed after every write + operation to simulate a bufsize of 0. In gevent 1.0, a + bufsize of 0 was flushed when a newline was written, while + in gevent 1.1 it was flushed when more than one byte was + written. Note that this may have performance impacts. + """ + + if isinstance(fobj, int): + fileno = fobj + fobj = None + else: + fileno = fobj.fileno() + if not isinstance(fileno, int): + raise TypeError('fileno must be int: %r' % fileno) + + orig_mode = mode + mode = (mode or 'rb').replace('b', '') + if 'U' in mode: + self._translate = True + mode = mode.replace('U', '') + else: + self._translate = False + + if len(mode) != 1 and mode not in 'rw': # pragma: no cover + # Python 3 builtin `open` raises a ValueError for invalid modes; + # Python 2 ignores it. In the past, we raised an AssertionError, if __debug__ was + # enabled (which it usually was). Match Python 3 because it makes more sense + # and because __debug__ may not be enabled. + # NOTE: This is preventing a mode like 'rwb' for binary random access; + # that code was never tested and was explicitly marked as "not used" + raise ValueError('mode can only be [rb, rU, wb], not %r' % (orig_mode,)) + + self._fobj = fobj + + # This attribute is documented as available for non-blocking reads. + self.fileio = GreenFileDescriptorIO(fileno, mode, closefd=close) + + self._orig_bufsize = bufsize + if bufsize < 0 or bufsize == 1: + bufsize = self.default_bufsize + elif bufsize == 0: + bufsize = 1 + + if mode == 'r': + IOFamily = BufferedReader + else: + assert mode == 'w' + IOFamily = BufferedWriter + if self._orig_bufsize == 0: + # We could also simply pass self.fileio as *io*, but this way + # we at least consistently expose a BufferedWriter in our *io* + # attribute. + IOFamily = FlushingBufferedWriter + + super(FileObjectPosix, self).__init__(IOFamily(self.fileio, bufsize), close) + + def _do_close(self, fobj, closefd): + try: + fobj.close() + # self.fileio already knows whether or not to close the + # file descriptor + self.fileio.close() + finally: + self._fobj = None + self.fileio = None + + def __iter__(self): + return self._io diff --git a/python/gevent/_semaphore.pxd b/python/gevent/_semaphore.pxd new file mode 100644 index 0000000..6382d56 --- /dev/null +++ b/python/gevent/_semaphore.pxd @@ -0,0 +1,23 @@ +cdef class Semaphore: + cdef public int counter + cdef readonly object _links + cdef readonly object _notifier + cdef public int _dirty + cdef object __weakref__ + + cpdef bint locked(self) + cpdef int release(self) except -1000 + cpdef rawlink(self, object callback) + cpdef unlink(self, object callback) + cpdef _start_notify(self) + cpdef _notify_links(self) + cdef _do_wait(self, object timeout) + cpdef int wait(self, object timeout=*) except -1000 + cpdef bint acquire(self, int blocking=*, object timeout=*) except -1000 + cpdef __enter__(self) + cpdef __exit__(self, object t, object v, object tb) + +cdef class BoundedSemaphore(Semaphore): + cdef readonly int _initial_value + + cpdef int release(self) except -1000 diff --git a/python/gevent/_semaphore.py b/python/gevent/_semaphore.py new file mode 100644 index 0000000..c6e1162 --- /dev/null +++ b/python/gevent/_semaphore.py @@ -0,0 +1,269 @@ +import sys +from gevent.hub import get_hub, getcurrent +from gevent.timeout import Timeout + + +__all__ = ['Semaphore', 'BoundedSemaphore'] + + +class Semaphore(object): + """ + Semaphore(value=1) -> Semaphore + + A semaphore manages a counter representing the number of release() + calls minus the number of acquire() calls, plus an initial value. + The acquire() method blocks if necessary until it can return + without making the counter negative. + + If not given, ``value`` defaults to 1. + + The semaphore is a context manager and can be used in ``with`` statements. + + This Semaphore's ``__exit__`` method does not call the trace function + on CPython, but does under PyPy. + + .. seealso:: :class:`BoundedSemaphore` for a safer version that prevents + some classes of bugs. + """ + + def __init__(self, value=1): + if value < 0: + raise ValueError("semaphore initial value must be >= 0") + self.counter = value + self._dirty = False + # In PyPy 2.6.1 with Cython 0.23, `cdef public` or `cdef + # readonly` or simply `cdef` attributes of type `object` can appear to leak if + # a Python subclass is used (this is visible simply + # instantiating this subclass if _links=[]). Our _links and + # _notifier are such attributes, and gevent.thread subclasses + # this class. Thus, we carefully manage the lifetime of the + # objects we put in these attributes so that, in the normal + # case of a semaphore used correctly (deallocated when it's not + # locked and no one is waiting), the leak goes away (because + # these objects are back to None). This can also be solved on PyPy + # by simply not declaring these objects in the pxd file, but that doesn't work for + # CPython ("No attribute...") + # See https://github.com/gevent/gevent/issues/660 + self._links = None + self._notifier = None + # we don't want to do get_hub() here to allow defining module-level locks + # without initializing the hub + + def __str__(self): + params = (self.__class__.__name__, self.counter, len(self._links) if self._links else 0) + return '<%s counter=%s _links[%s]>' % params + + def locked(self): + """Return a boolean indicating whether the semaphore can be acquired. + Most useful with binary semaphores.""" + return self.counter <= 0 + + def release(self): + """ + Release the semaphore, notifying any waiters if needed. + """ + self.counter += 1 + self._start_notify() + return self.counter + + def _start_notify(self): + if self._links and self.counter > 0 and not self._notifier: + # We create a new self._notifier each time through the loop, + # if needed. (it has a __bool__ method that tells whether it has + # been run; once it's run once---at the end of the loop---it becomes + # false.) + # NOTE: Passing the bound method will cause a memory leak on PyPy + # with Cython <= 0.23.3. You must use >= 0.23.4. + # See https://bitbucket.org/pypy/pypy/issues/2149/memory-leak-for-python-subclass-of-cpyext#comment-22371546 + self._notifier = get_hub().loop.run_callback(self._notify_links) + + def _notify_links(self): + # Subclasses CANNOT override. This is a cdef method. + + # We release self._notifier here. We are called by it + # at the end of the loop, and it is now false in a boolean way (as soon + # as this method returns). + # If we get acquired/released again, we will create a new one, but there's + # no need to keep it around until that point (making it potentially climb + # into older GC generations, notably on PyPy) + notifier = self._notifier + try: + while True: + self._dirty = False + if not self._links: + # In case we were manually unlinked before + # the callback. Which shouldn't happen + return + for link in self._links: + if self.counter <= 0: + return + try: + link(self) # Must use Cython >= 0.23.4 on PyPy else this leaks memory + except: # pylint:disable=bare-except + getcurrent().handle_error((link, self), *sys.exc_info()) + if self._dirty: + # We mutated self._links so we need to start over + break + if not self._dirty: + return + finally: + # We should not have created a new notifier even if callbacks + # released us because we loop through *all* of our links on the + # same callback while self._notifier is still true. + assert self._notifier is notifier + self._notifier = None + + def rawlink(self, callback): + """ + rawlink(callback) -> None + + Register a callback to call when a counter is more than zero. + + *callback* will be called in the :class:`Hub `, so it must not use blocking gevent API. + *callback* will be passed one argument: this instance. + + This method is normally called automatically by :meth:`acquire` and :meth:`wait`; most code + will not need to use it. + """ + if not callable(callback): + raise TypeError('Expected callable:', callback) + if self._links is None: + self._links = [callback] + else: + self._links.append(callback) + self._dirty = True + + def unlink(self, callback): + """ + unlink(callback) -> None + + Remove the callback set by :meth:`rawlink`. + + This method is normally called automatically by :meth:`acquire` and :meth:`wait`; most + code will not need to use it. + """ + try: + self._links.remove(callback) + self._dirty = True + except (ValueError, AttributeError): + pass + if not self._links: + self._links = None + # TODO: Cancel a notifier if there are no links? + + def _do_wait(self, timeout): + """ + Wait for up to *timeout* seconds to expire. If timeout + elapses, return the exception. Otherwise, return None. + Raises timeout if a different timer expires. + """ + switch = getcurrent().switch + self.rawlink(switch) + try: + timer = Timeout._start_new_or_dummy(timeout) + try: + try: + result = get_hub().switch() + assert result is self, 'Invalid switch into Semaphore.wait/acquire(): %r' % (result, ) + except Timeout as ex: + if ex is not timer: + raise + return ex + finally: + timer.cancel() + finally: + self.unlink(switch) + + def wait(self, timeout=None): + """ + wait(timeout=None) -> int + + Wait until it is possible to acquire this semaphore, or until the optional + *timeout* elapses. + + .. caution:: If this semaphore was initialized with a size of 0, + this method will block forever if no timeout is given. + + :keyword float timeout: If given, specifies the maximum amount of seconds + this method will block. + :return: A number indicating how many times the semaphore can be acquired + before blocking. + """ + if self.counter > 0: + return self.counter + + self._do_wait(timeout) # return value irrelevant, whether we got it or got a timeout + return self.counter + + def acquire(self, blocking=True, timeout=None): + """ + acquire(blocking=True, timeout=None) -> bool + + Acquire the semaphore. + + .. caution:: If this semaphore was initialized with a size of 0, + this method will block forever (unless a timeout is given or blocking is + set to false). + + :keyword bool blocking: If True (the default), this function will block + until the semaphore is acquired. + :keyword float timeout: If given, specifies the maximum amount of seconds + this method will block. + :return: A boolean indicating whether the semaphore was acquired. + If ``blocking`` is True and ``timeout`` is None (the default), then + (so long as this semaphore was initialized with a size greater than 0) + this will always return True. If a timeout was given, and it expired before + the semaphore was acquired, False will be returned. (Note that this can still + raise a ``Timeout`` exception, if some other caller had already started a timer.) + """ + if self.counter > 0: + self.counter -= 1 + return True + + if not blocking: + return False + + timeout = self._do_wait(timeout) + if timeout is not None: + # Our timer expired. + return False + + # Neither our timer no another one expired, so we blocked until + # awoke. Therefore, the counter is ours + self.counter -= 1 + assert self.counter >= 0 + return True + + _py3k_acquire = acquire # PyPy needs this; it must be static for Cython + + def __enter__(self): + self.acquire() + + def __exit__(self, t, v, tb): + self.release() + + +class BoundedSemaphore(Semaphore): + """ + BoundedSemaphore(value=1) -> BoundedSemaphore + + A bounded semaphore checks to make sure its current value doesn't + exceed its initial value. If it does, :class:`ValueError` is + raised. In most situations semaphores are used to guard resources + with limited capacity. If the semaphore is released too many times + it's a sign of a bug. + + If not given, *value* defaults to 1. + """ + + #: For monkey-patching, allow changing the class of error we raise + _OVER_RELEASE_ERROR = ValueError + + def __init__(self, *args, **kwargs): + Semaphore.__init__(self, *args, **kwargs) + self._initial_value = self.counter + + def release(self): + if self.counter >= self._initial_value: + raise self._OVER_RELEASE_ERROR("Semaphore released too many times") + return Semaphore.release(self) diff --git a/python/gevent/_socket2.py b/python/gevent/_socket2.py new file mode 100644 index 0000000..dbcf1f7 --- /dev/null +++ b/python/gevent/_socket2.py @@ -0,0 +1,539 @@ +# Copyright (c) 2009-2014 Denis Bilenko and gevent contributors. See LICENSE for details. +""" +Python 2 socket module. +""" +# Our import magic sadly makes this warning useless +# pylint: disable=undefined-variable + +import time +from gevent import _socketcommon +from gevent._util import copy_globals +from gevent._compat import PYPY + +copy_globals(_socketcommon, globals(), + names_to_ignore=_socketcommon.__py3_imports__ + _socketcommon.__extensions__, + dunder_names_to_keep=()) + +__socket__ = _socketcommon.__socket__ +__implements__ = _socketcommon._implements +__extensions__ = _socketcommon.__extensions__ +__imports__ = [i for i in _socketcommon.__imports__ if i not in _socketcommon.__py3_imports__] +__dns__ = _socketcommon.__dns__ +try: + _fileobject = __socket__._fileobject + _socketmethods = __socket__._socketmethods +except AttributeError: + # Allow this module to be imported under Python 3 + # for building the docs + _fileobject = object + _socketmethods = ('bind', 'connect', 'connect_ex', + 'fileno', 'listen', 'getpeername', + 'getsockname', 'getsockopt', + 'setsockopt', 'sendall', + 'setblocking', 'settimeout', + 'gettimeout', 'shutdown') +else: + # Python 2 doesn't natively support with statements on _fileobject; + # but it eases our test cases if we can do the same with on both Py3 + # and Py2. Implementation copied from Python 3 + if not hasattr(_fileobject, '__enter__'): + # we could either patch in place: + #_fileobject.__enter__ = lambda self: self + #_fileobject.__exit__ = lambda self, *args: self.close() if not self.closed else None + # or we could subclass. subclassing has the benefit of not + # changing the behaviour of the stdlib if we're just imported; OTOH, + # under Python 2.6/2.7, test_urllib2net.py asserts that the class IS + # socket._fileobject (sigh), so we have to work around that. + class _fileobject(_fileobject): # pylint:disable=function-redefined + + def __enter__(self): + return self + + def __exit__(self, *args): + if not self.closed: + self.close() + +def _get_memory(data): + try: + mv = memoryview(data) + if mv.shape: + return mv + # No shape, probably working with a ctypes object, + # or something else exotic that supports the buffer interface + return mv.tobytes() + except TypeError: + # fixes "python2.7 array.array doesn't support memoryview used in + # gevent.socket.send" issue + # (http://code.google.com/p/gevent/issues/detail?id=94) + return buffer(data) + + +class _closedsocket(object): + __slots__ = [] + + def _dummy(*args, **kwargs): # pylint:disable=no-method-argument,unused-argument + raise error(EBADF, 'Bad file descriptor') + # All _delegate_methods must also be initialized here. + send = recv = recv_into = sendto = recvfrom = recvfrom_into = _dummy + + if PYPY: + + def _drop(self): + pass + + def _reuse(self): + pass + + __getattr__ = _dummy + + +timeout_default = object() + + +class socket(object): + """ + gevent `socket.socket `_ + for Python 2. + + This object should have the same API as the standard library socket linked to above. Not all + methods are specifically documented here; when they are they may point out a difference + to be aware of or may document a method the standard library does not. + """ + + # pylint:disable=too-many-public-methods + + def __init__(self, family=AF_INET, type=SOCK_STREAM, proto=0, _sock=None): + if _sock is None: + self._sock = _realsocket(family, type, proto) + self.timeout = _socket.getdefaulttimeout() + else: + if hasattr(_sock, '_sock'): + self._sock = _sock._sock + self.timeout = getattr(_sock, 'timeout', False) + if self.timeout is False: + self.timeout = _socket.getdefaulttimeout() + else: + self._sock = _sock + self.timeout = _socket.getdefaulttimeout() + if PYPY: + self._sock._reuse() + self._sock.setblocking(0) + fileno = self._sock.fileno() + self.hub = get_hub() + io = self.hub.loop.io + self._read_event = io(fileno, 1) + self._write_event = io(fileno, 2) + + def __repr__(self): + return '<%s at %s %s>' % (type(self).__name__, hex(id(self)), self._formatinfo()) + + def __str__(self): + return '<%s %s>' % (type(self).__name__, self._formatinfo()) + + def _formatinfo(self): + # pylint:disable=broad-except + try: + fileno = self.fileno() + except Exception as ex: + fileno = str(ex) + try: + sockname = self.getsockname() + sockname = '%s:%s' % sockname + except Exception: + sockname = None + try: + peername = self.getpeername() + peername = '%s:%s' % peername + except Exception: + peername = None + result = 'fileno=%s' % fileno + if sockname is not None: + result += ' sock=' + str(sockname) + if peername is not None: + result += ' peer=' + str(peername) + if getattr(self, 'timeout', None) is not None: + result += ' timeout=' + str(self.timeout) + return result + + def _get_ref(self): + return self._read_event.ref or self._write_event.ref + + def _set_ref(self, value): + self._read_event.ref = value + self._write_event.ref = value + + ref = property(_get_ref, _set_ref) + + def _wait(self, watcher, timeout_exc=timeout('timed out')): + """Block the current greenlet until *watcher* has pending events. + + If *timeout* is non-negative, then *timeout_exc* is raised after *timeout* second has passed. + By default *timeout_exc* is ``socket.timeout('timed out')``. + + If :func:`cancel_wait` is called, raise ``socket.error(EBADF, 'File descriptor was closed in another greenlet')``. + """ + if watcher.callback is not None: + raise _socketcommon.ConcurrentObjectUseError('This socket is already used by another greenlet: %r' % (watcher.callback, )) + if self.timeout is not None: + timeout = Timeout.start_new(self.timeout, timeout_exc, ref=False) + else: + timeout = None + try: + self.hub.wait(watcher) + finally: + if timeout is not None: + timeout.cancel() + + def accept(self): + sock = self._sock + while True: + try: + client_socket, address = sock.accept() + break + except error as ex: + if ex.args[0] != EWOULDBLOCK or self.timeout == 0.0: + raise + sys.exc_clear() + self._wait(self._read_event) + sockobj = socket(_sock=client_socket) + if PYPY: + client_socket._drop() + return sockobj, address + + def close(self, _closedsocket=_closedsocket, cancel_wait_ex=cancel_wait_ex): + # This function should not reference any globals. See Python issue #808164. + self.hub.cancel_wait(self._read_event, cancel_wait_ex) + self.hub.cancel_wait(self._write_event, cancel_wait_ex) + s = self._sock + self._sock = _closedsocket() + if PYPY: + s._drop() + + @property + def closed(self): + return isinstance(self._sock, _closedsocket) + + def connect(self, address): + if self.timeout == 0.0: + return self._sock.connect(address) + sock = self._sock + if isinstance(address, tuple): + r = getaddrinfo(address[0], address[1], sock.family) + address = r[0][-1] + if self.timeout is not None: + timer = Timeout.start_new(self.timeout, timeout('timed out')) + else: + timer = None + try: + while True: + err = sock.getsockopt(SOL_SOCKET, SO_ERROR) + if err: + raise error(err, strerror(err)) + result = sock.connect_ex(address) + if not result or result == EISCONN: + break + elif (result in (EWOULDBLOCK, EINPROGRESS, EALREADY)) or (result == EINVAL and is_windows): + self._wait(self._write_event) + else: + raise error(result, strerror(result)) + finally: + if timer is not None: + timer.cancel() + + def connect_ex(self, address): + try: + return self.connect(address) or 0 + except timeout: + return EAGAIN + except error as ex: + if type(ex) is error: # pylint:disable=unidiomatic-typecheck + return ex.args[0] + else: + raise # gaierror is not silenced by connect_ex + + def dup(self): + """dup() -> socket object + + Return a new socket object connected to the same system resource. + Note, that the new socket does not inherit the timeout.""" + return socket(_sock=self._sock) + + def makefile(self, mode='r', bufsize=-1): + # Two things to look out for: + # 1) Closing the original socket object should not close the + # socket (hence creating a new instance) + # 2) The resulting fileobject must keep the timeout in order + # to be compatible with the stdlib's socket.makefile. + # Pass self as _sock to preserve timeout. + fobj = _fileobject(type(self)(_sock=self), mode, bufsize) + if PYPY: + self._sock._drop() + return fobj + + def recv(self, *args): + sock = self._sock # keeping the reference so that fd is not closed during waiting + while True: + try: + return sock.recv(*args) + except error as ex: + if ex.args[0] != EWOULDBLOCK or self.timeout == 0.0: + raise + # QQQ without clearing exc_info test__refcount.test_clean_exit fails + sys.exc_clear() + self._wait(self._read_event) + + def recvfrom(self, *args): + sock = self._sock + while True: + try: + return sock.recvfrom(*args) + except error as ex: + if ex.args[0] != EWOULDBLOCK or self.timeout == 0.0: + raise + sys.exc_clear() + self._wait(self._read_event) + + def recvfrom_into(self, *args): + sock = self._sock + while True: + try: + return sock.recvfrom_into(*args) + except error as ex: + if ex.args[0] != EWOULDBLOCK or self.timeout == 0.0: + raise + sys.exc_clear() + self._wait(self._read_event) + + def recv_into(self, *args): + sock = self._sock + while True: + try: + return sock.recv_into(*args) + except error as ex: + if ex.args[0] != EWOULDBLOCK or self.timeout == 0.0: + raise + sys.exc_clear() + self._wait(self._read_event) + + def send(self, data, flags=0, timeout=timeout_default): + sock = self._sock + if timeout is timeout_default: + timeout = self.timeout + try: + return sock.send(data, flags) + except error as ex: + if ex.args[0] != EWOULDBLOCK or timeout == 0.0: + raise + sys.exc_clear() + self._wait(self._write_event) + try: + return sock.send(data, flags) + except error as ex2: + if ex2.args[0] == EWOULDBLOCK: + return 0 + raise + + def __send_chunk(self, data_memory, flags, timeleft, end): + """ + Send the complete contents of ``data_memory`` before returning. + This is the core loop around :meth:`send`. + + :param timeleft: Either ``None`` if there is no timeout involved, + or a float indicating the timeout to use. + :param end: Either ``None`` if there is no timeout involved, or + a float giving the absolute end time. + :return: An updated value for ``timeleft`` (or None) + :raises timeout: If ``timeleft`` was given and elapsed while + sending this chunk. + """ + data_sent = 0 + len_data_memory = len(data_memory) + started_timer = 0 + while data_sent < len_data_memory: + chunk = data_memory[data_sent:] + if timeleft is None: + data_sent += self.send(chunk, flags) + elif started_timer and timeleft <= 0: + # Check before sending to guarantee a check + # happens even if each chunk successfully sends its data + # (especially important for SSL sockets since they have large + # buffers). But only do this if we've actually tried to + # send something once to avoid spurious timeouts on non-blocking + # sockets. + raise timeout('timed out') + else: + started_timer = 1 + data_sent += self.send(chunk, flags, timeout=timeleft) + timeleft = end - time.time() + + return timeleft + + def sendall(self, data, flags=0): + if isinstance(data, unicode): + data = data.encode() + # this sendall is also reused by gevent.ssl.SSLSocket subclass, + # so it should not call self._sock methods directly + data_memory = _get_memory(data) + len_data_memory = len(data_memory) + if not len_data_memory: + # Don't send empty data, can cause SSL EOFError. + # See issue 719 + return 0 + + # On PyPy up through 2.6.0, subviews of a memoryview() object + # copy the underlying bytes the first time the builtin + # socket.send() method is called. On a non-blocking socket + # (that thus calls socket.send() many times) with a large + # input, this results in many repeated copies of an ever + # smaller string, depending on the networking buffering. For + # example, if each send() can process 1MB of a 50MB input, and + # we naively pass the entire remaining subview each time, we'd + # copy 49MB, 48MB, 47MB, etc, thus completely killing + # performance. To workaround this problem, we work in + # reasonable, fixed-size chunks. This results in a 10x + # improvement to bench_sendall.py, while having no measurable impact on + # CPython (since it doesn't copy at all the only extra overhead is + # a few python function calls, which is negligible for large inputs). + + # See https://bitbucket.org/pypy/pypy/issues/2091/non-blocking-socketsend-slow-gevent + + # Too small of a chunk (the socket's buf size is usually too + # small) results in reduced perf due to *too many* calls to send and too many + # small copies. With a buffer of 143K (the default on my system), for + # example, bench_sendall.py yields ~264MB/s, while using 1MB yields + # ~653MB/s (matching CPython). 1MB is arbitrary and might be better + # chosen, say, to match a page size? + chunk_size = max(self.getsockopt(SOL_SOCKET, SO_SNDBUF), 1024 * 1024) # pylint:disable=no-member + + data_sent = 0 + end = None + timeleft = None + if self.timeout is not None: + timeleft = self.timeout + end = time.time() + timeleft + + while data_sent < len_data_memory: + chunk_end = min(data_sent + chunk_size, len_data_memory) + chunk = data_memory[data_sent:chunk_end] + + timeleft = self.__send_chunk(chunk, flags, timeleft, end) + data_sent += len(chunk) # Guaranteed it sent the whole thing + + def sendto(self, *args): + sock = self._sock + try: + return sock.sendto(*args) + except error as ex: + if ex.args[0] != EWOULDBLOCK or self.timeout == 0.0: + raise + sys.exc_clear() + self._wait(self._write_event) + try: + return sock.sendto(*args) + except error as ex2: + if ex2.args[0] == EWOULDBLOCK: + return 0 + raise + + def setblocking(self, flag): + if flag: + self.timeout = None + else: + self.timeout = 0.0 + + def settimeout(self, howlong): + if howlong is not None: + try: + f = howlong.__float__ + except AttributeError: + raise TypeError('a float is required') + howlong = f() + if howlong < 0.0: + raise ValueError('Timeout value out of range') + self.__dict__['timeout'] = howlong # avoid recursion with any property on self.timeout + + def gettimeout(self): + return self.__dict__['timeout'] # avoid recursion with any property on self.timeout + + def shutdown(self, how): + if how == 0: # SHUT_RD + self.hub.cancel_wait(self._read_event, cancel_wait_ex) + elif how == 1: # SHUT_WR + self.hub.cancel_wait(self._write_event, cancel_wait_ex) + else: + self.hub.cancel_wait(self._read_event, cancel_wait_ex) + self.hub.cancel_wait(self._write_event, cancel_wait_ex) + self._sock.shutdown(how) + + family = property(lambda self: self._sock.family) + type = property(lambda self: self._sock.type) + proto = property(lambda self: self._sock.proto) + + def fileno(self): + return self._sock.fileno() + + def getsockname(self): + return self._sock.getsockname() + + def getpeername(self): + return self._sock.getpeername() + + # delegate the functions that we haven't implemented to the real socket object + + _s = "def %s(self, *args): return self._sock.%s(*args)\n\n" + _m = None + for _m in set(_socketmethods) - set(locals()): + exec(_s % (_m, _m,)) + del _m, _s + + if PYPY: + + def _reuse(self): + self._sock._reuse() + + def _drop(self): + self._sock._drop() + + +SocketType = socket + +if hasattr(_socket, 'socketpair'): + + def socketpair(family=getattr(_socket, 'AF_UNIX', _socket.AF_INET), + type=_socket.SOCK_STREAM, proto=0): + one, two = _socket.socketpair(family, type, proto) + result = socket(_sock=one), socket(_sock=two) + if PYPY: + one._drop() + two._drop() + return result +elif 'socketpair' in __implements__: + __implements__.remove('socketpair') + +if hasattr(_socket, 'fromfd'): + + def fromfd(fd, family, type, proto=0): + s = _socket.fromfd(fd, family, type, proto) + result = socket(_sock=s) + if PYPY: + s._drop() + return result + +elif 'fromfd' in __implements__: + __implements__.remove('fromfd') + +if hasattr(__socket__, 'ssl'): + + def ssl(sock, keyfile=None, certfile=None): + # deprecated in 2.7.9 but still present; + # sometimes backported by distros. See ssl.py + # Note that we import gevent.ssl, not _ssl2, to get the correct + # version. + from gevent import ssl as _sslmod + # wrap_socket is 2.7.9/backport, sslwrap_simple is older. They take + # the same arguments. + wrap = getattr(_sslmod, 'wrap_socket', None) or getattr(_sslmod, 'sslwrap_simple') + return wrap(sock, keyfile, certfile) + __implements__.append('ssl') + +__all__ = __implements__ + __extensions__ + __imports__ diff --git a/python/gevent/_socket3.py b/python/gevent/_socket3.py new file mode 100644 index 0000000..d659d88 --- /dev/null +++ b/python/gevent/_socket3.py @@ -0,0 +1,1065 @@ +# Port of Python 3.3's socket module to gevent +""" +Python 3 socket module. +""" +# Our import magic sadly makes this warning useless +# pylint: disable=undefined-variable +# pylint: disable=too-many-statements,too-many-branches +# pylint: disable=too-many-public-methods,unused-argument +from __future__ import absolute_import +import io +import os +import sys +import time +from gevent import _socketcommon +from gevent._util import copy_globals +from gevent._compat import PYPY +import _socket +from os import dup + +copy_globals(_socketcommon, globals(), + names_to_ignore=_socketcommon.__extensions__, + dunder_names_to_keep=()) + +__socket__ = _socketcommon.__socket__ +__implements__ = _socketcommon._implements +__extensions__ = _socketcommon.__extensions__ +__imports__ = _socketcommon.__imports__ +__dns__ = _socketcommon.__dns__ + + +SocketIO = __socket__.SocketIO # pylint:disable=no-member + + +def _get_memory(data): + mv = memoryview(data) + if mv.shape: + return mv + # No shape, probably working with a ctypes object, + # or something else exotic that supports the buffer interface + return mv.tobytes() + +timeout_default = object() + + +class _wrefsocket(_socket.socket): + # Plain stdlib socket.socket objects subclass _socket.socket + # and add weakref ability. The ssl module, for one, counts on this. + # We don't create socket.socket objects (because they may have been + # monkey patched to be the object from this module), but we still + # need to make sure what we do create can be weakrefd. + + __slots__ = ("__weakref__", ) + + if PYPY: + # server.py unwraps the socket object to get the raw _sock; + # it depends on having a timeout property alias, which PyPy does not + # provide. + timeout = property(lambda s: s.gettimeout(), + lambda s, nv: s.settimeout(nv)) + + +class socket(object): + """ + gevent `socket.socket `_ + for Python 3. + + This object should have the same API as the standard library socket linked to above. Not all + methods are specifically documented here; when they are they may point out a difference + to be aware of or may document a method the standard library does not. + """ + + # Subclasses can set this to customize the type of the + # native _socket.socket we create. It MUST be a subclass + # of _wrefsocket. (gevent internal usage only) + _gevent_sock_class = _wrefsocket + + def __init__(self, family=AF_INET, type=SOCK_STREAM, proto=0, fileno=None): + # Take the same approach as socket2: wrap a real socket object, + # don't subclass it. This lets code that needs the raw _sock (not tied to the hub) + # get it. This shows up in tests like test__example_udp_server. + self._sock = self._gevent_sock_class(family, type, proto, fileno) + self._io_refs = 0 + self._closed = False + _socket.socket.setblocking(self._sock, False) + fileno = _socket.socket.fileno(self._sock) + self.hub = get_hub() + io_class = self.hub.loop.io + self._read_event = io_class(fileno, 1) + self._write_event = io_class(fileno, 2) + self.timeout = _socket.getdefaulttimeout() + + def __getattr__(self, name): + return getattr(self._sock, name) + + if hasattr(_socket, 'SOCK_NONBLOCK'): + # Only defined under Linux + @property + def type(self): + # See https://github.com/gevent/gevent/pull/399 + if self.timeout != 0.0: + return self._sock.type & ~_socket.SOCK_NONBLOCK # pylint:disable=no-member + return self._sock.type + + def __enter__(self): + return self + + def __exit__(self, *args): + if not self._closed: + self.close() + + def __repr__(self): + """Wrap __repr__() to reveal the real class name.""" + try: + s = _socket.socket.__repr__(self._sock) + except Exception as ex: # pylint:disable=broad-except + # Observed on Windows Py3.3, printing the repr of a socket + # that just sufferred a ConnectionResetError [WinError 10054]: + # "OverflowError: no printf formatter to display the socket descriptor in decimal" + # Not sure what the actual cause is or if there's a better way to handle this + s = '' % ex + + if s.startswith(" socket object + + Return a new socket object connected to the same system resource. + """ + fd = dup(self.fileno()) + sock = self.__class__(self.family, self.type, self.proto, fileno=fd) + sock.settimeout(self.gettimeout()) + return sock + + def accept(self): + """accept() -> (socket object, address info) + + Wait for an incoming connection. Return a new socket + representing the connection, and the address of the client. + For IP sockets, the address info is a pair (hostaddr, port). + """ + while True: + try: + fd, addr = self._accept() + break + except BlockingIOError: + if self.timeout == 0.0: + raise + self._wait(self._read_event) + sock = socket(self.family, self.type, self.proto, fileno=fd) + # Python Issue #7995: if no default timeout is set and the listening + # socket had a (non-zero) timeout, force the new socket in blocking + # mode to override platform-specific socket flags inheritance. + # XXX do we need to do this? + if getdefaulttimeout() is None and self.gettimeout(): + sock.setblocking(True) + return sock, addr + + def makefile(self, mode="r", buffering=None, *, + encoding=None, errors=None, newline=None): + """Return an I/O stream connected to the socket + + The arguments are as for io.open() after the filename, + except the only mode characters supported are 'r', 'w' and 'b'. + The semantics are similar too. + """ + # (XXX refactor to share code?) + for c in mode: + if c not in {"r", "w", "b"}: + raise ValueError("invalid mode %r (only r, w, b allowed)") + writing = "w" in mode + reading = "r" in mode or not writing + assert reading or writing + binary = "b" in mode + rawmode = "" + if reading: + rawmode += "r" + if writing: + rawmode += "w" + raw = SocketIO(self, rawmode) + self._io_refs += 1 + if buffering is None: + buffering = -1 + if buffering < 0: + buffering = io.DEFAULT_BUFFER_SIZE + if buffering == 0: + if not binary: + raise ValueError("unbuffered streams must be binary") + return raw + if reading and writing: + buffer = io.BufferedRWPair(raw, raw, buffering) + elif reading: + buffer = io.BufferedReader(raw, buffering) + else: + assert writing + buffer = io.BufferedWriter(raw, buffering) + if binary: + return buffer + text = io.TextIOWrapper(buffer, encoding, errors, newline) + text.mode = mode + return text + + def _decref_socketios(self): + if self._io_refs > 0: + self._io_refs -= 1 + if self._closed: + self.close() + + def _real_close(self, _ss=_socket.socket, cancel_wait_ex=cancel_wait_ex): + # This function should not reference any globals. See Python issue #808164. + self.hub.cancel_wait(self._read_event, cancel_wait_ex) + self.hub.cancel_wait(self._write_event, cancel_wait_ex) + _ss.close(self._sock) + + # Break any references to the underlying socket object. Tested + # by test__refcount. (Why does this matter?). Be sure to + # preserve our same family/type/proto if possible (if we + # don't, we can get TypeError instead of OSError; see + # test_socket.SendmsgUDP6Test.testSendmsgAfterClose)... but + # this isn't always possible (see test_socket.test_unknown_socket_family_repr) + # TODO: Can we use a simpler proxy, like _socket2 does? + try: + self._sock = self._gevent_sock_class(self.family, self.type, self.proto) + except OSError: + pass + else: + _ss.close(self._sock) + + + def close(self): + # This function should not reference any globals. See Python issue #808164. + self._closed = True + if self._io_refs <= 0: + self._real_close() + + @property + def closed(self): + return self._closed + + def detach(self): + """detach() -> file descriptor + + Close the socket object without closing the underlying file descriptor. + The object cannot be used after this call, but the file descriptor + can be reused for other purposes. The file descriptor is returned. + """ + self._closed = True + return self._sock.detach() + + def connect(self, address): + if self.timeout == 0.0: + return _socket.socket.connect(self._sock, address) + if isinstance(address, tuple): + r = getaddrinfo(address[0], address[1], self.family) + address = r[0][-1] + if self.timeout is not None: + timer = Timeout.start_new(self.timeout, timeout('timed out')) + else: + timer = None + try: + while True: + err = self.getsockopt(SOL_SOCKET, SO_ERROR) + if err: + raise error(err, strerror(err)) + result = _socket.socket.connect_ex(self._sock, address) + if not result or result == EISCONN: + break + elif (result in (EWOULDBLOCK, EINPROGRESS, EALREADY)) or (result == EINVAL and is_windows): + self._wait(self._write_event) + else: + raise error(result, strerror(result)) + finally: + if timer is not None: + timer.cancel() + + def connect_ex(self, address): + try: + return self.connect(address) or 0 + except timeout: + return EAGAIN + except gaierror: + # gaierror/overflowerror/typerror is not silenced by connect_ex; + # gaierror extends OSError (aka error) so catch it first + raise + except error as ex: + # error is now OSError and it has various subclasses. + # Only those that apply to actually connecting are silenced by + # connect_ex. + if ex.errno: + return ex.errno + raise # pragma: no cover + + def recv(self, *args): + while True: + try: + return _socket.socket.recv(self._sock, *args) + except error as ex: + if ex.args[0] != EWOULDBLOCK or self.timeout == 0.0: + raise + self._wait(self._read_event) + + if hasattr(_socket.socket, 'sendmsg'): + # Only on Unix + + def recvmsg(self, *args): + while True: + try: + return _socket.socket.recvmsg(self._sock, *args) + except error as ex: + if ex.args[0] != EWOULDBLOCK or self.timeout == 0.0: + raise + self._wait(self._read_event) + + def recvmsg_into(self, *args): + while True: + try: + return _socket.socket.recvmsg_into(self._sock, *args) + except error as ex: + if ex.args[0] != EWOULDBLOCK or self.timeout == 0.0: + raise + self._wait(self._read_event) + + def recvfrom(self, *args): + while True: + try: + return _socket.socket.recvfrom(self._sock, *args) + except error as ex: + if ex.args[0] != EWOULDBLOCK or self.timeout == 0.0: + raise + self._wait(self._read_event) + + def recvfrom_into(self, *args): + while True: + try: + return _socket.socket.recvfrom_into(self._sock, *args) + except error as ex: + if ex.args[0] != EWOULDBLOCK or self.timeout == 0.0: + raise + self._wait(self._read_event) + + def recv_into(self, *args): + while True: + try: + return _socket.socket.recv_into(self._sock, *args) + except error as ex: + if ex.args[0] != EWOULDBLOCK or self.timeout == 0.0: + raise + self._wait(self._read_event) + + def send(self, data, flags=0, timeout=timeout_default): + if timeout is timeout_default: + timeout = self.timeout + try: + return _socket.socket.send(self._sock, data, flags) + except error as ex: + if ex.args[0] != EWOULDBLOCK or timeout == 0.0: + raise + self._wait(self._write_event) + try: + return _socket.socket.send(self._sock, data, flags) + except error as ex2: + if ex2.args[0] == EWOULDBLOCK: + return 0 + raise + + def sendall(self, data, flags=0): + # XXX Now that we run on PyPy3, see the notes in _socket2.py's sendall() + # and implement that here if needed. + # PyPy3 is not optimized for performance yet, and is known to be slower than + # PyPy2, so it's possibly premature to do this. However, there is a 3.5 test case that + # possibly exposes this in a severe way. + data_memory = _get_memory(data) + len_data_memory = len(data_memory) + if not len_data_memory: + # Don't try to send empty data at all, no point, and breaks ssl + # See issue 719 + return 0 + + if self.timeout is None: + data_sent = 0 + while data_sent < len_data_memory: + data_sent += self.send(data_memory[data_sent:], flags) + else: + timeleft = self.timeout + end = time.time() + timeleft + data_sent = 0 + while True: + data_sent += self.send(data_memory[data_sent:], flags, timeout=timeleft) + if data_sent >= len_data_memory: + break + timeleft = end - time.time() + if timeleft <= 0: + raise timeout('timed out') + + def sendto(self, *args): + try: + return _socket.socket.sendto(self._sock, *args) + except error as ex: + if ex.args[0] != EWOULDBLOCK or self.timeout == 0.0: + raise + self._wait(self._write_event) + try: + return _socket.socket.sendto(self._sock, *args) + except error as ex2: + if ex2.args[0] == EWOULDBLOCK: + return 0 + raise + + if hasattr(_socket.socket, 'sendmsg'): + # Only on Unix + def sendmsg(self, buffers, ancdata=(), flags=0, address=None): + try: + return _socket.socket.sendmsg(self._sock, buffers, ancdata, flags, address) + except error as ex: + if flags & getattr(_socket, 'MSG_DONTWAIT', 0): + # Enable non-blocking behaviour + # XXX: Do all platforms that have sendmsg have MSG_DONTWAIT? + raise + + if ex.args[0] != EWOULDBLOCK or self.timeout == 0.0: + raise + self._wait(self._write_event) + try: + return _socket.socket.sendmsg(self._sock, buffers, ancdata, flags, address) + except error as ex2: + if ex2.args[0] == EWOULDBLOCK: + return 0 + raise + + def setblocking(self, flag): + if flag: + self.timeout = None + else: + self.timeout = 0.0 + + def settimeout(self, howlong): + if howlong is not None: + try: + f = howlong.__float__ + except AttributeError: + raise TypeError('a float is required') + howlong = f() + if howlong < 0.0: + raise ValueError('Timeout value out of range') + self.__dict__['timeout'] = howlong + + def gettimeout(self): + return self.__dict__['timeout'] + + def shutdown(self, how): + if how == 0: # SHUT_RD + self.hub.cancel_wait(self._read_event, cancel_wait_ex) + elif how == 1: # SHUT_WR + self.hub.cancel_wait(self._write_event, cancel_wait_ex) + else: + self.hub.cancel_wait(self._read_event, cancel_wait_ex) + self.hub.cancel_wait(self._write_event, cancel_wait_ex) + self._sock.shutdown(how) + + # sendfile: new in 3.5. But there's no real reason to not + # support it everywhere. Note that we can't use os.sendfile() + # because it's not cooperative. + def _sendfile_use_sendfile(self, file, offset=0, count=None): + # This is called directly by tests + raise __socket__._GiveupOnSendfile() # pylint:disable=no-member + + def _sendfile_use_send(self, file, offset=0, count=None): + self._check_sendfile_params(file, offset, count) + if self.gettimeout() == 0: + raise ValueError("non-blocking sockets are not supported") + if offset: + file.seek(offset) + blocksize = min(count, 8192) if count else 8192 + total_sent = 0 + # localize variable access to minimize overhead + file_read = file.read + sock_send = self.send + try: + while True: + if count: + blocksize = min(count - total_sent, blocksize) + if blocksize <= 0: + break + data = memoryview(file_read(blocksize)) + if not data: + break # EOF + while True: + try: + sent = sock_send(data) + except BlockingIOError: + continue + else: + total_sent += sent + if sent < len(data): + data = data[sent:] + else: + break + return total_sent + finally: + if total_sent > 0 and hasattr(file, 'seek'): + file.seek(offset + total_sent) + + def _check_sendfile_params(self, file, offset, count): + if 'b' not in getattr(file, 'mode', 'b'): + raise ValueError("file should be opened in binary mode") + if not self.type & SOCK_STREAM: + raise ValueError("only SOCK_STREAM type sockets are supported") + if count is not None: + if not isinstance(count, int): + raise TypeError( + "count must be a positive integer (got {!r})".format(count)) + if count <= 0: + raise ValueError( + "count must be a positive integer (got {!r})".format(count)) + + def sendfile(self, file, offset=0, count=None): + """sendfile(file[, offset[, count]]) -> sent + + Send a file until EOF is reached by using high-performance + os.sendfile() and return the total number of bytes which + were sent. + *file* must be a regular file object opened in binary mode. + If os.sendfile() is not available (e.g. Windows) or file is + not a regular file socket.send() will be used instead. + *offset* tells from where to start reading the file. + If specified, *count* is the total number of bytes to transmit + as opposed to sending the file until EOF is reached. + File position is updated on return or also in case of error in + which case file.tell() can be used to figure out the number of + bytes which were sent. + The socket must be of SOCK_STREAM type. + Non-blocking sockets are not supported. + + .. versionadded:: 1.1rc4 + Added in Python 3.5, but available under all Python 3 versions in + gevent. + """ + return self._sendfile_use_send(file, offset, count) + + # get/set_inheritable new in 3.4 + if hasattr(os, 'get_inheritable') or hasattr(os, 'get_handle_inheritable'): + # pylint:disable=no-member + if os.name == 'nt': + def get_inheritable(self): + return os.get_handle_inheritable(self.fileno()) + + def set_inheritable(self, inheritable): + os.set_handle_inheritable(self.fileno(), inheritable) + else: + def get_inheritable(self): + return os.get_inheritable(self.fileno()) + + def set_inheritable(self, inheritable): + os.set_inheritable(self.fileno(), inheritable) + _added = "\n\n.. versionadded:: 1.1rc4 Added in Python 3.4" + get_inheritable.__doc__ = "Get the inheritable flag of the socket" + _added + set_inheritable.__doc__ = "Set the inheritable flag of the socket" + _added + del _added + + +if sys.version_info[:2] == (3, 4) and sys.version_info[:3] <= (3, 4, 2): + # Python 3.4, up to and including 3.4.2, had a bug where the + # SocketType enumeration overwrote the SocketType class imported + # from _socket. This was fixed in 3.4.3 (http://bugs.python.org/issue20386 + # and https://github.com/python/cpython/commit/0d2f85f38a9691efdfd1e7285c4262cab7f17db7). + # Prior to that, if we replace SocketType with our own class, the implementation + # of socket.type breaks with "OSError: [Errno 97] Address family not supported by protocol". + # Therefore, on these old versions, we must preserve it as an enum; while this + # seems like it could lead to non-green behaviour, code on those versions + # cannot possibly be using SocketType as a class anyway. + SocketType = __socket__.SocketType # pylint:disable=no-member + # Fixup __all__; note that we get exec'd multiple times during unit tests + if 'SocketType' in __implements__: + __implements__.remove('SocketType') + if 'SocketType' not in __imports__: + __imports__.append('SocketType') +else: + SocketType = socket + + +def fromfd(fd, family, type, proto=0): + """ fromfd(fd, family, type[, proto]) -> socket object + + Create a socket object from a duplicate of the given file + descriptor. The remaining arguments are the same as for socket(). + """ + nfd = dup(fd) + return socket(family, type, proto, nfd) + + +if hasattr(_socket.socket, "share"): + def fromshare(info): + """ fromshare(info) -> socket object + + Create a socket object from a the bytes object returned by + socket.share(pid). + """ + return socket(0, 0, 0, info) + + __implements__.append('fromshare') + +if hasattr(_socket, "socketpair"): + + def socketpair(family=None, type=SOCK_STREAM, proto=0): + """socketpair([family[, type[, proto]]]) -> (socket object, socket object) + + Create a pair of socket objects from the sockets returned by the platform + socketpair() function. + The arguments are the same as for socket() except the default family is + AF_UNIX if defined on the platform; otherwise, the default is AF_INET. + + .. versionchanged:: 1.2 + All Python 3 versions on Windows supply this function (natively + supplied by Python 3.5 and above). + """ + if family is None: + try: + family = AF_UNIX + except NameError: + family = AF_INET + a, b = _socket.socketpair(family, type, proto) + a = socket(family, type, proto, a.detach()) + b = socket(family, type, proto, b.detach()) + return a, b + +else: + # Origin: https://gist.github.com/4325783, by Geert Jansen. Public domain. + + # gevent: taken from 3.6 release. Expected to be used only on Win. Added to Win/3.5 + # gevent: for < 3.5, pass the default value of 128 to lsock.listen() + # (3.5+ uses this as a default and the original code passed no value) + + _LOCALHOST = '127.0.0.1' + _LOCALHOST_V6 = '::1' + + def socketpair(family=AF_INET, type=SOCK_STREAM, proto=0): + if family == AF_INET: + host = _LOCALHOST + elif family == AF_INET6: + host = _LOCALHOST_V6 + else: + raise ValueError("Only AF_INET and AF_INET6 socket address families " + "are supported") + if type != SOCK_STREAM: + raise ValueError("Only SOCK_STREAM socket type is supported") + if proto != 0: + raise ValueError("Only protocol zero is supported") + + # We create a connected TCP socket. Note the trick with + # setblocking(False) that prevents us from having to create a thread. + lsock = socket(family, type, proto) + try: + lsock.bind((host, 0)) + lsock.listen(128) + # On IPv6, ignore flow_info and scope_id + addr, port = lsock.getsockname()[:2] + csock = socket(family, type, proto) + try: + csock.setblocking(False) + try: + csock.connect((addr, port)) + except (BlockingIOError, InterruptedError): + pass + csock.setblocking(True) + ssock, _ = lsock.accept() + except: + csock.close() + raise + finally: + lsock.close() + return (ssock, csock) + + if sys.version_info[:2] < (3, 5): + # Not provided natively + if 'socketpair' in __implements__: + # Multiple imports can cause this to be missing if _socketcommon + # was successfully imported, leading to subsequent imports to cause + # ValueError + __implements__.remove('socketpair') + + +# PyPy needs drop and reuse +def _do_reuse_or_drop(sock, methname): + try: + method = getattr(sock, methname) + except (AttributeError, TypeError): + pass + else: + method() + +from io import BytesIO + + +class _basefileobject(object): + """Faux file object attached to a socket object.""" + + default_bufsize = 8192 + name = "" + + __slots__ = ["mode", "bufsize", "softspace", + # "closed" is a property, see below + "_sock", "_rbufsize", "_wbufsize", "_rbuf", "_wbuf", "_wbuf_len", + "_close"] + + def __init__(self, sock, mode='rb', bufsize=-1, close=False): + _do_reuse_or_drop(sock, '_reuse') + self._sock = sock + self.mode = mode # Not actually used in this version + if bufsize < 0: + bufsize = self.default_bufsize + self.bufsize = bufsize + self.softspace = False + # _rbufsize is the suggested recv buffer size. It is *strictly* + # obeyed within readline() for recv calls. If it is larger than + # default_bufsize it will be used for recv calls within read(). + if bufsize == 0: + self._rbufsize = 1 + elif bufsize == 1: + self._rbufsize = self.default_bufsize + else: + self._rbufsize = bufsize + self._wbufsize = bufsize + # We use BytesIO for the read buffer to avoid holding a list + # of variously sized string objects which have been known to + # fragment the heap due to how they are malloc()ed and often + # realloc()ed down much smaller than their original allocation. + self._rbuf = BytesIO() + self._wbuf = [] # A list of strings + self._wbuf_len = 0 + self._close = close + + def _getclosed(self): + return self._sock is None + closed = property(_getclosed, doc="True if the file is closed") + + def close(self): + try: + if self._sock: + self.flush() + finally: + s = self._sock + self._sock = None + if s is not None: + if self._close: + s.close() + else: + _do_reuse_or_drop(s, '_drop') + + def __del__(self): + try: + self.close() + except: # pylint:disable=bare-except + # close() may fail if __init__ didn't complete + pass + + def flush(self): + if self._wbuf: + data = b"".join(self._wbuf) + self._wbuf = [] + self._wbuf_len = 0 + buffer_size = max(self._rbufsize, self.default_bufsize) + data_size = len(data) + write_offset = 0 + view = memoryview(data) + try: + while write_offset < data_size: + self._sock.sendall(view[write_offset:write_offset + buffer_size]) + write_offset += buffer_size + finally: + if write_offset < data_size: + remainder = data[write_offset:] + del view, data # explicit free + self._wbuf.append(remainder) + self._wbuf_len = len(remainder) + + def fileno(self): + return self._sock.fileno() + + def write(self, data): + if not isinstance(data, bytes): + raise TypeError("Non-bytes data") + if not data: + return + self._wbuf.append(data) + self._wbuf_len += len(data) + if (self._wbufsize == 0 or (self._wbufsize == 1 and b'\n' in data) or + (self._wbufsize > 1 and self._wbuf_len >= self._wbufsize)): + self.flush() + + def writelines(self, list): + # XXX We could do better here for very long lists + # XXX Should really reject non-string non-buffers + lines = filter(None, map(str, list)) + self._wbuf_len += sum(map(len, lines)) + self._wbuf.extend(lines) + if self._wbufsize <= 1 or self._wbuf_len >= self._wbufsize: + self.flush() + + def read(self, size=-1): + # Use max, disallow tiny reads in a loop as they are very inefficient. + # We never leave read() with any leftover data from a new recv() call + # in our internal buffer. + rbufsize = max(self._rbufsize, self.default_bufsize) + # Our use of BytesIO rather than lists of string objects returned by + # recv() minimizes memory usage and fragmentation that occurs when + # rbufsize is large compared to the typical return value of recv(). + buf = self._rbuf + buf.seek(0, 2) # seek end + if size < 0: + # Read until EOF + self._rbuf = BytesIO() # reset _rbuf. we consume it via buf. + while True: + try: + data = self._sock.recv(rbufsize) + except InterruptedError: + continue + if not data: + break + buf.write(data) + return buf.getvalue() + else: + # Read until size bytes or EOF seen, whichever comes first + buf_len = buf.tell() + if buf_len >= size: + # Already have size bytes in our buffer? Extract and return. + buf.seek(0) + rv = buf.read(size) + self._rbuf = BytesIO() + self._rbuf.write(buf.read()) + return rv + + self._rbuf = BytesIO() # reset _rbuf. we consume it via buf. + while True: + left = size - buf_len + # recv() will malloc the amount of memory given as its + # parameter even though it often returns much less data + # than that. The returned data string is short lived + # as we copy it into a BytesIO and free it. This avoids + # fragmentation issues on many platforms. + try: + data = self._sock.recv(left) + except InterruptedError: + continue + + if not data: + break + n = len(data) + if n == size and not buf_len: + # Shortcut. Avoid buffer data copies when: + # - We have no data in our buffer. + # AND + # - Our call to recv returned exactly the + # number of bytes we were asked to read. + return data + if n == left: + buf.write(data) + del data # explicit free + break + assert n <= left, "recv(%d) returned %d bytes" % (left, n) + buf.write(data) + buf_len += n + del data # explicit free + #assert buf_len == buf.tell() + return buf.getvalue() + + def readline(self, size=-1): + # pylint:disable=too-many-return-statements + buf = self._rbuf + buf.seek(0, 2) # seek end + if buf.tell() > 0: + # check if we already have it in our buffer + buf.seek(0) + bline = buf.readline(size) + if bline.endswith(b'\n') or len(bline) == size: + self._rbuf = BytesIO() + self._rbuf.write(buf.read()) + return bline + del bline + if size < 0: # pylint:disable=too-many-nested-blocks + # Read until \n or EOF, whichever comes first + if self._rbufsize <= 1: + # Speed up unbuffered case + buf.seek(0) + buffers = [buf.read()] + self._rbuf = BytesIO() # reset _rbuf. we consume it via buf. + data = None + recv = self._sock.recv + while True: + try: + while data != b"\n": + data = recv(1) + if not data: + break + buffers.append(data) + except InterruptedError: + # The try..except to catch EINTR was moved outside the + # recv loop to avoid the per byte overhead. + continue + + break + return b"".join(buffers) + + buf.seek(0, 2) # seek end + self._rbuf = BytesIO() # reset _rbuf. we consume it via buf. + while True: + try: + data = self._sock.recv(self._rbufsize) + except InterruptedError: + continue + + if not data: + break + nl = data.find(b'\n') + if nl >= 0: + nl += 1 + buf.write(data[:nl]) + self._rbuf.write(data[nl:]) + del data + break + buf.write(data) + return buf.getvalue() + else: + # Read until size bytes or \n or EOF seen, whichever comes first + buf.seek(0, 2) # seek end + buf_len = buf.tell() + if buf_len >= size: + buf.seek(0) + rv = buf.read(size) + self._rbuf = BytesIO() + self._rbuf.write(buf.read()) + return rv + self._rbuf = BytesIO() # reset _rbuf. we consume it via buf. + while True: + try: + data = self._sock.recv(self._rbufsize) + except InterruptedError: + continue + + if not data: + break + left = size - buf_len + # did we just receive a newline? + nl = data.find(b'\n', 0, left) + if nl >= 0: + nl += 1 + # save the excess data to _rbuf + self._rbuf.write(data[nl:]) + if buf_len: + buf.write(data[:nl]) + break + else: + # Shortcut. Avoid data copy through buf when returning + # a substring of our first recv(). + return data[:nl] + n = len(data) + if n == size and not buf_len: + # Shortcut. Avoid data copy through buf when + # returning exactly all of our first recv(). + return data + if n >= left: + buf.write(data[:left]) + self._rbuf.write(data[left:]) + break + buf.write(data) + buf_len += n + #assert buf_len == buf.tell() + return buf.getvalue() + + def readlines(self, sizehint=0): + total = 0 + list = [] + while True: + line = self.readline() + if not line: + break + list.append(line) + total += len(line) + if sizehint and total >= sizehint: + break + return list + + # Iterator protocols + + def __iter__(self): + return self + + def next(self): + line = self.readline() + if not line: + raise StopIteration + return line + __next__ = next + +try: + from gevent.fileobject import FileObjectPosix +except ImportError: + # Manual implementation + _fileobject = _basefileobject +else: + class _fileobject(FileObjectPosix): + # Add the proper drop/reuse support for pypy, and match + # the close=False default in the constructor + def __init__(self, sock, mode='rb', bufsize=-1, close=False): + _do_reuse_or_drop(sock, '_reuse') + self._sock = sock + FileObjectPosix.__init__(self, sock, mode, bufsize, close) + + def close(self): + try: + if self._sock: + self.flush() + finally: + s = self._sock + self._sock = None + if s is not None: + if self._close: + FileObjectPosix.close(self) + else: + _do_reuse_or_drop(s, '_drop') + + def __del__(self): + try: + self.close() + except: # pylint:disable=bare-except + # close() may fail if __init__ didn't complete + pass + + +__all__ = __implements__ + __extensions__ + __imports__ diff --git a/python/gevent/_socketcommon.py b/python/gevent/_socketcommon.py new file mode 100644 index 0000000..4da29c8 --- /dev/null +++ b/python/gevent/_socketcommon.py @@ -0,0 +1,343 @@ +# Copyright (c) 2009-2014 Denis Bilenko and gevent contributors. See LICENSE for details. +from __future__ import absolute_import + +# standard functions and classes that this module re-implements in a gevent-aware way: +_implements = [ + 'create_connection', + 'socket', + 'SocketType', + 'fromfd', + 'socketpair', +] + +__dns__ = [ + 'getaddrinfo', + 'gethostbyname', + 'gethostbyname_ex', + 'gethostbyaddr', + 'getnameinfo', + 'getfqdn', +] + +_implements += __dns__ + +# non-standard functions that this module provides: +__extensions__ = [ + 'cancel_wait', + 'wait_read', + 'wait_write', + 'wait_readwrite', +] + +# standard functions and classes that this module re-imports +__imports__ = [ + 'error', + 'gaierror', + 'herror', + 'htonl', + 'htons', + 'ntohl', + 'ntohs', + 'inet_aton', + 'inet_ntoa', + 'inet_pton', + 'inet_ntop', + 'timeout', + 'gethostname', + 'getprotobyname', + 'getservbyname', + 'getservbyport', + 'getdefaulttimeout', + 'setdefaulttimeout', + # Windows: + 'errorTab', +] + +__py3_imports__ = [ + # Python 3 + 'AddressFamily', + 'SocketKind', + 'CMSG_LEN', + 'CMSG_SPACE', + 'dup', + 'if_indextoname', + 'if_nameindex', + 'if_nametoindex', + 'sethostname', +] + +__imports__.extend(__py3_imports__) + + +import sys +from gevent.hub import get_hub +from gevent.hub import ConcurrentObjectUseError +from gevent.timeout import Timeout +from gevent._compat import string_types, integer_types, PY3 +from gevent._util import copy_globals +from gevent._util import _NONE + +is_windows = sys.platform == 'win32' +# pylint:disable=no-name-in-module,unused-import +if is_windows: + # no such thing as WSAEPERM or error code 10001 according to winsock.h or MSDN + from errno import WSAEINVAL as EINVAL + from errno import WSAEWOULDBLOCK as EWOULDBLOCK + from errno import WSAEINPROGRESS as EINPROGRESS + from errno import WSAEALREADY as EALREADY + from errno import WSAEISCONN as EISCONN + from gevent.win32util import formatError as strerror + EAGAIN = EWOULDBLOCK +else: + from errno import EINVAL + from errno import EWOULDBLOCK + from errno import EINPROGRESS + from errno import EALREADY + from errno import EAGAIN + from errno import EISCONN + from os import strerror + +try: + from errno import EBADF +except ImportError: + EBADF = 9 + +import _socket +_realsocket = _socket.socket +import socket as __socket__ + +_name = _value = None +__imports__ = copy_globals(__socket__, globals(), + only_names=__imports__, + ignore_missing_names=True) + +for _name in __socket__.__all__: + _value = getattr(__socket__, _name) + if isinstance(_value, (integer_types, string_types)): + globals()[_name] = _value + __imports__.append(_name) + +del _name, _value + +_timeout_error = timeout # pylint: disable=undefined-variable + + +def wait(io, timeout=None, timeout_exc=_NONE): + """ + Block the current greenlet until *io* is ready. + + If *timeout* is non-negative, then *timeout_exc* is raised after + *timeout* second has passed. By default *timeout_exc* is + ``socket.timeout('timed out')``. + + If :func:`cancel_wait` is called on *io* by another greenlet, + raise an exception in this blocking greenlet + (``socket.error(EBADF, 'File descriptor was closed in another + greenlet')`` by default). + + :param io: A libev watcher, most commonly an IO watcher obtained from + :meth:`gevent.core.loop.io` + :keyword timeout_exc: The exception to raise if the timeout expires. + By default, a :class:`socket.timeout` exception is raised. + If you pass a value for this keyword, it is interpreted as for + :class:`gevent.timeout.Timeout`. + """ + if io.callback is not None: + raise ConcurrentObjectUseError('This socket is already used by another greenlet: %r' % (io.callback, )) + if timeout is not None: + timeout_exc = timeout_exc if timeout_exc is not _NONE else _timeout_error('timed out') + timeout = Timeout.start_new(timeout, timeout_exc) + + try: + return get_hub().wait(io) + finally: + if timeout is not None: + timeout.cancel() + # rename "io" to "watcher" because wait() works with any watcher + + +def wait_read(fileno, timeout=None, timeout_exc=_NONE): + """ + Block the current greenlet until *fileno* is ready to read. + + For the meaning of the other parameters and possible exceptions, + see :func:`wait`. + + .. seealso:: :func:`cancel_wait` + """ + io = get_hub().loop.io(fileno, 1) + return wait(io, timeout, timeout_exc) + + +def wait_write(fileno, timeout=None, timeout_exc=_NONE, event=_NONE): + """ + Block the current greenlet until *fileno* is ready to write. + + For the meaning of the other parameters and possible exceptions, + see :func:`wait`. + + :keyword event: Ignored. Applications should not pass this parameter. + In the future, it may become an error. + + .. seealso:: :func:`cancel_wait` + """ + # pylint:disable=unused-argument + io = get_hub().loop.io(fileno, 2) + return wait(io, timeout, timeout_exc) + + +def wait_readwrite(fileno, timeout=None, timeout_exc=_NONE, event=_NONE): + """ + Block the current greenlet until *fileno* is ready to read or + write. + + For the meaning of the other parameters and possible exceptions, + see :func:`wait`. + + :keyword event: Ignored. Applications should not pass this parameter. + In the future, it may become an error. + + .. seealso:: :func:`cancel_wait` + """ + # pylint:disable=unused-argument + io = get_hub().loop.io(fileno, 3) + return wait(io, timeout, timeout_exc) + +#: The exception raised by default on a call to :func:`cancel_wait` +class cancel_wait_ex(error): # pylint: disable=undefined-variable + def __init__(self): + super(cancel_wait_ex, self).__init__( + EBADF, + 'File descriptor was closed in another greenlet') + + +def cancel_wait(watcher, error=cancel_wait_ex): + """See :meth:`gevent.hub.Hub.cancel_wait`""" + get_hub().cancel_wait(watcher, error) + + +class BlockingResolver(object): + + def __init__(self, hub=None): + pass + + def close(self): + pass + + for method in ['gethostbyname', + 'gethostbyname_ex', + 'getaddrinfo', + 'gethostbyaddr', + 'getnameinfo']: + locals()[method] = staticmethod(getattr(_socket, method)) + + +def gethostbyname(hostname): + """ + gethostbyname(host) -> address + + Return the IP address (a string of the form '255.255.255.255') for a host. + + .. seealso:: :doc:`dns` + """ + return get_hub().resolver.gethostbyname(hostname) + + +def gethostbyname_ex(hostname): + """ + gethostbyname_ex(host) -> (name, aliaslist, addresslist) + + Return the true host name, a list of aliases, and a list of IP addresses, + for a host. The host argument is a string giving a host name or IP number. + Resolve host and port into list of address info entries. + + .. seealso:: :doc:`dns` + """ + return get_hub().resolver.gethostbyname_ex(hostname) + + +def getaddrinfo(host, port, family=0, socktype=0, proto=0, flags=0): + """ + Resolve host and port into list of address info entries. + + Translate the host/port argument into a sequence of 5-tuples that contain + all the necessary arguments for creating a socket connected to that service. + host is a domain name, a string representation of an IPv4/v6 address or + None. port is a string service name such as 'http', a numeric port number or + None. By passing None as the value of host and port, you can pass NULL to + the underlying C API. + + The family, type and proto arguments can be optionally specified in order to + narrow the list of addresses returned. Passing zero as a value for each of + these arguments selects the full range of results. + + .. seealso:: :doc:`dns` + """ + return get_hub().resolver.getaddrinfo(host, port, family, socktype, proto, flags) + +if PY3: + # The name of the socktype param changed to type in Python 3. + # See https://github.com/gevent/gevent/issues/960 + # Using inspect here to directly detect the condition is painful because we have to + # wrap it with a try/except TypeError because not all Python 2 + # versions can get the args of a builtin; we also have to use a with to suppress + # the deprecation warning. + d = getaddrinfo.__doc__ + + def getaddrinfo(host, port, family=0, type=0, proto=0, flags=0): # pylint:disable=function-redefined + return get_hub().resolver.getaddrinfo(host, port, family, type, proto, flags) + getaddrinfo.__doc__ = d + del d + + +def gethostbyaddr(ip_address): + """ + gethostbyaddr(ip_address) -> (name, aliaslist, addresslist) + + Return the true host name, a list of aliases, and a list of IP addresses, + for a host. The host argument is a string giving a host name or IP number. + + .. seealso:: :doc:`dns` + """ + return get_hub().resolver.gethostbyaddr(ip_address) + + +def getnameinfo(sockaddr, flags): + """ + getnameinfo(sockaddr, flags) -> (host, port) + + Get host and port for a sockaddr. + + .. seealso:: :doc:`dns` + """ + return get_hub().resolver.getnameinfo(sockaddr, flags) + + +def getfqdn(name=''): + """Get fully qualified domain name from name. + + An empty argument is interpreted as meaning the local host. + + First the hostname returned by gethostbyaddr() is checked, then + possibly existing aliases. In case no FQDN is available, hostname + from gethostname() is returned. + """ + # pylint: disable=undefined-variable + name = name.strip() + if not name or name == '0.0.0.0': + name = gethostname() + try: + hostname, aliases, _ = gethostbyaddr(name) + except error: + pass + else: + aliases.insert(0, hostname) + for name in aliases: # EWW! pylint:disable=redefined-argument-from-local + if isinstance(name, bytes): + if b'.' in name: + break + elif '.' in name: + break + else: + name = hostname + return name diff --git a/python/gevent/_ssl2.py b/python/gevent/_ssl2.py new file mode 100644 index 0000000..cf76aca --- /dev/null +++ b/python/gevent/_ssl2.py @@ -0,0 +1,436 @@ +# Wrapper module for _ssl. Written by Bill Janssen. +# Ported to gevent by Denis Bilenko. +"""SSL wrapper for socket objects on Python 2.7.8 and below. + +For the documentation, refer to :mod:`ssl` module manual. + +This module implements cooperative SSL socket wrappers. +""" + +from __future__ import absolute_import +# Our import magic sadly makes this warning useless +# pylint: disable=undefined-variable,arguments-differ,no-member + +import ssl as __ssl__ + +_ssl = __ssl__._ssl + +import sys +import errno +from gevent._socket2 import socket +from gevent.socket import _fileobject, timeout_default +from gevent.socket import error as socket_error, EWOULDBLOCK +from gevent.socket import timeout as _socket_timeout +from gevent._compat import PYPY +from gevent._util import copy_globals + + +__implements__ = ['SSLSocket', + 'wrap_socket', + 'get_server_certificate', + 'sslwrap_simple'] + +# Import all symbols from Python's ssl.py, except those that we are implementing +# and "private" symbols. +__imports__ = copy_globals(__ssl__, globals(), + # SSLSocket *must* subclass gevent.socket.socket; see issue 597 + names_to_ignore=__implements__ + ['socket'], + dunder_names_to_keep=()) + + +# Py2.6 can get RAND_status added twice +__all__ = list(set(__implements__) | set(__imports__)) +if 'namedtuple' in __all__: + __all__.remove('namedtuple') + +class SSLSocket(socket): + """ + gevent `ssl.SSLSocket `_ + for Pythons < 2.7.9. + """ + + def __init__(self, sock, keyfile=None, certfile=None, + server_side=False, cert_reqs=CERT_NONE, + ssl_version=PROTOCOL_SSLv23, ca_certs=None, + do_handshake_on_connect=True, + suppress_ragged_eofs=True, + ciphers=None): + socket.__init__(self, _sock=sock) + + if PYPY: + sock._drop() + + if certfile and not keyfile: + keyfile = certfile + # see if it's connected + try: + socket.getpeername(self) + except socket_error as e: + if e.args[0] != errno.ENOTCONN: + raise + # no, no connection yet + self._sslobj = None + else: + # yes, create the SSL object + if ciphers is None: + self._sslobj = _ssl.sslwrap(self._sock, server_side, + keyfile, certfile, + cert_reqs, ssl_version, ca_certs) + else: + self._sslobj = _ssl.sslwrap(self._sock, server_side, + keyfile, certfile, + cert_reqs, ssl_version, ca_certs, + ciphers) + if do_handshake_on_connect: + self.do_handshake() + self.keyfile = keyfile + self.certfile = certfile + self.cert_reqs = cert_reqs + self.ssl_version = ssl_version + self.ca_certs = ca_certs + self.ciphers = ciphers + self.do_handshake_on_connect = do_handshake_on_connect + self.suppress_ragged_eofs = suppress_ragged_eofs + self._makefile_refs = 0 + + def read(self, len=1024): + """Read up to LEN bytes and return them. + Return zero-length string on EOF.""" + while True: + try: + return self._sslobj.read(len) + except SSLError as ex: + if ex.args[0] == SSL_ERROR_EOF and self.suppress_ragged_eofs: + return '' + elif ex.args[0] == SSL_ERROR_WANT_READ: + if self.timeout == 0.0: + raise + sys.exc_clear() + self._wait(self._read_event, timeout_exc=_SSLErrorReadTimeout) + elif ex.args[0] == SSL_ERROR_WANT_WRITE: + if self.timeout == 0.0: + raise + sys.exc_clear() + # note: using _SSLErrorReadTimeout rather than _SSLErrorWriteTimeout below is intentional + self._wait(self._write_event, timeout_exc=_SSLErrorReadTimeout) + else: + raise + + def write(self, data): + """Write DATA to the underlying SSL channel. Returns + number of bytes of DATA actually transmitted.""" + while True: + try: + return self._sslobj.write(data) + except SSLError as ex: + if ex.args[0] == SSL_ERROR_WANT_READ: + if self.timeout == 0.0: + raise + sys.exc_clear() + self._wait(self._read_event, timeout_exc=_SSLErrorWriteTimeout) + elif ex.args[0] == SSL_ERROR_WANT_WRITE: + if self.timeout == 0.0: + raise + sys.exc_clear() + self._wait(self._write_event, timeout_exc=_SSLErrorWriteTimeout) + else: + raise + + def getpeercert(self, binary_form=False): + """Returns a formatted version of the data in the + certificate provided by the other end of the SSL channel. + Return None if no certificate was provided, {} if a + certificate was provided, but not validated.""" + return self._sslobj.peer_certificate(binary_form) + + def cipher(self): + if not self._sslobj: + return None + return self._sslobj.cipher() + + def send(self, data, flags=0, timeout=timeout_default): + if timeout is timeout_default: + timeout = self.timeout + if self._sslobj: + if flags != 0: + raise ValueError( + "non-zero flags not allowed in calls to send() on %s" % + self.__class__) + while True: + try: + v = self._sslobj.write(data) + except SSLError as x: + if x.args[0] == SSL_ERROR_WANT_READ: + if self.timeout == 0.0: + return 0 + sys.exc_clear() + self._wait(self._read_event) + elif x.args[0] == SSL_ERROR_WANT_WRITE: + if self.timeout == 0.0: + return 0 + sys.exc_clear() + self._wait(self._write_event) + else: + raise + else: + return v + else: + return socket.send(self, data, flags, timeout) + # is it possible for sendall() to send some data without encryption if another end shut down SSL? + + def sendall(self, data, flags=0): + try: + socket.sendall(self, data) + except _socket_timeout as ex: + if self.timeout == 0.0: + # Python 2 simply *hangs* in this case, which is bad, but + # Python 3 raises SSLWantWriteError. We do the same. + raise SSLError(SSL_ERROR_WANT_WRITE) + # Convert the socket.timeout back to the sslerror + raise SSLError(*ex.args) + + def sendto(self, *args): + if self._sslobj: + raise ValueError("sendto not allowed on instances of %s" % + self.__class__) + else: + return socket.sendto(self, *args) + + def recv(self, buflen=1024, flags=0): + if self._sslobj: + if flags != 0: + raise ValueError( + "non-zero flags not allowed in calls to recv() on %s" % + self.__class__) + # QQQ Shouldn't we wrap the SSL_WANT_READ errors as socket.timeout errors to match socket.recv's behavior? + return self.read(buflen) + else: + return socket.recv(self, buflen, flags) + + def recv_into(self, buffer, nbytes=None, flags=0): + if buffer and (nbytes is None): + nbytes = len(buffer) + elif nbytes is None: + nbytes = 1024 + if self._sslobj: + if flags != 0: + raise ValueError( + "non-zero flags not allowed in calls to recv_into() on %s" % + self.__class__) + while True: + try: + tmp_buffer = self.read(nbytes) + v = len(tmp_buffer) + buffer[:v] = tmp_buffer + return v + except SSLError as x: + if x.args[0] == SSL_ERROR_WANT_READ: + if self.timeout == 0.0: + raise + sys.exc_clear() + self._wait(self._read_event) + continue + else: + raise + else: + return socket.recv_into(self, buffer, nbytes, flags) + + def recvfrom(self, *args): + if self._sslobj: + raise ValueError("recvfrom not allowed on instances of %s" % + self.__class__) + else: + return socket.recvfrom(self, *args) + + def recvfrom_into(self, *args): + if self._sslobj: + raise ValueError("recvfrom_into not allowed on instances of %s" % + self.__class__) + else: + return socket.recvfrom_into(self, *args) + + def pending(self): + if self._sslobj: + return self._sslobj.pending() + return 0 + + def _sslobj_shutdown(self): + while True: + try: + return self._sslobj.shutdown() + except SSLError as ex: + if ex.args[0] == SSL_ERROR_EOF and self.suppress_ragged_eofs: + return '' + elif ex.args[0] == SSL_ERROR_WANT_READ: + if self.timeout == 0.0: + raise + sys.exc_clear() + self._wait(self._read_event, timeout_exc=_SSLErrorReadTimeout) + elif ex.args[0] == SSL_ERROR_WANT_WRITE: + if self.timeout == 0.0: + raise + sys.exc_clear() + self._wait(self._write_event, timeout_exc=_SSLErrorWriteTimeout) + else: + raise + + def unwrap(self): + if self._sslobj: + s = self._sslobj_shutdown() + self._sslobj = None + return socket(_sock=s) + else: + raise ValueError("No SSL wrapper around " + str(self)) + + def shutdown(self, how): + self._sslobj = None + socket.shutdown(self, how) + + def close(self): + if self._makefile_refs < 1: + self._sslobj = None + socket.close(self) + else: + self._makefile_refs -= 1 + + if PYPY: + + def _reuse(self): + self._makefile_refs += 1 + + def _drop(self): + if self._makefile_refs < 1: + self.close() + else: + self._makefile_refs -= 1 + + def do_handshake(self): + """Perform a TLS/SSL handshake.""" + while True: + try: + return self._sslobj.do_handshake() + except SSLError as ex: + if ex.args[0] == SSL_ERROR_WANT_READ: + if self.timeout == 0.0: + raise + sys.exc_clear() + self._wait(self._read_event, timeout_exc=_SSLErrorHandshakeTimeout) + elif ex.args[0] == SSL_ERROR_WANT_WRITE: + if self.timeout == 0.0: + raise + sys.exc_clear() + self._wait(self._write_event, timeout_exc=_SSLErrorHandshakeTimeout) + else: + raise + + def connect(self, addr): + """Connects to remote ADDR, and then wraps the connection in + an SSL channel.""" + # Here we assume that the socket is client-side, and not + # connected at the time of the call. We connect it, then wrap it. + if self._sslobj: + raise ValueError("attempt to connect already-connected SSLSocket!") + socket.connect(self, addr) + if self.ciphers is None: + self._sslobj = _ssl.sslwrap(self._sock, False, self.keyfile, self.certfile, + self.cert_reqs, self.ssl_version, + self.ca_certs) + else: + self._sslobj = _ssl.sslwrap(self._sock, False, self.keyfile, self.certfile, + self.cert_reqs, self.ssl_version, + self.ca_certs, self.ciphers) + if self.do_handshake_on_connect: + self.do_handshake() + + def accept(self): + """Accepts a new connection from a remote client, and returns + a tuple containing that new connection wrapped with a server-side + SSL channel, and the address of the remote client.""" + sock = self._sock + while True: + try: + client_socket, address = sock.accept() + break + except socket_error as ex: + if ex.args[0] != EWOULDBLOCK or self.timeout == 0.0: + raise + sys.exc_clear() + self._wait(self._read_event) + + sslobj = SSLSocket(client_socket, + keyfile=self.keyfile, + certfile=self.certfile, + server_side=True, + cert_reqs=self.cert_reqs, + ssl_version=self.ssl_version, + ca_certs=self.ca_certs, + do_handshake_on_connect=self.do_handshake_on_connect, + suppress_ragged_eofs=self.suppress_ragged_eofs, + ciphers=self.ciphers) + + return sslobj, address + + def makefile(self, mode='r', bufsize=-1): + """Make and return a file-like object that + works with the SSL connection. Just use the code + from the socket module.""" + if not PYPY: + self._makefile_refs += 1 + # close=True so as to decrement the reference count when done with + # the file-like object. + return _fileobject(self, mode, bufsize, close=True) + +if PYPY or not hasattr(SSLSocket, 'timeout'): + # PyPy (and certain versions of CPython) doesn't have a direct + # 'timeout' property on raw sockets, because that's not part of + # the documented specification. We may wind up wrapping a raw + # socket (when ssl is used with PyWSGI) or a gevent socket, which + # does have a read/write timeout property as an alias for + # get/settimeout, so make sure that's always the case because + # pywsgi can depend on that. + SSLSocket.timeout = property(lambda self: self.gettimeout(), + lambda self, value: self.settimeout(value)) + + +_SSLErrorReadTimeout = SSLError('The read operation timed out') +_SSLErrorWriteTimeout = SSLError('The write operation timed out') +_SSLErrorHandshakeTimeout = SSLError('The handshake operation timed out') + + +def wrap_socket(sock, keyfile=None, certfile=None, + server_side=False, cert_reqs=CERT_NONE, + ssl_version=PROTOCOL_SSLv23, ca_certs=None, + do_handshake_on_connect=True, + suppress_ragged_eofs=True, ciphers=None): + """Create a new :class:`SSLSocket` instance.""" + return SSLSocket(sock, keyfile=keyfile, certfile=certfile, + server_side=server_side, cert_reqs=cert_reqs, + ssl_version=ssl_version, ca_certs=ca_certs, + do_handshake_on_connect=do_handshake_on_connect, + suppress_ragged_eofs=suppress_ragged_eofs, + ciphers=ciphers) + + +def get_server_certificate(addr, ssl_version=PROTOCOL_SSLv23, ca_certs=None): + """Retrieve the certificate from the server at the specified address, + and return it as a PEM-encoded string. + If 'ca_certs' is specified, validate the server cert against it. + If 'ssl_version' is specified, use it in the connection attempt.""" + + if ca_certs is not None: + cert_reqs = CERT_REQUIRED + else: + cert_reqs = CERT_NONE + s = wrap_socket(socket(), ssl_version=ssl_version, + cert_reqs=cert_reqs, ca_certs=ca_certs) + s.connect(addr) + dercert = s.getpeercert(True) + s.close() + return DER_cert_to_PEM_cert(dercert) + + +def sslwrap_simple(sock, keyfile=None, certfile=None): + """A replacement for the old socket.ssl function. Designed + for compatability with Python 2.5 and earlier. Will disappear in + Python 3.0.""" + return SSLSocket(sock, keyfile, certfile) diff --git a/python/gevent/_ssl3.py b/python/gevent/_ssl3.py new file mode 100644 index 0000000..81b709c --- /dev/null +++ b/python/gevent/_ssl3.py @@ -0,0 +1,661 @@ +# Wrapper module for _ssl. Written by Bill Janssen. +# Ported to gevent by Denis Bilenko. +"""SSL wrapper for socket objects on Python 3. + +For the documentation, refer to :mod:`ssl` module manual. + +This module implements cooperative SSL socket wrappers. +""" +# Our import magic sadly makes this warning useless +# pylint: disable=undefined-variable + +from __future__ import absolute_import +import ssl as __ssl__ + +_ssl = __ssl__._ssl # pylint:disable=no-member + +import errno +from gevent.socket import socket, timeout_default +from gevent.socket import error as socket_error +from gevent.socket import timeout as _socket_timeout +from gevent._util import copy_globals + +from weakref import ref as _wref + +__implements__ = [ + 'SSLContext', + 'SSLSocket', + 'wrap_socket', + 'get_server_certificate', +] + +# Import all symbols from Python's ssl.py, except those that we are implementing +# and "private" symbols. +__imports__ = copy_globals(__ssl__, globals(), + # SSLSocket *must* subclass gevent.socket.socket; see issue 597 + names_to_ignore=__implements__ + ['socket'], + dunder_names_to_keep=()) + +__all__ = __implements__ + __imports__ +if 'namedtuple' in __all__: + __all__.remove('namedtuple') + +orig_SSLContext = __ssl__.SSLContext # pylint:disable=no-member + + +class SSLContext(orig_SSLContext): + def wrap_socket(self, sock, server_side=False, + do_handshake_on_connect=True, + suppress_ragged_eofs=True, + server_hostname=None, + session=None): + # pylint:disable=arguments-differ + # (3.6 adds session) + # Sadly, using *args and **kwargs doesn't work + return SSLSocket(sock=sock, server_side=server_side, + do_handshake_on_connect=do_handshake_on_connect, + suppress_ragged_eofs=suppress_ragged_eofs, + server_hostname=server_hostname, + _context=self, + _session=session) + + if not hasattr(orig_SSLContext, 'check_hostname'): + # Python 3.3 lacks this + check_hostname = False + + if hasattr(orig_SSLContext.options, 'setter'): + # In 3.6, these became properties. They want to access the + # property __set__ method in the superclass, and they do so by using + # super(SSLContext, SSLContext). But we rebind SSLContext when we monkey + # patch, which causes infinite recursion. + # https://github.com/python/cpython/commit/328067c468f82e4ec1b5c510a4e84509e010f296 + # pylint:disable=no-member + @orig_SSLContext.options.setter + def options(self, value): + super(orig_SSLContext, orig_SSLContext).options.__set__(self, value) + + @orig_SSLContext.verify_flags.setter + def verify_flags(self, value): + super(orig_SSLContext, orig_SSLContext).verify_flags.__set__(self, value) + + @orig_SSLContext.verify_mode.setter + def verify_mode(self, value): + super(orig_SSLContext, orig_SSLContext).verify_mode.__set__(self, value) + + +class _contextawaresock(socket._gevent_sock_class): # Python 2: pylint:disable=slots-on-old-class + # We have to pass the raw stdlib socket to SSLContext.wrap_socket. + # That method in turn can pass that object on to things like SNI callbacks. + # It wouldn't have access to any of the attributes on the SSLSocket, like + # context, that it's supposed to (see test_ssl.test_sni_callback). Our + # solution is to keep a weak reference to the SSLSocket on the raw + # socket and delegate. + + # We keep it in a slot to avoid having the ability to set any attributes + # we're not prepared for (because we don't know what to delegate.) + + __slots__ = ('_sslsock',) + + @property + def context(self): + return self._sslsock().context + + @context.setter + def context(self, ctx): + self._sslsock().context = ctx + + @property + def session(self): + """The SSLSession for client socket.""" + return self._sslsock().session + + @session.setter + def session(self, session): + self._sslsock().session = session + + def __getattr__(self, name): + try: + return getattr(self._sslsock(), name) + except RuntimeError: + # XXX: If the attribute doesn't exist, + # we infinitely recurse + pass + raise AttributeError(name) + + +class SSLSocket(socket): + """ + gevent `ssl.SSLSocket `_ + for Python 3. + """ + + # pylint:disable=too-many-instance-attributes,too-many-public-methods + + _gevent_sock_class = _contextawaresock + + def __init__(self, sock=None, keyfile=None, certfile=None, + server_side=False, cert_reqs=CERT_NONE, + ssl_version=PROTOCOL_SSLv23, ca_certs=None, + do_handshake_on_connect=True, + family=AF_INET, type=SOCK_STREAM, proto=0, fileno=None, + suppress_ragged_eofs=True, npn_protocols=None, ciphers=None, + server_hostname=None, + _session=None, # 3.6 + _context=None): + # pylint:disable=too-many-locals,too-many-statements,too-many-branches + if _context: + self._context = _context + else: + if server_side and not certfile: + raise ValueError("certfile must be specified for server-side " + "operations") + if keyfile and not certfile: + raise ValueError("certfile must be specified") + if certfile and not keyfile: + keyfile = certfile + self._context = SSLContext(ssl_version) + self._context.verify_mode = cert_reqs + if ca_certs: + self._context.load_verify_locations(ca_certs) + if certfile: + self._context.load_cert_chain(certfile, keyfile) + if npn_protocols: + self._context.set_npn_protocols(npn_protocols) + if ciphers: + self._context.set_ciphers(ciphers) + self.keyfile = keyfile + self.certfile = certfile + self.cert_reqs = cert_reqs + self.ssl_version = ssl_version + self.ca_certs = ca_certs + self.ciphers = ciphers + # Can't use sock.type as other flags (such as SOCK_NONBLOCK) get + # mixed in. + if sock.getsockopt(SOL_SOCKET, SO_TYPE) != SOCK_STREAM: + raise NotImplementedError("only stream sockets are supported") + if server_side: + if server_hostname: + raise ValueError("server_hostname can only be specified " + "in client mode") + if _session is not None: + raise ValueError("session can only be specified " + "in client mode") + if self._context.check_hostname and not server_hostname: + raise ValueError("check_hostname requires server_hostname") + self._session = _session + self.server_side = server_side + self.server_hostname = server_hostname + self.do_handshake_on_connect = do_handshake_on_connect + self.suppress_ragged_eofs = suppress_ragged_eofs + connected = False + if sock is not None: + socket.__init__(self, + family=sock.family, + type=sock.type, + proto=sock.proto, + fileno=sock.fileno()) + self.settimeout(sock.gettimeout()) + # see if it's connected + try: + sock.getpeername() + except socket_error as e: + if e.errno != errno.ENOTCONN: + raise + else: + connected = True + sock.detach() + elif fileno is not None: + socket.__init__(self, fileno=fileno) + else: + socket.__init__(self, family=family, type=type, proto=proto) + + self._sock._sslsock = _wref(self) + self._closed = False + self._sslobj = None + self._connected = connected + if connected: + # create the SSL object + try: + self._sslobj = self._context._wrap_socket(self._sock, server_side, + server_hostname) + if _session is not None: # 3.6 + self._sslobj = SSLObject(self._sslobj, owner=self, session=self._session) + if do_handshake_on_connect: + timeout = self.gettimeout() + if timeout == 0.0: + # non-blocking + raise ValueError("do_handshake_on_connect should not be specified for non-blocking sockets") + self.do_handshake() + + except socket_error as x: + self.close() + raise x + + @property + def context(self): + return self._context + + @context.setter + def context(self, ctx): + self._context = ctx + self._sslobj.context = ctx + + @property + def session(self): + """The SSLSession for client socket.""" + if self._sslobj is not None: + return self._sslobj.session + + @session.setter + def session(self, session): + self._session = session + if self._sslobj is not None: + self._sslobj.session = session + + @property + def session_reused(self): + """Was the client session reused during handshake""" + if self._sslobj is not None: + return self._sslobj.session_reused + + def dup(self): + raise NotImplementedError("Can't dup() %s instances" % + self.__class__.__name__) + + def _checkClosed(self, msg=None): + # raise an exception here if you wish to check for spurious closes + pass + + def _check_connected(self): + if not self._connected: + # getpeername() will raise ENOTCONN if the socket is really + # not connected; note that we can be connected even without + # _connected being set, e.g. if connect() first returned + # EAGAIN. + self.getpeername() + + def read(self, len=1024, buffer=None): + """Read up to LEN bytes and return them. + Return zero-length string on EOF.""" + # pylint:disable=too-many-branches + self._checkClosed() + + while True: + if not self._sslobj: + raise ValueError("Read on closed or unwrapped SSL socket.") + if len == 0: + return b'' if buffer is None else 0 + # Negative lengths are handled natively when the buffer is None + # to raise a ValueError + try: + if buffer is not None: + return self._sslobj.read(len, buffer) + return self._sslobj.read(len or 1024) + except SSLWantReadError: + if self.timeout == 0.0: + raise + self._wait(self._read_event, timeout_exc=_SSLErrorReadTimeout) + except SSLWantWriteError: + if self.timeout == 0.0: + raise + # note: using _SSLErrorReadTimeout rather than _SSLErrorWriteTimeout below is intentional + self._wait(self._write_event, timeout_exc=_SSLErrorReadTimeout) + except SSLError as ex: + if ex.args[0] == SSL_ERROR_EOF and self.suppress_ragged_eofs: + if buffer is None: + return b'' + return 0 + else: + raise + + def write(self, data): + """Write DATA to the underlying SSL channel. Returns + number of bytes of DATA actually transmitted.""" + self._checkClosed() + + while True: + if not self._sslobj: + raise ValueError("Write on closed or unwrapped SSL socket.") + + try: + return self._sslobj.write(data) + except SSLError as ex: + if ex.args[0] == SSL_ERROR_WANT_READ: + if self.timeout == 0.0: + raise + self._wait(self._read_event, timeout_exc=_SSLErrorWriteTimeout) + elif ex.args[0] == SSL_ERROR_WANT_WRITE: + if self.timeout == 0.0: + raise + self._wait(self._write_event, timeout_exc=_SSLErrorWriteTimeout) + else: + raise + + def getpeercert(self, binary_form=False): + """Returns a formatted version of the data in the + certificate provided by the other end of the SSL channel. + Return None if no certificate was provided, {} if a + certificate was provided, but not validated.""" + + self._checkClosed() + self._check_connected() + try: + c = self._sslobj.peer_certificate + except AttributeError: + # 3.6 + c = self._sslobj.getpeercert + + return c(binary_form) + + def selected_npn_protocol(self): + self._checkClosed() + if not self._sslobj or not _ssl.HAS_NPN: + return None + return self._sslobj.selected_npn_protocol() + + if hasattr(_ssl, 'HAS_ALPN'): + # 3.5+ + def selected_alpn_protocol(self): + self._checkClosed() + if not self._sslobj or not _ssl.HAS_ALPN: # pylint:disable=no-member + return None + return self._sslobj.selected_alpn_protocol() + + def shared_ciphers(self): + """Return a list of ciphers shared by the client during the handshake or + None if this is not a valid server connection. + """ + return self._sslobj.shared_ciphers() + + def version(self): + """Return a string identifying the protocol version used by the + current SSL channel. """ + if not self._sslobj: + return None + return self._sslobj.version() + + # We inherit sendfile from super(); it always uses `send` + + def cipher(self): + self._checkClosed() + if not self._sslobj: + return None + return self._sslobj.cipher() + + def compression(self): + self._checkClosed() + if not self._sslobj: + return None + return self._sslobj.compression() + + def send(self, data, flags=0, timeout=timeout_default): + self._checkClosed() + if timeout is timeout_default: + timeout = self.timeout + if self._sslobj: + if flags != 0: + raise ValueError( + "non-zero flags not allowed in calls to send() on %s" % + self.__class__) + while True: + try: + return self._sslobj.write(data) + except SSLWantReadError: + if self.timeout == 0.0: + return 0 + self._wait(self._read_event) + except SSLWantWriteError: + if self.timeout == 0.0: + return 0 + self._wait(self._write_event) + else: + return socket.send(self, data, flags, timeout) + + def sendto(self, data, flags_or_addr, addr=None): + self._checkClosed() + if self._sslobj: + raise ValueError("sendto not allowed on instances of %s" % + self.__class__) + elif addr is None: + return socket.sendto(self, data, flags_or_addr) + else: + return socket.sendto(self, data, flags_or_addr, addr) + + def sendmsg(self, *args, **kwargs): + # Ensure programs don't send data unencrypted if they try to + # use this method. + raise NotImplementedError("sendmsg not allowed on instances of %s" % + self.__class__) + + def sendall(self, data, flags=0): + self._checkClosed() + if self._sslobj: + if flags != 0: + raise ValueError( + "non-zero flags not allowed in calls to sendall() on %s" % + self.__class__) + + try: + return socket.sendall(self, data, flags) + except _socket_timeout: + if self.timeout == 0.0: + # Raised by the stdlib on non-blocking sockets + raise SSLWantWriteError("The operation did not complete (write)") + raise + + def recv(self, buflen=1024, flags=0): + self._checkClosed() + if self._sslobj: + if flags != 0: + raise ValueError( + "non-zero flags not allowed in calls to recv() on %s" % + self.__class__) + if buflen == 0: + # https://github.com/python/cpython/commit/00915577dd84ba75016400793bf547666e6b29b5 + # Python #23804 + return b'' + return self.read(buflen) + else: + return socket.recv(self, buflen, flags) + + def recv_into(self, buffer, nbytes=None, flags=0): + self._checkClosed() + if buffer and (nbytes is None): + nbytes = len(buffer) + elif nbytes is None: + nbytes = 1024 + if self._sslobj: + if flags != 0: + raise ValueError("non-zero flags not allowed in calls to recv_into() on %s" % self.__class__) + return self.read(nbytes, buffer) + else: + return socket.recv_into(self, buffer, nbytes, flags) + + def recvfrom(self, buflen=1024, flags=0): + self._checkClosed() + if self._sslobj: + raise ValueError("recvfrom not allowed on instances of %s" % + self.__class__) + else: + return socket.recvfrom(self, buflen, flags) + + def recvfrom_into(self, buffer, nbytes=None, flags=0): + self._checkClosed() + if self._sslobj: + raise ValueError("recvfrom_into not allowed on instances of %s" % + self.__class__) + else: + return socket.recvfrom_into(self, buffer, nbytes, flags) + + def recvmsg(self, *args, **kwargs): + raise NotImplementedError("recvmsg not allowed on instances of %s" % + self.__class__) + + def recvmsg_into(self, *args, **kwargs): + raise NotImplementedError("recvmsg_into not allowed on instances of " + "%s" % self.__class__) + + def pending(self): + self._checkClosed() + if self._sslobj: + return self._sslobj.pending() + return 0 + + def shutdown(self, how): + self._checkClosed() + self._sslobj = None + socket.shutdown(self, how) + + def unwrap(self): + if self._sslobj: + while True: + try: + s = self._sslobj.shutdown() + break + except SSLWantReadError: + if self.timeout == 0.0: + return 0 + self._wait(self._read_event) + except SSLWantWriteError: + if self.timeout == 0.0: + return 0 + self._wait(self._write_event) + + self._sslobj = None + # The return value of shutting down the SSLObject is the + # original wrapped socket, i.e., _contextawaresock. But that + # object doesn't have the gevent wrapper around it so it can't + # be used. We have to wrap it back up with a gevent wrapper. + sock = socket(family=s.family, type=s.type, proto=s.proto, fileno=s.fileno()) + s.detach() + return sock + else: + raise ValueError("No SSL wrapper around " + str(self)) + + def _real_close(self): + self._sslobj = None + # self._closed = True + socket._real_close(self) + + def do_handshake(self): + """Perform a TLS/SSL handshake.""" + self._check_connected() + while True: + try: + self._sslobj.do_handshake() + break + except SSLWantReadError: + if self.timeout == 0.0: + raise + self._wait(self._read_event, timeout_exc=_SSLErrorHandshakeTimeout) + except SSLWantWriteError: + if self.timeout == 0.0: + raise + self._wait(self._write_event, timeout_exc=_SSLErrorHandshakeTimeout) + + if self._context.check_hostname: + if not self.server_hostname: + raise ValueError("check_hostname needs server_hostname " + "argument") + match_hostname(self.getpeercert(), self.server_hostname) + + def _real_connect(self, addr, connect_ex): + if self.server_side: + raise ValueError("can't connect in server-side mode") + # Here we assume that the socket is client-side, and not + # connected at the time of the call. We connect it, then wrap it. + if self._connected: + raise ValueError("attempt to connect already-connected SSLSocket!") + self._sslobj = self._context._wrap_socket(self._sock, False, self.server_hostname) + if self._session is not None: # 3.6 + self._sslobj = SSLObject(self._sslobj, owner=self, session=self._session) + try: + if connect_ex: + rc = socket.connect_ex(self, addr) + else: + rc = None + socket.connect(self, addr) + if not rc: + if self.do_handshake_on_connect: + self.do_handshake() + self._connected = True + return rc + except socket_error: + self._sslobj = None + raise + + def connect(self, addr): + """Connects to remote ADDR, and then wraps the connection in + an SSL channel.""" + self._real_connect(addr, False) + + def connect_ex(self, addr): + """Connects to remote ADDR, and then wraps the connection in + an SSL channel.""" + return self._real_connect(addr, True) + + def accept(self): + """Accepts a new connection from a remote client, and returns + a tuple containing that new connection wrapped with a server-side + SSL channel, and the address of the remote client.""" + + newsock, addr = socket.accept(self) + newsock = self._context.wrap_socket(newsock, + do_handshake_on_connect=self.do_handshake_on_connect, + suppress_ragged_eofs=self.suppress_ragged_eofs, + server_side=True) + return newsock, addr + + def get_channel_binding(self, cb_type="tls-unique"): + """Get channel binding data for current connection. Raise ValueError + if the requested `cb_type` is not supported. Return bytes of the data + or None if the data is not available (e.g. before the handshake). + """ + if cb_type not in CHANNEL_BINDING_TYPES: + raise ValueError("Unsupported channel binding type") + if cb_type != "tls-unique": + raise NotImplementedError("{0} channel binding type not implemented".format(cb_type)) + if self._sslobj is None: + return None + return self._sslobj.tls_unique_cb() + + +# Python 3.2 onwards raise normal timeout errors, not SSLError. +# See https://bugs.python.org/issue10272 +_SSLErrorReadTimeout = _socket_timeout('The read operation timed out') +_SSLErrorWriteTimeout = _socket_timeout('The write operation timed out') +_SSLErrorHandshakeTimeout = _socket_timeout('The handshake operation timed out') + + +def wrap_socket(sock, keyfile=None, certfile=None, + server_side=False, cert_reqs=CERT_NONE, + ssl_version=PROTOCOL_SSLv23, ca_certs=None, + do_handshake_on_connect=True, + suppress_ragged_eofs=True, + ciphers=None): + + return SSLSocket(sock=sock, keyfile=keyfile, certfile=certfile, + server_side=server_side, cert_reqs=cert_reqs, + ssl_version=ssl_version, ca_certs=ca_certs, + do_handshake_on_connect=do_handshake_on_connect, + suppress_ragged_eofs=suppress_ragged_eofs, + ciphers=ciphers) + + +def get_server_certificate(addr, ssl_version=PROTOCOL_SSLv23, ca_certs=None): + """Retrieve the certificate from the server at the specified address, + and return it as a PEM-encoded string. + If 'ca_certs' is specified, validate the server cert against it. + If 'ssl_version' is specified, use it in the connection attempt.""" + + _, _ = addr + if ca_certs is not None: + cert_reqs = CERT_REQUIRED + else: + cert_reqs = CERT_NONE + s = create_connection(addr) + s = wrap_socket(s, ssl_version=ssl_version, + cert_reqs=cert_reqs, ca_certs=ca_certs) + dercert = s.getpeercert(True) + s.close() + return DER_cert_to_PEM_cert(dercert) diff --git a/python/gevent/_sslgte279.py b/python/gevent/_sslgte279.py new file mode 100644 index 0000000..92280ad --- /dev/null +++ b/python/gevent/_sslgte279.py @@ -0,0 +1,714 @@ +# Wrapper module for _ssl. Written by Bill Janssen. +# Ported to gevent by Denis Bilenko. +"""SSL wrapper for socket objects on Python 2.7.9 and above. + +For the documentation, refer to :mod:`ssl` module manual. + +This module implements cooperative SSL socket wrappers. +""" + +from __future__ import absolute_import +# Our import magic sadly makes this warning useless +# pylint: disable=undefined-variable +# pylint: disable=too-many-instance-attributes,too-many-locals,too-many-statements,too-many-branches +# pylint: disable=arguments-differ,too-many-public-methods + +import ssl as __ssl__ + +_ssl = __ssl__._ssl # pylint:disable=no-member + +import errno +from gevent._socket2 import socket +from gevent.socket import timeout_default +from gevent.socket import create_connection +from gevent.socket import error as socket_error +from gevent.socket import timeout as _socket_timeout +from gevent._compat import PYPY +from gevent._util import copy_globals + +__implements__ = [ + 'SSLContext', + 'SSLSocket', + 'wrap_socket', + 'get_server_certificate', + 'create_default_context', + '_create_unverified_context', + '_create_default_https_context', + '_create_stdlib_context', +] + +# Import all symbols from Python's ssl.py, except those that we are implementing +# and "private" symbols. +__imports__ = copy_globals(__ssl__, globals(), + # SSLSocket *must* subclass gevent.socket.socket; see issue 597 and 801 + names_to_ignore=__implements__ + ['socket', 'create_connection'], + dunder_names_to_keep=()) + +try: + _delegate_methods +except NameError: # PyPy doesn't expose this detail + _delegate_methods = ('recv', 'recvfrom', 'recv_into', 'recvfrom_into', 'send', 'sendto') + +__all__ = __implements__ + __imports__ +if 'namedtuple' in __all__: + __all__.remove('namedtuple') + +orig_SSLContext = __ssl__.SSLContext # pylint: disable=no-member + + +class SSLContext(orig_SSLContext): + def wrap_socket(self, sock, server_side=False, + do_handshake_on_connect=True, + suppress_ragged_eofs=True, + server_hostname=None): + return SSLSocket(sock=sock, server_side=server_side, + do_handshake_on_connect=do_handshake_on_connect, + suppress_ragged_eofs=suppress_ragged_eofs, + server_hostname=server_hostname, + _context=self) + + +def create_default_context(purpose=Purpose.SERVER_AUTH, cafile=None, + capath=None, cadata=None): + """Create a SSLContext object with default settings. + + NOTE: The protocol and settings may change anytime without prior + deprecation. The values represent a fair balance between maximum + compatibility and security. + """ + if not isinstance(purpose, _ASN1Object): + raise TypeError(purpose) + + context = SSLContext(PROTOCOL_SSLv23) + + # SSLv2 considered harmful. + context.options |= OP_NO_SSLv2 + + # SSLv3 has problematic security and is only required for really old + # clients such as IE6 on Windows XP + context.options |= OP_NO_SSLv3 + + # disable compression to prevent CRIME attacks (OpenSSL 1.0+) + context.options |= getattr(_ssl, "OP_NO_COMPRESSION", 0) + + if purpose == Purpose.SERVER_AUTH: + # verify certs and host name in client mode + context.verify_mode = CERT_REQUIRED + context.check_hostname = True # pylint: disable=attribute-defined-outside-init + elif purpose == Purpose.CLIENT_AUTH: + # Prefer the server's ciphers by default so that we get stronger + # encryption + context.options |= getattr(_ssl, "OP_CIPHER_SERVER_PREFERENCE", 0) + + # Use single use keys in order to improve forward secrecy + context.options |= getattr(_ssl, "OP_SINGLE_DH_USE", 0) + context.options |= getattr(_ssl, "OP_SINGLE_ECDH_USE", 0) + + # disallow ciphers with known vulnerabilities + context.set_ciphers(_RESTRICTED_SERVER_CIPHERS) + + if cafile or capath or cadata: + context.load_verify_locations(cafile, capath, cadata) + elif context.verify_mode != CERT_NONE: + # no explicit cafile, capath or cadata but the verify mode is + # CERT_OPTIONAL or CERT_REQUIRED. Let's try to load default system + # root CA certificates for the given purpose. This may fail silently. + context.load_default_certs(purpose) + return context + +def _create_unverified_context(protocol=PROTOCOL_SSLv23, cert_reqs=None, + check_hostname=False, purpose=Purpose.SERVER_AUTH, + certfile=None, keyfile=None, + cafile=None, capath=None, cadata=None): + """Create a SSLContext object for Python stdlib modules + + All Python stdlib modules shall use this function to create SSLContext + objects in order to keep common settings in one place. The configuration + is less restrict than create_default_context()'s to increase backward + compatibility. + """ + if not isinstance(purpose, _ASN1Object): + raise TypeError(purpose) + + context = SSLContext(protocol) + # SSLv2 considered harmful. + context.options |= OP_NO_SSLv2 + # SSLv3 has problematic security and is only required for really old + # clients such as IE6 on Windows XP + context.options |= OP_NO_SSLv3 + + if cert_reqs is not None: + context.verify_mode = cert_reqs + context.check_hostname = check_hostname # pylint: disable=attribute-defined-outside-init + + if keyfile and not certfile: + raise ValueError("certfile must be specified") + if certfile or keyfile: + context.load_cert_chain(certfile, keyfile) + + # load CA root certs + if cafile or capath or cadata: + context.load_verify_locations(cafile, capath, cadata) + elif context.verify_mode != CERT_NONE: + # no explicit cafile, capath or cadata but the verify mode is + # CERT_OPTIONAL or CERT_REQUIRED. Let's try to load default system + # root CA certificates for the given purpose. This may fail silently. + context.load_default_certs(purpose) + + return context + +# Used by http.client if no context is explicitly passed. +_create_default_https_context = create_default_context + + +# Backwards compatibility alias, even though it's not a public name. +_create_stdlib_context = _create_unverified_context + +class SSLSocket(socket): + """ + gevent `ssl.SSLSocket `_ + for Pythons >= 2.7.9 but less than 3. + """ + + def __init__(self, sock=None, keyfile=None, certfile=None, + server_side=False, cert_reqs=CERT_NONE, + ssl_version=PROTOCOL_SSLv23, ca_certs=None, + do_handshake_on_connect=True, + family=AF_INET, type=SOCK_STREAM, proto=0, fileno=None, + suppress_ragged_eofs=True, npn_protocols=None, ciphers=None, + server_hostname=None, + _context=None): + # fileno is ignored + # pylint: disable=unused-argument + if _context: + self._context = _context + else: + if server_side and not certfile: + raise ValueError("certfile must be specified for server-side " + "operations") + if keyfile and not certfile: + raise ValueError("certfile must be specified") + if certfile and not keyfile: + keyfile = certfile + self._context = SSLContext(ssl_version) + self._context.verify_mode = cert_reqs + if ca_certs: + self._context.load_verify_locations(ca_certs) + if certfile: + self._context.load_cert_chain(certfile, keyfile) + if npn_protocols: + self._context.set_npn_protocols(npn_protocols) + if ciphers: + self._context.set_ciphers(ciphers) + self.keyfile = keyfile + self.certfile = certfile + self.cert_reqs = cert_reqs + self.ssl_version = ssl_version + self.ca_certs = ca_certs + self.ciphers = ciphers + # Can't use sock.type as other flags (such as SOCK_NONBLOCK) get + # mixed in. + if sock.getsockopt(SOL_SOCKET, SO_TYPE) != SOCK_STREAM: + raise NotImplementedError("only stream sockets are supported") + + if PYPY: + socket.__init__(self, _sock=sock) + sock._drop() + else: + # CPython: XXX: Must pass the underlying socket, not our + # potential wrapper; test___example_servers fails the SSL test + # with a client-side EOF error. (Why?) + socket.__init__(self, _sock=sock._sock) + + # The initializer for socket overrides the methods send(), recv(), etc. + # in the instance, which we don't need -- but we want to provide the + # methods defined in SSLSocket. + for attr in _delegate_methods: + try: + delattr(self, attr) + except AttributeError: + pass + if server_side and server_hostname: + raise ValueError("server_hostname can only be specified " + "in client mode") + if self._context.check_hostname and not server_hostname: + raise ValueError("check_hostname requires server_hostname") + self.server_side = server_side + self.server_hostname = server_hostname + self.do_handshake_on_connect = do_handshake_on_connect + self.suppress_ragged_eofs = suppress_ragged_eofs + self.settimeout(sock.gettimeout()) + + # See if we are connected + try: + self.getpeername() + except socket_error as e: + if e.errno != errno.ENOTCONN: + raise + connected = False + else: + connected = True + + self._makefile_refs = 0 + self._closed = False + self._sslobj = None + self._connected = connected + if connected: + # create the SSL object + try: + self._sslobj = self._context._wrap_socket(self._sock, server_side, + server_hostname, ssl_sock=self) + if do_handshake_on_connect: + timeout = self.gettimeout() + if timeout == 0.0: + # non-blocking + raise ValueError("do_handshake_on_connect should not be specified for non-blocking sockets") + self.do_handshake() + + except socket_error as x: + self.close() + raise x + + + @property + def context(self): + return self._context + + @context.setter + def context(self, ctx): + self._context = ctx + self._sslobj.context = ctx + + def dup(self): + raise NotImplementedError("Can't dup() %s instances" % + self.__class__.__name__) + + def _checkClosed(self, msg=None): + # raise an exception here if you wish to check for spurious closes + pass + + def _check_connected(self): + if not self._connected: + # getpeername() will raise ENOTCONN if the socket is really + # not connected; note that we can be connected even without + # _connected being set, e.g. if connect() first returned + # EAGAIN. + self.getpeername() + + def read(self, len=1024, buffer=None): + """Read up to LEN bytes and return them. + Return zero-length string on EOF.""" + self._checkClosed() + + while 1: + if not self._sslobj: + raise ValueError("Read on closed or unwrapped SSL socket.") + if len == 0: + return b'' if buffer is None else 0 + if len < 0 and buffer is None: + # This is handled natively in python 2.7.12+ + raise ValueError("Negative read length") + try: + if buffer is not None: + return self._sslobj.read(len, buffer) + return self._sslobj.read(len or 1024) + except SSLWantReadError: + if self.timeout == 0.0: + raise + self._wait(self._read_event, timeout_exc=_SSLErrorReadTimeout) + except SSLWantWriteError: + if self.timeout == 0.0: + raise + # note: using _SSLErrorReadTimeout rather than _SSLErrorWriteTimeout below is intentional + self._wait(self._write_event, timeout_exc=_SSLErrorReadTimeout) + except SSLError as ex: + if ex.args[0] == SSL_ERROR_EOF and self.suppress_ragged_eofs: + if buffer is not None: + return 0 + return b'' + else: + raise + + def write(self, data): + """Write DATA to the underlying SSL channel. Returns + number of bytes of DATA actually transmitted.""" + self._checkClosed() + + while 1: + if not self._sslobj: + raise ValueError("Write on closed or unwrapped SSL socket.") + + try: + return self._sslobj.write(data) + except SSLError as ex: + if ex.args[0] == SSL_ERROR_WANT_READ: + if self.timeout == 0.0: + raise + self._wait(self._read_event, timeout_exc=_SSLErrorWriteTimeout) + elif ex.args[0] == SSL_ERROR_WANT_WRITE: + if self.timeout == 0.0: + raise + self._wait(self._write_event, timeout_exc=_SSLErrorWriteTimeout) + else: + raise + + def getpeercert(self, binary_form=False): + """Returns a formatted version of the data in the + certificate provided by the other end of the SSL channel. + Return None if no certificate was provided, {} if a + certificate was provided, but not validated.""" + + self._checkClosed() + self._check_connected() + return self._sslobj.peer_certificate(binary_form) + + def selected_npn_protocol(self): + self._checkClosed() + if not self._sslobj or not _ssl.HAS_NPN: + return None + return self._sslobj.selected_npn_protocol() + + if hasattr(_ssl, 'HAS_ALPN'): + # 2.7.10+ + def selected_alpn_protocol(self): + self._checkClosed() + if not self._sslobj or not _ssl.HAS_ALPN: # pylint:disable=no-member + return None + return self._sslobj.selected_alpn_protocol() + + def cipher(self): + self._checkClosed() + if not self._sslobj: + return None + return self._sslobj.cipher() + + def compression(self): + self._checkClosed() + if not self._sslobj: + return None + return self._sslobj.compression() + + def __check_flags(self, meth, flags): + if flags != 0: + raise ValueError( + "non-zero flags not allowed in calls to %s on %s" % + (meth, self.__class__)) + + def send(self, data, flags=0, timeout=timeout_default): + self._checkClosed() + self.__check_flags('send', flags) + + if timeout is timeout_default: + timeout = self.timeout + + if not self._sslobj: + return socket.send(self, data, flags, timeout) + + while True: + try: + return self._sslobj.write(data) + except SSLWantReadError: + if self.timeout == 0.0: + return 0 + self._wait(self._read_event) + except SSLWantWriteError: + if self.timeout == 0.0: + return 0 + self._wait(self._write_event) + + def sendto(self, data, flags_or_addr, addr=None): + self._checkClosed() + if self._sslobj: + raise ValueError("sendto not allowed on instances of %s" % + self.__class__) + elif addr is None: + return socket.sendto(self, data, flags_or_addr) + else: + return socket.sendto(self, data, flags_or_addr, addr) + + def sendmsg(self, *args, **kwargs): + # Ensure programs don't send data unencrypted if they try to + # use this method. + raise NotImplementedError("sendmsg not allowed on instances of %s" % + self.__class__) + + def sendall(self, data, flags=0): + self._checkClosed() + self.__check_flags('sendall', flags) + + try: + socket.sendall(self, data) + except _socket_timeout as ex: + if self.timeout == 0.0: + # Python 2 simply *hangs* in this case, which is bad, but + # Python 3 raises SSLWantWriteError. We do the same. + raise SSLWantWriteError("The operation did not complete (write)") + # Convert the socket.timeout back to the sslerror + raise SSLError(*ex.args) + + def recv(self, buflen=1024, flags=0): + self._checkClosed() + if self._sslobj: + if flags != 0: + raise ValueError( + "non-zero flags not allowed in calls to recv() on %s" % + self.__class__) + if buflen == 0: + return b'' + return self.read(buflen) + else: + return socket.recv(self, buflen, flags) + + def recv_into(self, buffer, nbytes=None, flags=0): + self._checkClosed() + if buffer is not None and (nbytes is None): + # Fix for python bug #23804: bool(bytearray()) is False, + # but we should read 0 bytes. + nbytes = len(buffer) + elif nbytes is None: + nbytes = 1024 + if self._sslobj: + if flags != 0: + raise ValueError( + "non-zero flags not allowed in calls to recv_into() on %s" % + self.__class__) + return self.read(nbytes, buffer) + else: + return socket.recv_into(self, buffer, nbytes, flags) + + def recvfrom(self, buflen=1024, flags=0): + self._checkClosed() + if self._sslobj: + raise ValueError("recvfrom not allowed on instances of %s" % + self.__class__) + else: + return socket.recvfrom(self, buflen, flags) + + def recvfrom_into(self, buffer, nbytes=None, flags=0): + self._checkClosed() + if self._sslobj: + raise ValueError("recvfrom_into not allowed on instances of %s" % + self.__class__) + else: + return socket.recvfrom_into(self, buffer, nbytes, flags) + + def recvmsg(self, *args, **kwargs): + raise NotImplementedError("recvmsg not allowed on instances of %s" % + self.__class__) + + def recvmsg_into(self, *args, **kwargs): + raise NotImplementedError("recvmsg_into not allowed on instances of " + "%s" % self.__class__) + + def pending(self): + self._checkClosed() + if self._sslobj: + return self._sslobj.pending() + return 0 + + def shutdown(self, how): + self._checkClosed() + self._sslobj = None + socket.shutdown(self, how) + + def close(self): + if self._makefile_refs < 1: + self._sslobj = None + socket.close(self) + else: + self._makefile_refs -= 1 + + if PYPY: + + def _reuse(self): + self._makefile_refs += 1 + + def _drop(self): + if self._makefile_refs < 1: + self.close() + else: + self._makefile_refs -= 1 + + def _sslobj_shutdown(self): + while True: + try: + return self._sslobj.shutdown() + except SSLError as ex: + if ex.args[0] == SSL_ERROR_EOF and self.suppress_ragged_eofs: + return '' + elif ex.args[0] == SSL_ERROR_WANT_READ: + if self.timeout == 0.0: + raise + sys.exc_clear() + self._wait(self._read_event, timeout_exc=_SSLErrorReadTimeout) + elif ex.args[0] == SSL_ERROR_WANT_WRITE: + if self.timeout == 0.0: + raise + sys.exc_clear() + self._wait(self._write_event, timeout_exc=_SSLErrorWriteTimeout) + else: + raise + + def unwrap(self): + if self._sslobj: + s = self._sslobj_shutdown() + self._sslobj = None + return socket(_sock=s) # match _ssl2; critical to drop/reuse here on PyPy + else: + raise ValueError("No SSL wrapper around " + str(self)) + + def _real_close(self): + self._sslobj = None + socket._real_close(self) # pylint: disable=no-member + + def do_handshake(self): + """Perform a TLS/SSL handshake.""" + self._check_connected() + while True: + try: + self._sslobj.do_handshake() + break + except SSLWantReadError: + if self.timeout == 0.0: + raise + self._wait(self._read_event, timeout_exc=_SSLErrorHandshakeTimeout) + except SSLWantWriteError: + if self.timeout == 0.0: + raise + self._wait(self._write_event, timeout_exc=_SSLErrorHandshakeTimeout) + + if self._context.check_hostname: + if not self.server_hostname: + raise ValueError("check_hostname needs server_hostname " + "argument") + match_hostname(self.getpeercert(), self.server_hostname) + + def _real_connect(self, addr, connect_ex): + if self.server_side: + raise ValueError("can't connect in server-side mode") + # Here we assume that the socket is client-side, and not + # connected at the time of the call. We connect it, then wrap it. + if self._connected: + raise ValueError("attempt to connect already-connected SSLSocket!") + self._sslobj = self._context._wrap_socket(self._sock, False, self.server_hostname, ssl_sock=self) + try: + if connect_ex: + rc = socket.connect_ex(self, addr) + else: + rc = None + socket.connect(self, addr) + if not rc: + self._connected = True + if self.do_handshake_on_connect: + self.do_handshake() + return rc + except socket_error: + self._sslobj = None + raise + + def connect(self, addr): + """Connects to remote ADDR, and then wraps the connection in + an SSL channel.""" + self._real_connect(addr, False) + + def connect_ex(self, addr): + """Connects to remote ADDR, and then wraps the connection in + an SSL channel.""" + return self._real_connect(addr, True) + + def accept(self): + """Accepts a new connection from a remote client, and returns + a tuple containing that new connection wrapped with a server-side + SSL channel, and the address of the remote client.""" + + newsock, addr = socket.accept(self) + newsock = self._context.wrap_socket(newsock, + do_handshake_on_connect=self.do_handshake_on_connect, + suppress_ragged_eofs=self.suppress_ragged_eofs, + server_side=True) + return newsock, addr + + def makefile(self, mode='r', bufsize=-1): + + """Make and return a file-like object that + works with the SSL connection. Just use the code + from the socket module.""" + if not PYPY: + self._makefile_refs += 1 + # close=True so as to decrement the reference count when done with + # the file-like object. + return _fileobject(self, mode, bufsize, close=True) + + def get_channel_binding(self, cb_type="tls-unique"): + """Get channel binding data for current connection. Raise ValueError + if the requested `cb_type` is not supported. Return bytes of the data + or None if the data is not available (e.g. before the handshake). + """ + if cb_type not in CHANNEL_BINDING_TYPES: + raise ValueError("Unsupported channel binding type") + if cb_type != "tls-unique": + raise NotImplementedError( + "{0} channel binding type not implemented" + .format(cb_type)) + if self._sslobj is None: + return None + return self._sslobj.tls_unique_cb() + + def version(self): + """ + Return a string identifying the protocol version used by the + current SSL channel, or None if there is no established channel. + """ + if self._sslobj is None: + return None + return self._sslobj.version() + +if PYPY or not hasattr(SSLSocket, 'timeout'): + # PyPy (and certain versions of CPython) doesn't have a direct + # 'timeout' property on raw sockets, because that's not part of + # the documented specification. We may wind up wrapping a raw + # socket (when ssl is used with PyWSGI) or a gevent socket, which + # does have a read/write timeout property as an alias for + # get/settimeout, so make sure that's always the case because + # pywsgi can depend on that. + SSLSocket.timeout = property(lambda self: self.gettimeout(), + lambda self, value: self.settimeout(value)) + + + +_SSLErrorReadTimeout = SSLError('The read operation timed out') +_SSLErrorWriteTimeout = SSLError('The write operation timed out') +_SSLErrorHandshakeTimeout = SSLError('The handshake operation timed out') + +def wrap_socket(sock, keyfile=None, certfile=None, + server_side=False, cert_reqs=CERT_NONE, + ssl_version=PROTOCOL_SSLv23, ca_certs=None, + do_handshake_on_connect=True, + suppress_ragged_eofs=True, + ciphers=None): + + return SSLSocket(sock=sock, keyfile=keyfile, certfile=certfile, + server_side=server_side, cert_reqs=cert_reqs, + ssl_version=ssl_version, ca_certs=ca_certs, + do_handshake_on_connect=do_handshake_on_connect, + suppress_ragged_eofs=suppress_ragged_eofs, + ciphers=ciphers) + +def get_server_certificate(addr, ssl_version=PROTOCOL_SSLv23, ca_certs=None): + """Retrieve the certificate from the server at the specified address, + and return it as a PEM-encoded string. + If 'ca_certs' is specified, validate the server cert against it. + If 'ssl_version' is specified, use it in the connection attempt.""" + + _, _ = addr + if ca_certs is not None: + cert_reqs = CERT_REQUIRED + else: + cert_reqs = CERT_NONE + context = _create_stdlib_context(ssl_version, + cert_reqs=cert_reqs, + cafile=ca_certs) + with closing(create_connection(addr)) as sock: + with closing(context.wrap_socket(sock)) as sslsock: + dercert = sslsock.getpeercert(True) + return DER_cert_to_PEM_cert(dercert) diff --git a/python/gevent/_tblib.py b/python/gevent/_tblib.py new file mode 100644 index 0000000..91edb01 --- /dev/null +++ b/python/gevent/_tblib.py @@ -0,0 +1,431 @@ +# -*- coding: utf-8 -*- +# A vendored version of part of https://github.com/ionelmc/python-tblib +# pylint:disable=redefined-outer-name,reimported,function-redefined,bare-except,no-else-return,broad-except +#### +# Copyright (c) 2013-2016, Ionel Cristian Mărieș +# All rights reserved. + +# Redistribution and use in source and binary forms, with or without modification, are permitted provided that the +# following conditions are met: + +# 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following +# disclaimer. + +# 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following +# disclaimer in the documentation and/or other materials provided with the distribution. + +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, +# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, +# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +#### + +# cpython.py + +""" +Taken verbatim from Jinja2. + +https://github.com/mitsuhiko/jinja2/blob/master/jinja2/debug.py#L267 +""" +#import platform # XXX: gevent cannot import platform at the top level; interferes with monkey patching +import sys + + +def _init_ugly_crap(): + """This function implements a few ugly things so that we can patch the + traceback objects. The function returned allows resetting `tb_next` on + any python traceback object. Do not attempt to use this on non cpython + interpreters + """ + import ctypes + from types import TracebackType + + # figure out side of _Py_ssize_t + if hasattr(ctypes.pythonapi, 'Py_InitModule4_64'): + _Py_ssize_t = ctypes.c_int64 + else: + _Py_ssize_t = ctypes.c_int + + # regular python + class _PyObject(ctypes.Structure): + pass + + _PyObject._fields_ = [ + ('ob_refcnt', _Py_ssize_t), + ('ob_type', ctypes.POINTER(_PyObject)) + ] + + # python with trace + if hasattr(sys, 'getobjects'): + class _PyObject(ctypes.Structure): + pass + + _PyObject._fields_ = [ + ('_ob_next', ctypes.POINTER(_PyObject)), + ('_ob_prev', ctypes.POINTER(_PyObject)), + ('ob_refcnt', _Py_ssize_t), + ('ob_type', ctypes.POINTER(_PyObject)) + ] + + class _Traceback(_PyObject): + pass + + _Traceback._fields_ = [ + ('tb_next', ctypes.POINTER(_Traceback)), + ('tb_frame', ctypes.POINTER(_PyObject)), + ('tb_lasti', ctypes.c_int), + ('tb_lineno', ctypes.c_int) + ] + + def tb_set_next(tb, next): + """Set the tb_next attribute of a traceback object.""" + if not (isinstance(tb, TracebackType) and (next is None or isinstance(next, TracebackType))): + raise TypeError('tb_set_next arguments must be traceback objects') + obj = _Traceback.from_address(id(tb)) + if tb.tb_next is not None: + old = _Traceback.from_address(id(tb.tb_next)) + old.ob_refcnt -= 1 + if next is None: + obj.tb_next = ctypes.POINTER(_Traceback)() + else: + next = _Traceback.from_address(id(next)) + next.ob_refcnt += 1 + obj.tb_next = ctypes.pointer(next) + + return tb_set_next + + +tb_set_next = None +#try: +# if platform.python_implementation() == 'CPython': +# tb_set_next = _init_ugly_crap() +#except Exception as exc: +# sys.stderr.write("Failed to initialize cpython support: {!r}".format(exc)) +#del _init_ugly_crap + +# __init__.py +import re +from types import CodeType +from types import TracebackType + +try: + from __pypy__ import tproxy +except ImportError: + tproxy = None + +__version__ = '1.3.0' +__all__ = ('Traceback',) + +PY3 = sys.version_info[0] == 3 +FRAME_RE = re.compile(r'^\s*File "(?P.+)", line (?P\d+)(, in (?P.+))?$') + + +class _AttrDict(dict): + __slots__ = () + __getattr__ = dict.__getitem__ + + +# noinspection PyPep8Naming +class __traceback_maker(Exception): + pass + + +class TracebackParseError(Exception): + pass + + +class Code(object): + def __init__(self, code): + self.co_filename = code.co_filename + self.co_name = code.co_name + # gevent: copy more attributes + self.co_nlocals = code.co_nlocals + self.co_stacksize = code.co_stacksize + self.co_flags = code.co_flags + self.co_firstlineno = code.co_firstlineno + + +class Frame(object): + def __init__(self, frame): + self.f_globals = dict([ + (k, v) + for k, v in frame.f_globals.items() + if k in ("__file__", "__name__") + ]) + self.f_code = Code(frame.f_code) + + def clear(self): + # For compatibility with PyPy 3.5; + # clear was added to frame in Python 3.4 + # and is called by traceback.clear_frames(), which + # in turn is called by unittest.TestCase.assertRaises + pass + +class Traceback(object): + + tb_next = None + + def __init__(self, tb): + self.tb_frame = Frame(tb.tb_frame) + # noinspection SpellCheckingInspection + self.tb_lineno = int(tb.tb_lineno) + + # Build in place to avoid exceeding the recursion limit + tb = tb.tb_next + prev_traceback = self + cls = type(self) + while tb is not None: + traceback = object.__new__(cls) + traceback.tb_frame = Frame(tb.tb_frame) + traceback.tb_lineno = int(tb.tb_lineno) + prev_traceback.tb_next = traceback + prev_traceback = traceback + tb = tb.tb_next + + def as_traceback(self): + if tproxy: + return tproxy(TracebackType, self.__tproxy_handler) + if not tb_set_next: + raise RuntimeError("Cannot re-create traceback !") + + current = self + top_tb = None + tb = None + while current: + f_code = current.tb_frame.f_code + code = compile('\n' * (current.tb_lineno - 1) + 'raise __traceback_maker', current.tb_frame.f_code.co_filename, 'exec') + if PY3: + code = CodeType( + 0, code.co_kwonlyargcount, + code.co_nlocals, code.co_stacksize, code.co_flags, + code.co_code, code.co_consts, code.co_names, code.co_varnames, + f_code.co_filename, f_code.co_name, + code.co_firstlineno, code.co_lnotab, (), () + ) + else: + code = CodeType( + 0, + code.co_nlocals, code.co_stacksize, code.co_flags, + code.co_code, code.co_consts, code.co_names, code.co_varnames, + f_code.co_filename.encode(), f_code.co_name.encode(), + code.co_firstlineno, code.co_lnotab, (), () + ) + + # noinspection PyBroadException + try: + exec(code, current.tb_frame.f_globals, {}) + except: + next_tb = sys.exc_info()[2].tb_next + if top_tb is None: + top_tb = next_tb + if tb is not None: + tb_set_next(tb, next_tb) + tb = next_tb + del next_tb + + current = current.tb_next + try: + return top_tb + finally: + del top_tb + del tb + + + # noinspection SpellCheckingInspection + def __tproxy_handler(self, operation, *args, **kwargs): + if operation in ('__getattribute__', '__getattr__'): + if args[0] == 'tb_next': + return self.tb_next and self.tb_next.as_traceback() + else: + return getattr(self, args[0]) + else: + return getattr(self, operation)(*args, **kwargs) + + def to_dict(self): + """Convert a Traceback into a dictionary representation""" + if self.tb_next is None: + tb_next = None + else: + tb_next = self.tb_next.to_dict() + + code = { + 'co_filename': self.tb_frame.f_code.co_filename, + 'co_name': self.tb_frame.f_code.co_name, + } + frame = { + 'f_globals': self.tb_frame.f_globals, + 'f_code': code, + } + return { + 'tb_frame': frame, + 'tb_lineno': self.tb_lineno, + 'tb_next': tb_next, + } + + @classmethod + def from_dict(cls, dct): + if dct['tb_next']: + tb_next = cls.from_dict(dct['tb_next']) + else: + tb_next = None + + code = _AttrDict( + co_filename=dct['tb_frame']['f_code']['co_filename'], + co_name=dct['tb_frame']['f_code']['co_name'], + ) + frame = _AttrDict( + f_globals=dct['tb_frame']['f_globals'], + f_code=code, + ) + tb = _AttrDict( + tb_frame=frame, + tb_lineno=dct['tb_lineno'], + tb_next=tb_next, + ) + return cls(tb) + + @classmethod + def from_string(cls, string, strict=True): + frames = [] + header = strict + + for line in string.splitlines(): + line = line.rstrip() + if header: + if line == 'Traceback (most recent call last):': + header = False + continue + frame_match = FRAME_RE.match(line) + if frame_match: + frames.append(frame_match.groupdict()) + elif line.startswith(' '): + pass + elif strict: + break # traceback ended + + if frames: + previous = None + for frame in reversed(frames): + previous = _AttrDict( + frame, + tb_frame=_AttrDict( + frame, + f_globals=_AttrDict( + __file__=frame['co_filename'], + __name__='?', + ), + f_code=_AttrDict(frame), + ), + tb_next=previous, + ) + return cls(previous) + else: + raise TracebackParseError("Could not find any frames in %r." % string) + +# pickling_support.py + + +def unpickle_traceback(tb_frame, tb_lineno, tb_next): + ret = object.__new__(Traceback) + ret.tb_frame = tb_frame + ret.tb_lineno = tb_lineno + ret.tb_next = tb_next + return ret.as_traceback() + + +def pickle_traceback(tb): + return unpickle_traceback, (Frame(tb.tb_frame), tb.tb_lineno, tb.tb_next and Traceback(tb.tb_next)) + + +def install(): + try: + import copy_reg + except ImportError: + import copyreg as copy_reg + + copy_reg.pickle(TracebackType, pickle_traceback) + +# Added by gevent + +# We have to defer the initialization, and especially the import of platform, +# until runtime. If we're monkey patched, we need to be sure to use +# the original __import__ to avoid switching through the hub due to +# import locks on Python 2. See also builtins.py for details. + + +def _unlocked_imports(f): + def g(a): + if sys is None: # pragma: no cover + # interpreter shutdown on Py2 + return + + gb = None + if 'gevent.builtins' in sys.modules: + gb = sys.modules['gevent.builtins'] + gb._unlock_imports() + try: + return f(a) + finally: + if gb is not None: + gb._lock_imports() + g.__name__ = f.__name__ + g.__module__ = f.__module__ + return g + + +def _import_dump_load(): + global dumps + global loads + try: + import cPickle as pickle + except ImportError: + import pickle + dumps = pickle.dumps + loads = pickle.loads + +dumps = loads = None + +_installed = False + + +def _init(): + global _installed + global tb_set_next + if _installed: + return + + _installed = True + import platform + try: + if platform.python_implementation() == 'CPython': + tb_set_next = _init_ugly_crap() + except Exception as exc: + sys.stderr.write("Failed to initialize cpython support: {!r}".format(exc)) + + try: + from __pypy__ import tproxy + except ImportError: + tproxy = None + + if not tb_set_next and not tproxy: + raise ImportError("Cannot use tblib. Runtime not supported.") + _import_dump_load() + install() + + +@_unlocked_imports +def dump_traceback(tb): + # Both _init and dump/load have to be unlocked, because + # copy_reg and pickle can do imports to resolve class names; those + # class names are in this module and greenlet safe though + _init() + return dumps(tb) + + +@_unlocked_imports +def load_traceback(s): + _init() + return loads(s) diff --git a/python/gevent/_threading.py b/python/gevent/_threading.py new file mode 100644 index 0000000..2f5ffbc --- /dev/null +++ b/python/gevent/_threading.py @@ -0,0 +1,515 @@ +"""A clone of threading module (version 2.7.2) that always +targets real OS threads. (Unlike 'threading' which flips between +green and OS threads based on whether the monkey patching is in effect +or not). + +This module is missing 'Thread' class, but includes 'Queue'. +""" +from __future__ import absolute_import +try: + from Queue import Full, Empty +except ImportError: + from queue import Full, Empty # pylint:disable=import-error +from collections import deque +import heapq +from time import time as _time, sleep as _sleep + +from gevent import monkey +from gevent._compat import PY3 + + +__all__ = ['Condition', + 'Event', + 'Lock', + 'RLock', + 'Semaphore', + 'BoundedSemaphore', + 'Queue', + 'local', + 'stack_size'] + + +thread_name = '_thread' if PY3 else 'thread' +start_new_thread, Lock, get_ident, local, stack_size = monkey.get_original(thread_name, [ + 'start_new_thread', 'allocate_lock', 'get_ident', '_local', 'stack_size']) + + +class RLock(object): + + def __init__(self): + self.__block = Lock() + self.__owner = None + self.__count = 0 + + def __repr__(self): + owner = self.__owner + return "<%s owner=%r count=%d>" % ( + self.__class__.__name__, owner, self.__count) + + def acquire(self, blocking=1): + me = get_ident() + if self.__owner == me: + self.__count = self.__count + 1 + return 1 + rc = self.__block.acquire(blocking) + if rc: + self.__owner = me + self.__count = 1 + return rc + + __enter__ = acquire + + def release(self): + if self.__owner != get_ident(): + raise RuntimeError("cannot release un-acquired lock") + self.__count = count = self.__count - 1 + if not count: + self.__owner = None + self.__block.release() + + def __exit__(self, t, v, tb): + self.release() + + # Internal methods used by condition variables + + def _acquire_restore(self, count_owner): + count, owner = count_owner + self.__block.acquire() + self.__count = count + self.__owner = owner + + def _release_save(self): + count = self.__count + self.__count = 0 + owner = self.__owner + self.__owner = None + self.__block.release() + return (count, owner) + + def _is_owned(self): + return self.__owner == get_ident() + + +class Condition(object): + # pylint:disable=method-hidden + + def __init__(self, lock=None): + if lock is None: + lock = RLock() + self.__lock = lock + # Export the lock's acquire() and release() methods + self.acquire = lock.acquire + self.release = lock.release + # If the lock defines _release_save() and/or _acquire_restore(), + # these override the default implementations (which just call + # release() and acquire() on the lock). Ditto for _is_owned(). + try: + self._release_save = lock._release_save + except AttributeError: + pass + try: + self._acquire_restore = lock._acquire_restore + except AttributeError: + pass + try: + self._is_owned = lock._is_owned + except AttributeError: + pass + self.__waiters = [] + + def __enter__(self): + return self.__lock.__enter__() + + def __exit__(self, *args): + return self.__lock.__exit__(*args) + + def __repr__(self): + return "" % (self.__lock, len(self.__waiters)) + + def _release_save(self): + self.__lock.release() # No state to save + + def _acquire_restore(self, x): # pylint:disable=unused-argument + self.__lock.acquire() # Ignore saved state + + def _is_owned(self): + # Return True if lock is owned by current_thread. + # This method is called only if __lock doesn't have _is_owned(). + if self.__lock.acquire(0): + self.__lock.release() + return False + return True + + def wait(self, timeout=None): + if not self._is_owned(): + raise RuntimeError("cannot wait on un-acquired lock") + waiter = Lock() + waiter.acquire() + self.__waiters.append(waiter) + saved_state = self._release_save() + try: # restore state no matter what (e.g., KeyboardInterrupt) + if timeout is None: + waiter.acquire() + else: + # Balancing act: We can't afford a pure busy loop, so we + # have to sleep; but if we sleep the whole timeout time, + # we'll be unresponsive. The scheme here sleeps very + # little at first, longer as time goes on, but never longer + # than 20 times per second (or the timeout time remaining). + endtime = _time() + timeout + delay = 0.0005 # 500 us -> initial delay of 1 ms + while True: + gotit = waiter.acquire(0) + if gotit: + break + remaining = endtime - _time() + if remaining <= 0: + break + delay = min(delay * 2, remaining, .05) + _sleep(delay) + if not gotit: + try: + self.__waiters.remove(waiter) + except ValueError: + pass + finally: + self._acquire_restore(saved_state) + + def notify(self, n=1): + if not self._is_owned(): + raise RuntimeError("cannot notify on un-acquired lock") + __waiters = self.__waiters + waiters = __waiters[:n] + if not waiters: + return + for waiter in waiters: + waiter.release() + try: + __waiters.remove(waiter) + except ValueError: + pass + + def notify_all(self): + self.notify(len(self.__waiters)) + + +class Semaphore(object): + + # After Tim Peters' semaphore class, but not quite the same (no maximum) + + def __init__(self, value=1): + if value < 0: + raise ValueError("semaphore initial value must be >= 0") + self.__cond = Condition(Lock()) + self.__value = value + + def acquire(self, blocking=1): + rc = False + self.__cond.acquire() + while self.__value == 0: + if not blocking: + break + self.__cond.wait() + else: + self.__value = self.__value - 1 + rc = True + self.__cond.release() + return rc + + __enter__ = acquire + + def release(self): + self.__cond.acquire() + self.__value = self.__value + 1 + self.__cond.notify() + self.__cond.release() + + def __exit__(self, t, v, tb): + self.release() + + +class BoundedSemaphore(Semaphore): + """Semaphore that checks that # releases is <= # acquires""" + def __init__(self, value=1): + Semaphore.__init__(self, value) + self._initial_value = value + + def release(self): + if self.Semaphore__value >= self._initial_value: # pylint:disable=no-member + raise ValueError("Semaphore released too many times") + return Semaphore.release(self) + + +class Event(object): + + # After Tim Peters' event class (without is_posted()) + + def __init__(self): + self.__cond = Condition(Lock()) + self.__flag = False + + def _reset_internal_locks(self): + # private! called by Thread._reset_internal_locks by _after_fork() + self.__cond.__init__() + + def is_set(self): + return self.__flag + + def set(self): + self.__cond.acquire() + try: + self.__flag = True + self.__cond.notify_all() + finally: + self.__cond.release() + + def clear(self): + self.__cond.acquire() + try: + self.__flag = False + finally: + self.__cond.release() + + def wait(self, timeout=None): + self.__cond.acquire() + try: + if not self.__flag: + self.__cond.wait(timeout) + return self.__flag + finally: + self.__cond.release() + + +class Queue: # pylint:disable=old-style-class + """Create a queue object with a given maximum size. + + If maxsize is <= 0, the queue size is infinite. + """ + def __init__(self, maxsize=0): + self.maxsize = maxsize + self._init(maxsize) + # mutex must be held whenever the queue is mutating. All methods + # that acquire mutex must release it before returning. mutex + # is shared between the three conditions, so acquiring and + # releasing the conditions also acquires and releases mutex. + self.mutex = Lock() + # Notify not_empty whenever an item is added to the queue; a + # thread waiting to get is notified then. + self.not_empty = Condition(self.mutex) + # Notify not_full whenever an item is removed from the queue; + # a thread waiting to put is notified then. + self.not_full = Condition(self.mutex) + # Notify all_tasks_done whenever the number of unfinished tasks + # drops to zero; thread waiting to join() is notified to resume + self.all_tasks_done = Condition(self.mutex) + self.unfinished_tasks = 0 + + def task_done(self): + """Indicate that a formerly enqueued task is complete. + + Used by Queue consumer threads. For each get() used to fetch a task, + a subsequent call to task_done() tells the queue that the processing + on the task is complete. + + If a join() is currently blocking, it will resume when all items + have been processed (meaning that a task_done() call was received + for every item that had been put() into the queue). + + Raises a ValueError if called more times than there were items + placed in the queue. + """ + self.all_tasks_done.acquire() + try: + unfinished = self.unfinished_tasks - 1 + if unfinished <= 0: + if unfinished < 0: + raise ValueError('task_done() called too many times') + self.all_tasks_done.notify_all() + self.unfinished_tasks = unfinished + finally: + self.all_tasks_done.release() + + def join(self): + """Blocks until all items in the Queue have been gotten and processed. + + The count of unfinished tasks goes up whenever an item is added to the + queue. The count goes down whenever a consumer thread calls task_done() + to indicate the item was retrieved and all work on it is complete. + + When the count of unfinished tasks drops to zero, join() unblocks. + """ + self.all_tasks_done.acquire() + try: + while self.unfinished_tasks: + self.all_tasks_done.wait() + finally: + self.all_tasks_done.release() + + def qsize(self): + """Return the approximate size of the queue (not reliable!).""" + self.mutex.acquire() + try: + return self._qsize() + finally: + self.mutex.release() + + def empty(self): + """Return True if the queue is empty, False otherwise (not reliable!).""" + self.mutex.acquire() + try: + return not self._qsize() + finally: + self.mutex.release() + + def full(self): + """Return True if the queue is full, False otherwise (not reliable!).""" + self.mutex.acquire() + try: + if self.maxsize <= 0: + return False + if self.maxsize >= self._qsize(): + return True + finally: + self.mutex.release() + + def put(self, item, block=True, timeout=None): + """Put an item into the queue. + + If optional args 'block' is true and 'timeout' is None (the default), + block if necessary until a free slot is available. If 'timeout' is + a positive number, it blocks at most 'timeout' seconds and raises + the Full exception if no free slot was available within that time. + Otherwise ('block' is false), put an item on the queue if a free slot + is immediately available, else raise the Full exception ('timeout' + is ignored in that case). + """ + self.not_full.acquire() + try: + if self.maxsize > 0: + if not block: + if self._qsize() >= self.maxsize: + raise Full + elif timeout is None: + while self._qsize() >= self.maxsize: + self.not_full.wait() + elif timeout < 0: + raise ValueError("'timeout' must be a positive number") + else: + endtime = _time() + timeout + while self._qsize() >= self.maxsize: + remaining = endtime - _time() + if remaining <= 0.0: + raise Full + self.not_full.wait(remaining) + self._put(item) + self.unfinished_tasks += 1 + self.not_empty.notify() + finally: + self.not_full.release() + + def put_nowait(self, item): + """Put an item into the queue without blocking. + + Only enqueue the item if a free slot is immediately available. + Otherwise raise the Full exception. + """ + return self.put(item, False) + + def get(self, block=True, timeout=None): + """Remove and return an item from the queue. + + If optional args 'block' is true and 'timeout' is None (the default), + block if necessary until an item is available. If 'timeout' is + a positive number, it blocks at most 'timeout' seconds and raises + the Empty exception if no item was available within that time. + Otherwise ('block' is false), return an item if one is immediately + available, else raise the Empty exception ('timeout' is ignored + in that case). + """ + self.not_empty.acquire() + try: + if not block: + if not self._qsize(): + raise Empty + elif timeout is None: + while not self._qsize(): + self.not_empty.wait() + elif timeout < 0: + raise ValueError("'timeout' must be a positive number") + else: + endtime = _time() + timeout + while not self._qsize(): + remaining = endtime - _time() + if remaining <= 0.0: + raise Empty + self.not_empty.wait(remaining) + item = self._get() + self.not_full.notify() + return item + finally: + self.not_empty.release() + + def get_nowait(self): + """Remove and return an item from the queue without blocking. + + Only get an item if one is immediately available. Otherwise + raise the Empty exception. + """ + return self.get(False) + + # Override these methods to implement other queue organizations + # (e.g. stack or priority queue). + # These will only be called with appropriate locks held + + # Initialize the queue representation + def _init(self, maxsize): + # pylint:disable=unused-argument + self.queue = deque() + + def _qsize(self, len=len): + return len(self.queue) + + # Put a new item in the queue + def _put(self, item): + self.queue.append(item) + + # Get an item from the queue + def _get(self): + return self.queue.popleft() + + +class PriorityQueue(Queue): + '''Variant of Queue that retrieves open entries in priority order (lowest first). + + Entries are typically tuples of the form: (priority number, data). + ''' + + def _init(self, maxsize): + self.queue = [] + + def _qsize(self, len=len): + return len(self.queue) + + def _put(self, item, heappush=heapq.heappush): + # pylint:disable=arguments-differ + heappush(self.queue, item) + + def _get(self, heappop=heapq.heappop): + # pylint:disable=arguments-differ + return heappop(self.queue) + + +class LifoQueue(Queue): + '''Variant of Queue that retrieves most recently added entries first.''' + + def _init(self, maxsize): + self.queue = [] + + def _qsize(self, len=len): + return len(self.queue) + + def _put(self, item): + self.queue.append(item) + + def _get(self): + return self.queue.pop() diff --git a/python/gevent/_util.py b/python/gevent/_util.py new file mode 100644 index 0000000..4178a84 --- /dev/null +++ b/python/gevent/_util.py @@ -0,0 +1,106 @@ +# -*- coding: utf-8 -*- +""" +internal gevent utilities, not for external use. +""" + +from __future__ import print_function, absolute_import, division + +from gevent._compat import iteritems + + +class _NONE(object): + """ + A special object you must never pass to any gevent API. + Used as a marker object for keyword arguments that cannot have the + builtin None (because that might be a valid value). + """ + __slots__ = () + + def __repr__(self): + return '' + +_NONE = _NONE() + +def copy_globals(source, + globs, + only_names=None, + ignore_missing_names=False, + names_to_ignore=(), + dunder_names_to_keep=('__implements__', '__all__', '__imports__'), + cleanup_globs=True): + """ + Copy attributes defined in `source.__dict__` to the dictionary in globs + (which should be the caller's globals()). + + Names that start with `__` are ignored (unless they are in + *dunder_names_to_keep*). Anything found in *names_to_ignore* is + also ignored. + + If *only_names* is given, only those attributes will be considered. + In this case, *ignore_missing_names* says whether or not to raise an AttributeError + if one of those names can't be found. + + If cleanup_globs has a true value, then common things imported but not used + at runtime are removed, including this function. + + Returns a list of the names copied + """ + if only_names: + if ignore_missing_names: + items = ((k, getattr(source, k, _NONE)) for k in only_names) + else: + items = ((k, getattr(source, k)) for k in only_names) + else: + items = iteritems(source.__dict__) + + copied = [] + for key, value in items: + if value is _NONE: + continue + if key in names_to_ignore: + continue + if key.startswith("__") and key not in dunder_names_to_keep: + continue + globs[key] = value + copied.append(key) + + if cleanup_globs: + if 'copy_globals' in globs: + del globs['copy_globals'] + + return copied + +class Lazy(object): + """ + A non-data descriptor used just like @property. The + difference is the function value is assigned to the instance + dict the first time it is accessed and then the function is never + called agoin. + """ + def __init__(self, func): + self.data = (func, func.__name__) + + def __get__(self, inst, class_): + if inst is None: + return self + + func, name = self.data + value = func(inst) + inst.__dict__[name] = value + return value + +class readproperty(object): + """ + A non-data descriptor like @property. The difference is that + when the property is assigned to, it is cached in the instance + and the function is not called on that instance again. + """ + + def __init__(self, func): + self.func = func + + def __get__(self, inst, class_): + if inst is None: + return self + + return self.func(inst) diff --git a/python/gevent/_util_py2.py b/python/gevent/_util_py2.py new file mode 100644 index 0000000..dc74eec --- /dev/null +++ b/python/gevent/_util_py2.py @@ -0,0 +1,7 @@ +# this produces syntax error on Python3 + +__all__ = ['reraise'] + + +def reraise(type, value, tb): + raise type, value, tb diff --git a/python/gevent/ares.pyx b/python/gevent/ares.pyx new file mode 100644 index 0000000..92832cc --- /dev/null +++ b/python/gevent/ares.pyx @@ -0,0 +1,454 @@ +# Copyright (c) 2011-2012 Denis Bilenko. See LICENSE for details. +cimport cares +import sys +from python cimport * +from _socket import gaierror + + +__all__ = ['channel'] + +cdef object string_types +cdef object text_type + +if sys.version_info[0] >= 3: + string_types = str, + text_type = str +else: + string_types = __builtins__.basestring, + text_type = __builtins__.unicode + +TIMEOUT = 1 + +DEF EV_READ = 1 +DEF EV_WRITE = 2 + + +cdef extern from "dnshelper.c": + int AF_INET + int AF_INET6 + + struct hostent: + char* h_name + int h_addrtype + + struct sockaddr_t "sockaddr": + pass + + struct ares_channeldata: + pass + + object parse_h_name(hostent*) + object parse_h_aliases(hostent*) + object parse_h_addr_list(hostent*) + void* create_object_from_hostent(void*) + + # this imports _socket lazily + object PyUnicode_FromString(char*) + int PyTuple_Check(object) + int PyArg_ParseTuple(object, char*, ...) except 0 + struct sockaddr_in6: + pass + int gevent_make_sockaddr(char* hostp, int port, int flowinfo, int scope_id, sockaddr_in6* sa6) + + void* malloc(int) + void free(void*) + void memset(void*, int, int) + + +ARES_SUCCESS = cares.ARES_SUCCESS +ARES_ENODATA = cares.ARES_ENODATA +ARES_EFORMERR = cares.ARES_EFORMERR +ARES_ESERVFAIL = cares.ARES_ESERVFAIL +ARES_ENOTFOUND = cares.ARES_ENOTFOUND +ARES_ENOTIMP = cares.ARES_ENOTIMP +ARES_EREFUSED = cares.ARES_EREFUSED +ARES_EBADQUERY = cares.ARES_EBADQUERY +ARES_EBADNAME = cares.ARES_EBADNAME +ARES_EBADFAMILY = cares.ARES_EBADFAMILY +ARES_EBADRESP = cares.ARES_EBADRESP +ARES_ECONNREFUSED = cares.ARES_ECONNREFUSED +ARES_ETIMEOUT = cares.ARES_ETIMEOUT +ARES_EOF = cares.ARES_EOF +ARES_EFILE = cares.ARES_EFILE +ARES_ENOMEM = cares.ARES_ENOMEM +ARES_EDESTRUCTION = cares.ARES_EDESTRUCTION +ARES_EBADSTR = cares.ARES_EBADSTR +ARES_EBADFLAGS = cares.ARES_EBADFLAGS +ARES_ENONAME = cares.ARES_ENONAME +ARES_EBADHINTS = cares.ARES_EBADHINTS +ARES_ENOTINITIALIZED = cares.ARES_ENOTINITIALIZED +ARES_ELOADIPHLPAPI = cares.ARES_ELOADIPHLPAPI +ARES_EADDRGETNETWORKPARAMS = cares.ARES_EADDRGETNETWORKPARAMS +ARES_ECANCELLED = cares.ARES_ECANCELLED + +ARES_FLAG_USEVC = cares.ARES_FLAG_USEVC +ARES_FLAG_PRIMARY = cares.ARES_FLAG_PRIMARY +ARES_FLAG_IGNTC = cares.ARES_FLAG_IGNTC +ARES_FLAG_NORECURSE = cares.ARES_FLAG_NORECURSE +ARES_FLAG_STAYOPEN = cares.ARES_FLAG_STAYOPEN +ARES_FLAG_NOSEARCH = cares.ARES_FLAG_NOSEARCH +ARES_FLAG_NOALIASES = cares.ARES_FLAG_NOALIASES +ARES_FLAG_NOCHECKRESP = cares.ARES_FLAG_NOCHECKRESP + + +_ares_errors = dict([ + (cares.ARES_SUCCESS, 'ARES_SUCCESS'), + (cares.ARES_ENODATA, 'ARES_ENODATA'), + (cares.ARES_EFORMERR, 'ARES_EFORMERR'), + (cares.ARES_ESERVFAIL, 'ARES_ESERVFAIL'), + (cares.ARES_ENOTFOUND, 'ARES_ENOTFOUND'), + (cares.ARES_ENOTIMP, 'ARES_ENOTIMP'), + (cares.ARES_EREFUSED, 'ARES_EREFUSED'), + (cares.ARES_EBADQUERY, 'ARES_EBADQUERY'), + (cares.ARES_EBADNAME, 'ARES_EBADNAME'), + (cares.ARES_EBADFAMILY, 'ARES_EBADFAMILY'), + (cares.ARES_EBADRESP, 'ARES_EBADRESP'), + (cares.ARES_ECONNREFUSED, 'ARES_ECONNREFUSED'), + (cares.ARES_ETIMEOUT, 'ARES_ETIMEOUT'), + (cares.ARES_EOF, 'ARES_EOF'), + (cares.ARES_EFILE, 'ARES_EFILE'), + (cares.ARES_ENOMEM, 'ARES_ENOMEM'), + (cares.ARES_EDESTRUCTION, 'ARES_EDESTRUCTION'), + (cares.ARES_EBADSTR, 'ARES_EBADSTR'), + (cares.ARES_EBADFLAGS, 'ARES_EBADFLAGS'), + (cares.ARES_ENONAME, 'ARES_ENONAME'), + (cares.ARES_EBADHINTS, 'ARES_EBADHINTS'), + (cares.ARES_ENOTINITIALIZED, 'ARES_ENOTINITIALIZED'), + (cares.ARES_ELOADIPHLPAPI, 'ARES_ELOADIPHLPAPI'), + (cares.ARES_EADDRGETNETWORKPARAMS, 'ARES_EADDRGETNETWORKPARAMS'), + (cares.ARES_ECANCELLED, 'ARES_ECANCELLED')]) + + +# maps c-ares flag to _socket module flag +_cares_flag_map = None + + +cdef _prepare_cares_flag_map(): + global _cares_flag_map + import _socket + _cares_flag_map = [ + (getattr(_socket, 'NI_NUMERICHOST', 1), cares.ARES_NI_NUMERICHOST), + (getattr(_socket, 'NI_NUMERICSERV', 2), cares.ARES_NI_NUMERICSERV), + (getattr(_socket, 'NI_NOFQDN', 4), cares.ARES_NI_NOFQDN), + (getattr(_socket, 'NI_NAMEREQD', 8), cares.ARES_NI_NAMEREQD), + (getattr(_socket, 'NI_DGRAM', 16), cares.ARES_NI_DGRAM)] + + +cpdef _convert_cares_flags(int flags, int default=cares.ARES_NI_LOOKUPHOST|cares.ARES_NI_LOOKUPSERVICE): + if _cares_flag_map is None: + _prepare_cares_flag_map() + for socket_flag, cares_flag in _cares_flag_map: + if socket_flag & flags: + default |= cares_flag + flags &= ~socket_flag + if not flags: + return default + raise gaierror(-1, "Bad value for ai_flags: 0x%x" % flags) + + +cpdef strerror(code): + return '%s: %s' % (_ares_errors.get(code) or code, cares.ares_strerror(code)) + + +class InvalidIP(ValueError): + pass + + +cdef void gevent_sock_state_callback(void *data, int s, int read, int write): + if not data: + return + cdef channel ch = data + ch._sock_state_callback(s, read, write) + + +cdef class result: + cdef public object value + cdef public object exception + + def __init__(self, object value=None, object exception=None): + self.value = value + self.exception = exception + + def __repr__(self): + if self.exception is None: + return '%s(%r)' % (self.__class__.__name__, self.value) + elif self.value is None: + return '%s(exception=%r)' % (self.__class__.__name__, self.exception) + else: + return '%s(value=%r, exception=%r)' % (self.__class__.__name__, self.value, self.exception) + # add repr_recursive precaution + + def successful(self): + return self.exception is None + + def get(self): + if self.exception is not None: + raise self.exception + return self.value + + +class ares_host_result(tuple): + + def __new__(cls, family, iterable): + cdef object self = tuple.__new__(cls, iterable) + self.family = family + return self + + def __getnewargs__(self): + return (self.family, tuple(self)) + + +cdef void gevent_ares_host_callback(void *arg, int status, int timeouts, hostent* host): + cdef channel channel + cdef object callback + channel, callback = arg + Py_DECREF(arg) + cdef object host_result + try: + if status or not host: + callback(result(None, gaierror(status, strerror(status)))) + else: + try: + host_result = ares_host_result(host.h_addrtype, (parse_h_name(host), parse_h_aliases(host), parse_h_addr_list(host))) + except: + callback(result(None, sys.exc_info()[1])) + else: + callback(result(host_result)) + except: + channel.loop.handle_error(callback, *sys.exc_info()) + + +cdef void gevent_ares_nameinfo_callback(void *arg, int status, int timeouts, char *c_node, char *c_service): + cdef channel channel + cdef object callback + channel, callback = arg + Py_DECREF(arg) + cdef object node + cdef object service + try: + if status: + callback(result(None, gaierror(status, strerror(status)))) + else: + if c_node: + node = PyUnicode_FromString(c_node) + else: + node = None + if c_service: + service = PyUnicode_FromString(c_service) + else: + service = None + callback(result((node, service))) + except: + channel.loop.handle_error(callback, *sys.exc_info()) + + +cdef public class channel [object PyGeventAresChannelObject, type PyGeventAresChannel_Type]: + + cdef public object loop + cdef ares_channeldata* channel + cdef public dict _watchers + cdef public object _timer + + def __init__(self, object loop, flags=None, timeout=None, tries=None, ndots=None, + udp_port=None, tcp_port=None, servers=None): + cdef ares_channeldata* channel = NULL + cdef cares.ares_options options + memset(&options, 0, sizeof(cares.ares_options)) + cdef int optmask = cares.ARES_OPT_SOCK_STATE_CB + options.sock_state_cb = gevent_sock_state_callback + options.sock_state_cb_data = self + if flags is not None: + options.flags = int(flags) + optmask |= cares.ARES_OPT_FLAGS + if timeout is not None: + options.timeout = int(float(timeout) * 1000) + optmask |= cares.ARES_OPT_TIMEOUTMS + if tries is not None: + options.tries = int(tries) + optmask |= cares.ARES_OPT_TRIES + if ndots is not None: + options.ndots = int(ndots) + optmask |= cares.ARES_OPT_NDOTS + if udp_port is not None: + options.udp_port = int(udp_port) + optmask |= cares.ARES_OPT_UDP_PORT + if tcp_port is not None: + options.tcp_port = int(tcp_port) + optmask |= cares.ARES_OPT_TCP_PORT + cdef int result = cares.ares_library_init(cares.ARES_LIB_INIT_ALL) # ARES_LIB_INIT_WIN32 -DUSE_WINSOCK? + if result: + raise gaierror(result, strerror(result)) + result = cares.ares_init_options(&channel, &options, optmask) + if result: + raise gaierror(result, strerror(result)) + self._timer = loop.timer(TIMEOUT, TIMEOUT) + self._watchers = {} + self.channel = channel + try: + if servers is not None: + self.set_servers(servers) + self.loop = loop + except: + self.destroy() + raise + + def __repr__(self): + args = (self.__class__.__name__, id(self), self._timer, len(self._watchers)) + return '<%s at 0x%x _timer=%r _watchers[%s]>' % args + + def destroy(self): + if self.channel: + # XXX ares_library_cleanup? + cares.ares_destroy(self.channel) + self.channel = NULL + self._watchers.clear() + self._timer.stop() + self.loop = None + + def __dealloc__(self): + if self.channel: + # XXX ares_library_cleanup? + cares.ares_destroy(self.channel) + self.channel = NULL + + def set_servers(self, servers=None): + if not self.channel: + raise gaierror(cares.ARES_EDESTRUCTION, 'this ares channel has been destroyed') + if not servers: + servers = [] + if isinstance(servers, string_types): + servers = servers.split(',') + cdef int length = len(servers) + cdef int result, index + cdef char* string + cdef cares.ares_addr_node* c_servers + if length <= 0: + result = cares.ares_set_servers(self.channel, NULL) + else: + c_servers = malloc(sizeof(cares.ares_addr_node) * length) + if not c_servers: + raise MemoryError + try: + index = 0 + for server in servers: + if isinstance(server, unicode): + server = server.encode('ascii') + string = server + if cares.ares_inet_pton(AF_INET, string, &c_servers[index].addr) > 0: + c_servers[index].family = AF_INET + elif cares.ares_inet_pton(AF_INET6, string, &c_servers[index].addr) > 0: + c_servers[index].family = AF_INET6 + else: + raise InvalidIP(repr(string)) + c_servers[index].next = &c_servers[index] + 1 + index += 1 + if index >= length: + break + c_servers[length - 1].next = NULL + index = cares.ares_set_servers(self.channel, c_servers) + if index: + raise ValueError(strerror(index)) + finally: + free(c_servers) + + # this crashes c-ares + #def cancel(self): + # cares.ares_cancel(self.channel) + + cdef _sock_state_callback(self, int socket, int read, int write): + if not self.channel: + return + cdef object watcher = self._watchers.get(socket) + cdef int events = 0 + if read: + events |= EV_READ + if write: + events |= EV_WRITE + if watcher is None: + if not events: + return + watcher = self.loop.io(socket, events) + self._watchers[socket] = watcher + elif events: + if watcher.events == events: + return + watcher.stop() + watcher.events = events + else: + watcher.stop() + self._watchers.pop(socket, None) + if not self._watchers: + self._timer.stop() + return + watcher.start(self._process_fd, watcher, pass_events=True) + self._timer.again(self._on_timer) + + def _on_timer(self): + cares.ares_process_fd(self.channel, cares.ARES_SOCKET_BAD, cares.ARES_SOCKET_BAD) + + def _process_fd(self, int events, object watcher): + if not self.channel: + return + cdef int read_fd = watcher.fd + cdef int write_fd = read_fd + if not (events & EV_READ): + read_fd = cares.ARES_SOCKET_BAD + if not (events & EV_WRITE): + write_fd = cares.ARES_SOCKET_BAD + cares.ares_process_fd(self.channel, read_fd, write_fd) + + def gethostbyname(self, object callback, char* name, int family=AF_INET): + if not self.channel: + raise gaierror(cares.ARES_EDESTRUCTION, 'this ares channel has been destroyed') + # note that for file lookups still AF_INET can be returned for AF_INET6 request + cdef object arg = (self, callback) + Py_INCREF(arg) + cares.ares_gethostbyname(self.channel, name, family, gevent_ares_host_callback, arg) + + def gethostbyaddr(self, object callback, char* addr): + if not self.channel: + raise gaierror(cares.ARES_EDESTRUCTION, 'this ares channel has been destroyed') + # will guess the family + cdef char addr_packed[16] + cdef int family + cdef int length + if cares.ares_inet_pton(AF_INET, addr, addr_packed) > 0: + family = AF_INET + length = 4 + elif cares.ares_inet_pton(AF_INET6, addr, addr_packed) > 0: + family = AF_INET6 + length = 16 + else: + raise InvalidIP(repr(addr)) + cdef object arg = (self, callback) + Py_INCREF(arg) + cares.ares_gethostbyaddr(self.channel, addr_packed, length, family, gevent_ares_host_callback, arg) + + cpdef _getnameinfo(self, object callback, tuple sockaddr, int flags): + if not self.channel: + raise gaierror(cares.ARES_EDESTRUCTION, 'this ares channel has been destroyed') + cdef char* hostp = NULL + cdef int port = 0 + cdef int flowinfo = 0 + cdef int scope_id = 0 + cdef sockaddr_in6 sa6 + if not PyTuple_Check(sockaddr): + raise TypeError('expected a tuple, got %r' % (sockaddr, )) + PyArg_ParseTuple(sockaddr, "si|ii", &hostp, &port, &flowinfo, &scope_id) + if port < 0 or port > 65535: + raise gaierror(-8, 'Invalid value for port: %r' % port) + cdef int length = gevent_make_sockaddr(hostp, port, flowinfo, scope_id, &sa6) + if length <= 0: + raise InvalidIP(repr(hostp)) + cdef object arg = (self, callback) + Py_INCREF(arg) + cdef sockaddr_t* x = &sa6 + cares.ares_getnameinfo(self.channel, x, length, flags, gevent_ares_nameinfo_callback, arg) + + def getnameinfo(self, object callback, tuple sockaddr, int flags): + try: + flags = _convert_cares_flags(flags) + except gaierror: + # The stdlib just ignores bad flags + flags = 0 + return self._getnameinfo(callback, sockaddr, flags) diff --git a/python/gevent/backdoor.py b/python/gevent/backdoor.py new file mode 100644 index 0000000..ff45166 --- /dev/null +++ b/python/gevent/backdoor.py @@ -0,0 +1,206 @@ +# Copyright (c) 2009-2014, gevent contributors +# Based on eventlet.backdoor Copyright (c) 2005-2006, Bob Ippolito +""" +Interactive greenlet-based network console that can be used in any process. + +The :class:`BackdoorServer` provides a REPL inside a running process. As +long as the process is monkey-patched, the ``BackdoorServer`` can coexist +with other elements of the process. + +.. seealso:: :class:`code.InteractiveConsole` +""" +from __future__ import print_function, absolute_import +import sys +from code import InteractiveConsole + +from gevent.greenlet import Greenlet +from gevent.hub import getcurrent +from gevent.server import StreamServer +from gevent.pool import Pool + +__all__ = ['BackdoorServer'] + +try: + sys.ps1 +except AttributeError: + sys.ps1 = '>>> ' +try: + sys.ps2 +except AttributeError: + sys.ps2 = '... ' + +class _Greenlet_stdreplace(Greenlet): + # A greenlet that replaces sys.std[in/out/err] while running. + _fileobj = None + saved = None + + def switch(self, *args, **kw): + if self._fileobj is not None: + self.switch_in() + Greenlet.switch(self, *args, **kw) + + def switch_in(self): + self.saved = sys.stdin, sys.stderr, sys.stdout + sys.stdin = sys.stdout = sys.stderr = self._fileobj + + def switch_out(self): + sys.stdin, sys.stderr, sys.stdout = self.saved + self.saved = None + + def throw(self, *args, **kwargs): + # pylint:disable=arguments-differ + if self.saved is None and self._fileobj is not None: + self.switch_in() + Greenlet.throw(self, *args, **kwargs) + + def run(self): + try: + return Greenlet.run(self) + finally: + # Make sure to restore the originals. + self.switch_out() + + +class BackdoorServer(StreamServer): + """ + Provide a backdoor to a program for debugging purposes. + + .. warning:: This backdoor provides no authentication and makes no + attempt to limit what remote users can do. Anyone that + can access the server can take any action that the running + python process can. Thus, while you may bind to any interface, for + security purposes it is recommended that you bind to one + only accessible to the local machine, e.g., + 127.0.0.1/localhost. + + Basic usage:: + + from gevent.backdoor import BackdoorServer + server = BackdoorServer(('127.0.0.1', 5001), + banner="Hello from gevent backdoor!", + locals={'foo': "From defined scope!"}) + server.serve_forever() + + In a another terminal, connect with...:: + + $ telnet 127.0.0.1 5001 + Trying 127.0.0.1... + Connected to 127.0.0.1. + Escape character is '^]'. + Hello from gevent backdoor! + >> print(foo) + From defined scope! + + .. versionchanged:: 1.2a1 + Spawned greenlets are now tracked in a pool and killed when the server + is stopped. + """ + + def __init__(self, listener, locals=None, banner=None, **server_args): + """ + :keyword locals: If given, a dictionary of "builtin" values that will be available + at the top-level. + :keyword banner: If geven, a string that will be printed to each connecting user. + """ + group = Pool(greenlet_class=_Greenlet_stdreplace) # no limit on number + StreamServer.__init__(self, listener, spawn=group, **server_args) + _locals = {'__doc__': None, '__name__': '__console__'} + if locals: + _locals.update(locals) + self.locals = _locals + + self.banner = banner + self.stderr = sys.stderr + + def _create_interactive_locals(self): + # Create and return a *new* locals dictionary based on self.locals, + # and set any new entries in it. (InteractiveConsole does not + # copy its locals value) + _locals = self.locals.copy() + # __builtins__ may either be the __builtin__ module or + # __builtin__.__dict__; in the latter case typing + # locals() at the backdoor prompt spews out lots of + # useless stuff + try: + import __builtin__ + _locals["__builtins__"] = __builtin__ + except ImportError: + import builtins # pylint:disable=import-error + _locals["builtins"] = builtins + _locals['__builtins__'] = builtins + return _locals + + def handle(self, conn, _address): # pylint: disable=method-hidden + """ + Interact with one remote user. + + .. versionchanged:: 1.1b2 Each connection gets its own + ``locals`` dictionary. Previously they were shared in a + potentially unsafe manner. + """ + fobj = conn.makefile(mode="rw") + fobj = _fileobject(conn, fobj, self.stderr) + getcurrent()._fileobj = fobj + + getcurrent().switch_in() + try: + console = InteractiveConsole(self._create_interactive_locals()) + if sys.version_info[:3] >= (3, 6, 0): + # Beginning in 3.6, the console likes to print "now exiting " + # but probably our socket is already closed, so this just causes problems. + console.interact(banner=self.banner, exitmsg='') # pylint:disable=unexpected-keyword-arg + else: + console.interact(banner=self.banner) + except SystemExit: # raised by quit() + if hasattr(sys, 'exc_clear'): # py2 + sys.exc_clear() + finally: + conn.close() + fobj.close() + + +class _fileobject(object): + """ + A file-like object that wraps the result of socket.makefile (composition + instead of inheritance lets us work identically under CPython and PyPy). + + We write directly to the socket, avoiding the buffering that the text-oriented + makefile would want to do (otherwise we'd be at the mercy of waiting on a + flush() to get called for the remote user to see data); this beats putting + the file in binary mode and translating everywhere with a non-default + encoding. + """ + def __init__(self, sock, fobj, stderr): + self._sock = sock + self._fobj = fobj + self.stderr = stderr + + def __getattr__(self, name): + return getattr(self._fobj, name) + + def write(self, data): + if not isinstance(data, bytes): + data = data.encode('utf-8') + self._sock.sendall(data) + + def isatty(self): + return True + + def flush(self): + pass + + def readline(self, *a): + try: + return self._fobj.readline(*a).replace("\r\n", "\n") + except UnicodeError: + # Typically, under python 3, a ^C on the other end + return '' + + +if __name__ == '__main__': + if not sys.argv[1:]: + print('USAGE: %s PORT [banner]' % sys.argv[0]) + else: + BackdoorServer(('127.0.0.1', int(sys.argv[1])), + banner=(sys.argv[2] if len(sys.argv) > 2 else None), + locals={'hello': 'world'}).serve_forever() diff --git a/python/gevent/baseserver.py b/python/gevent/baseserver.py new file mode 100644 index 0000000..5b8bce5 --- /dev/null +++ b/python/gevent/baseserver.py @@ -0,0 +1,402 @@ +"""Base class for implementing servers""" +# Copyright (c) 2009-2012 Denis Bilenko. See LICENSE for details. +import sys +import _socket +import errno +from gevent.greenlet import Greenlet +from gevent.event import Event +from gevent.hub import get_hub +from gevent._compat import string_types, integer_types, xrange + + +__all__ = ['BaseServer'] + + +# We define a helper function to handle closing the socket in +# do_handle; We'd like to bind it to a kwarg to avoid *any* lookups at +# all, but that's incompatible with the calling convention of +# do_handle. On CPython, this is ~20% faster than creating and calling +# a closure and ~10% faster than using a @staticmethod. (In theory, we +# could create a closure only once in set_handle, to wrap self._handle, +# but this is safer from a backwards compat standpoint.) +# we also avoid unpacking the *args tuple when calling/spawning this object +# for a tiny improvement (benchmark shows a wash) +def _handle_and_close_when_done(handle, close, args_tuple): + try: + return handle(*args_tuple) + finally: + close(*args_tuple) + + +class BaseServer(object): + """ + An abstract base class that implements some common functionality for the servers in gevent. + + :param listener: Either be an address that the server should bind + on or a :class:`gevent.socket.socket` instance that is already + bound (and put into listening mode in case of TCP socket). + + :keyword handle: If given, the request handler. The request + handler can be defined in a few ways. Most commonly, + subclasses will implement a ``handle`` method as an + instance method. Alternatively, a function can be passed + as the ``handle`` argument to the constructor. In either + case, the handler can later be changed by calling + :meth:`set_handle`. + + When the request handler returns, the socket used for the + request will be closed. Therefore, the handler must not return if + the socket is still in use (for example, by manually spawned greenlets). + + :keyword spawn: If provided, is called to create a new + greenlet to run the handler. By default, + :func:`gevent.spawn` is used (meaning there is no + artificial limit on the number of concurrent requests). Possible values for *spawn*: + + - a :class:`gevent.pool.Pool` instance -- ``handle`` will be executed + using :meth:`gevent.pool.Pool.spawn` only if the pool is not full. + While it is full, no new connections are accepted; + - :func:`gevent.spawn_raw` -- ``handle`` will be executed in a raw + greenlet which has a little less overhead then :class:`gevent.Greenlet` instances spawned by default; + - ``None`` -- ``handle`` will be executed right away, in the :class:`Hub` greenlet. + ``handle`` cannot use any blocking functions as it would mean switching to the :class:`Hub`. + - an integer -- a shortcut for ``gevent.pool.Pool(integer)`` + + .. versionchanged:: 1.1a1 + When the *handle* function returns from processing a connection, + the client socket will be closed. This resolves the non-deterministic + closing of the socket, fixing ResourceWarnings under Python 3 and PyPy. + + """ + # pylint: disable=too-many-instance-attributes,bare-except,broad-except + + #: the number of seconds to sleep in case there was an error in accept() call + #: for consecutive errors the delay will double until it reaches max_delay + #: when accept() finally succeeds the delay will be reset to min_delay again + min_delay = 0.01 + max_delay = 1 + + #: Sets the maximum number of consecutive accepts that a process may perform on + #: a single wake up. High values give higher priority to high connection rates, + #: while lower values give higher priority to already established connections. + #: Default is 100. Note, that in case of multiple working processes on the same + #: listening value, it should be set to a lower value. (pywsgi.WSGIServer sets it + #: to 1 when environ["wsgi.multiprocess"] is true) + max_accept = 100 + + _spawn = Greenlet.spawn + + #: the default timeout that we wait for the client connections to close in stop() + stop_timeout = 1 + + fatal_errors = (errno.EBADF, errno.EINVAL, errno.ENOTSOCK) + + def __init__(self, listener, handle=None, spawn='default'): + self._stop_event = Event() + self._stop_event.set() + self._watcher = None + self._timer = None + self._handle = None + # XXX: FIXME: Subclasses rely on the presence or absence of the + # `socket` attribute to determine whether we are open/should be opened. + # Instead, have it be None. + self.pool = None + try: + self.set_listener(listener) + self.set_spawn(spawn) + self.set_handle(handle) + self.delay = self.min_delay + self.loop = get_hub().loop + if self.max_accept < 1: + raise ValueError('max_accept must be positive int: %r' % (self.max_accept, )) + except: + self.close() + raise + + def set_listener(self, listener): + if hasattr(listener, 'accept'): + if hasattr(listener, 'do_handshake'): + raise TypeError('Expected a regular socket, not SSLSocket: %r' % (listener, )) + self.family = listener.family + self.address = listener.getsockname() + self.socket = listener + else: + self.family, self.address = parse_address(listener) + + def set_spawn(self, spawn): + if spawn == 'default': + self.pool = None + self._spawn = self._spawn + elif hasattr(spawn, 'spawn'): + self.pool = spawn + self._spawn = spawn.spawn + elif isinstance(spawn, integer_types): + from gevent.pool import Pool + self.pool = Pool(spawn) + self._spawn = self.pool.spawn + else: + self.pool = None + self._spawn = spawn + if hasattr(self.pool, 'full'): + self.full = self.pool.full + if self.pool is not None: + self.pool._semaphore.rawlink(self._start_accepting_if_started) + + def set_handle(self, handle): + if handle is not None: + self.handle = handle + if hasattr(self, 'handle'): + self._handle = self.handle + else: + raise TypeError("'handle' must be provided") + + def _start_accepting_if_started(self, _event=None): + if self.started: + self.start_accepting() + + def start_accepting(self): + if self._watcher is None: + # just stop watcher without creating a new one? + self._watcher = self.loop.io(self.socket.fileno(), 1) + self._watcher.start(self._do_read) + + def stop_accepting(self): + if self._watcher is not None: + self._watcher.stop() + self._watcher = None + if self._timer is not None: + self._timer.stop() + self._timer = None + + def do_handle(self, *args): + spawn = self._spawn + handle = self._handle + close = self.do_close + + try: + if spawn is None: + _handle_and_close_when_done(handle, close, args) + else: + spawn(_handle_and_close_when_done, handle, close, args) + except: + close(*args) + raise + + def do_close(self, *args): + pass + + def do_read(self): + raise NotImplementedError() + + def _do_read(self): + for _ in xrange(self.max_accept): + if self.full(): + self.stop_accepting() + return + try: + args = self.do_read() + self.delay = self.min_delay + if not args: + return + except: + self.loop.handle_error(self, *sys.exc_info()) + ex = sys.exc_info()[1] + if self.is_fatal_error(ex): + self.close() + sys.stderr.write('ERROR: %s failed with %s\n' % (self, str(ex) or repr(ex))) + return + if self.delay >= 0: + self.stop_accepting() + self._timer = self.loop.timer(self.delay) + self._timer.start(self._start_accepting_if_started) + self.delay = min(self.max_delay, self.delay * 2) + break + else: + try: + self.do_handle(*args) + except: + self.loop.handle_error((args[1:], self), *sys.exc_info()) + if self.delay >= 0: + self.stop_accepting() + self._timer = self.loop.timer(self.delay) + self._timer.start(self._start_accepting_if_started) + self.delay = min(self.max_delay, self.delay * 2) + break + + def full(self): + # copied from self.pool + # pylint: disable=method-hidden + return False + + def __repr__(self): + return '<%s at %s %s>' % (type(self).__name__, hex(id(self)), self._formatinfo()) + + def __str__(self): + return '<%s %s>' % (type(self).__name__, self._formatinfo()) + + def _formatinfo(self): + if hasattr(self, 'socket'): + try: + fileno = self.socket.fileno() + except Exception as ex: + fileno = str(ex) + result = 'fileno=%s ' % fileno + else: + result = '' + try: + if isinstance(self.address, tuple) and len(self.address) == 2: + result += 'address=%s:%s' % self.address + else: + result += 'address=%s' % (self.address, ) + except Exception as ex: + result += str(ex) or '' + + handle = self.__dict__.get('handle') + if handle is not None: + fself = getattr(handle, '__self__', None) + try: + if fself is self: + # Checks the __self__ of the handle in case it is a bound + # method of self to prevent recursivly defined reprs. + handle_repr = '' % ( + self.__class__.__name__, + handle.__name__, + ) + else: + handle_repr = repr(handle) + + result += ' handle=' + handle_repr + except Exception as ex: + result += str(ex) or '' + + return result + + @property + def server_host(self): + """IP address that the server is bound to (string).""" + if isinstance(self.address, tuple): + return self.address[0] + + @property + def server_port(self): + """Port that the server is bound to (an integer).""" + if isinstance(self.address, tuple): + return self.address[1] + + def init_socket(self): + """If the user initialized the server with an address rather than socket, + then this function will create a socket, bind it and put it into listening mode. + + It is not supposed to be called by the user, it is called by :meth:`start` before starting + the accept loop.""" + pass + + @property + def started(self): + return not self._stop_event.is_set() + + def start(self): + """Start accepting the connections. + + If an address was provided in the constructor, then also create a socket, + bind it and put it into the listening mode. + """ + self.init_socket() + self._stop_event.clear() + try: + self.start_accepting() + except: + self.close() + raise + + def close(self): + """Close the listener socket and stop accepting.""" + self._stop_event.set() + try: + self.stop_accepting() + finally: + try: + self.socket.close() + except Exception: + pass + finally: + self.__dict__.pop('socket', None) + self.__dict__.pop('handle', None) + self.__dict__.pop('_handle', None) + self.__dict__.pop('_spawn', None) + self.__dict__.pop('full', None) + if self.pool is not None: + self.pool._semaphore.unlink(self._start_accepting_if_started) + + @property + def closed(self): + return not hasattr(self, 'socket') + + def stop(self, timeout=None): + """ + Stop accepting the connections and close the listening socket. + + If the server uses a pool to spawn the requests, then + :meth:`stop` also waits for all the handlers to exit. If there + are still handlers executing after *timeout* has expired + (default 1 second, :attr:`stop_timeout`), then the currently + running handlers in the pool are killed. + + If the server does not use a pool, then this merely stops accepting connections; + any spawned greenlets that are handling requests continue running until + they naturally complete. + """ + self.close() + if timeout is None: + timeout = self.stop_timeout + if self.pool: + self.pool.join(timeout=timeout) + self.pool.kill(block=True, timeout=1) + + def serve_forever(self, stop_timeout=None): + """Start the server if it hasn't been already started and wait until it's stopped.""" + # add test that serve_forever exists on stop() + if not self.started: + self.start() + try: + self._stop_event.wait() + finally: + Greenlet.spawn(self.stop, timeout=stop_timeout).join() + + def is_fatal_error(self, ex): + return isinstance(ex, _socket.error) and ex.args[0] in self.fatal_errors + + +def _extract_family(host): + if host.startswith('[') and host.endswith(']'): + host = host[1:-1] + return _socket.AF_INET6, host + return _socket.AF_INET, host + + +def _parse_address(address): + if isinstance(address, tuple): + if not address[0] or ':' in address[0]: + return _socket.AF_INET6, address + return _socket.AF_INET, address + + if ((isinstance(address, string_types) and ':' not in address) + or isinstance(address, integer_types)): # noqa (pep8 E129) + # Just a port + return _socket.AF_INET6, ('', int(address)) + + if not isinstance(address, string_types): + raise TypeError('Expected tuple or string, got %s' % type(address)) + + host, port = address.rsplit(':', 1) + family, host = _extract_family(host) + if host == '*': + host = '' + return family, (host, int(port)) + + +def parse_address(address): + try: + return _parse_address(address) + except ValueError as ex: + raise ValueError('Failed to parse address %r: %s' % (address, ex)) diff --git a/python/gevent/builtins.py b/python/gevent/builtins.py new file mode 100644 index 0000000..eab2099 --- /dev/null +++ b/python/gevent/builtins.py @@ -0,0 +1,125 @@ +# Copyright (c) 2015 gevent contributors. See LICENSE for details. +"""gevent friendly implementations of builtin functions.""" +from __future__ import absolute_import + +import imp # deprecated since 3.4; issues PendingDeprecationWarning in 3.5 +import sys +import weakref +from gevent.lock import RLock + +# Normally we'd have the "expected" case inside the try +# (Python 3, because Python 3 is the way forward). But +# under Python 2, the popular `future` library *also* provides +# a `builtins` module---which lacks the __import__ attribute. +# So we test for the old, deprecated version first + +try: # Py2 + import __builtin__ as builtins + _allowed_module_name_types = (basestring,) # pylint:disable=undefined-variable + __target__ = '__builtin__' +except ImportError: + import builtins # pylint: disable=import-error + _allowed_module_name_types = (str,) + __target__ = 'builtins' + +_import = builtins.__import__ + +# We need to protect imports both across threads and across greenlets. +# And the order matters. Note that under 3.4, the global import lock +# and imp module are deprecated. It seems that in all Py3 versions, a +# module lock is used such that this fix is not necessary. + +# We emulate the per-module locking system under Python 2 in order to +# avoid issues acquiring locks in multiple-level-deep imports +# that attempt to use the gevent blocking API at runtime; using one lock +# could lead to a LoopExit error as a greenlet attempts to block on it while +# it's already held by the main greenlet (issue #798). + +# We base this approach on a simplification of what `importlib._bootstrap` +# does; notably, we don't check for deadlocks + +_g_import_locks = {} # name -> wref of RLock + +__lock_imports = True + + +def __module_lock(name): + # Return the lock for the given module, creating it if necessary. + # It will be removed when no longer needed. + # Nothing in this function yields, so we're multi-greenlet safe + # (But not multi-threading safe.) + # XXX: What about on PyPy, where the GC is asynchronous (not ref-counting)? + # (Does it stop-the-world first?) + lock = None + try: + lock = _g_import_locks[name]() + except KeyError: + pass + + if lock is None: + lock = RLock() + + def cb(_): + # We've seen a KeyError on PyPy on RPi2 + _g_import_locks.pop(name, None) + _g_import_locks[name] = weakref.ref(lock, cb) + return lock + + +def __import__(*args, **kwargs): + """ + __import__(name, globals=None, locals=None, fromlist=(), level=0) -> object + + Normally python protects imports against concurrency by doing some locking + at the C level (at least, it does that in CPython). This function just + wraps the normal __import__ functionality in a recursive lock, ensuring that + we're protected against greenlet import concurrency as well. + """ + if args and not issubclass(type(args[0]), _allowed_module_name_types): + # if a builtin has been acquired as a bound instance method, + # python knows not to pass 'self' when the method is called. + # No such protection exists for monkey-patched builtins, + # however, so this is necessary. + args = args[1:] + + if not __lock_imports: + return _import(*args, **kwargs) + + module_lock = __module_lock(args[0]) # Get a lock for the module name + imp.acquire_lock() + try: + module_lock.acquire() + try: + result = _import(*args, **kwargs) + finally: + module_lock.release() + finally: + imp.release_lock() + return result + + +def _unlock_imports(): + """ + Internal function, called when gevent needs to perform imports + lazily, but does not know the state of the system. It may be impossible + to take the import lock because there are no other running greenlets, for + example. This causes a monkey-patched __import__ to avoid taking any locks. + until the corresponding call to lock_imports. This should only be done for limited + amounts of time and when the set of imports is statically known to be "safe". + """ + global __lock_imports + # This could easily become a list that we push/pop from or an integer + # we increment if we need to do this recursively, but we shouldn't get + # that complex. + __lock_imports = False + + +def _lock_imports(): + global __lock_imports + __lock_imports = True + +if sys.version_info[:2] >= (3, 3): + __implements__ = [] +else: + __implements__ = ['__import__'] +__all__ = __implements__ diff --git a/python/gevent/cares.pxd b/python/gevent/cares.pxd new file mode 100644 index 0000000..7b551a7 --- /dev/null +++ b/python/gevent/cares.pxd @@ -0,0 +1,109 @@ +cdef extern from "ares.h": + struct ares_options: + int flags + void* sock_state_cb + void* sock_state_cb_data + int timeout + int tries + int ndots + unsigned short udp_port + unsigned short tcp_port + char **domains + int ndomains + char* lookups + + int ARES_OPT_FLAGS + int ARES_OPT_SOCK_STATE_CB + int ARES_OPT_TIMEOUTMS + int ARES_OPT_TRIES + int ARES_OPT_NDOTS + int ARES_OPT_TCP_PORT + int ARES_OPT_UDP_PORT + int ARES_OPT_SERVERS + int ARES_OPT_DOMAINS + int ARES_OPT_LOOKUPS + + int ARES_FLAG_USEVC + int ARES_FLAG_PRIMARY + int ARES_FLAG_IGNTC + int ARES_FLAG_NORECURSE + int ARES_FLAG_STAYOPEN + int ARES_FLAG_NOSEARCH + int ARES_FLAG_NOALIASES + int ARES_FLAG_NOCHECKRESP + + int ARES_LIB_INIT_ALL + int ARES_SOCKET_BAD + + int ARES_SUCCESS + int ARES_ENODATA + int ARES_EFORMERR + int ARES_ESERVFAIL + int ARES_ENOTFOUND + int ARES_ENOTIMP + int ARES_EREFUSED + int ARES_EBADQUERY + int ARES_EBADNAME + int ARES_EBADFAMILY + int ARES_EBADRESP + int ARES_ECONNREFUSED + int ARES_ETIMEOUT + int ARES_EOF + int ARES_EFILE + int ARES_ENOMEM + int ARES_EDESTRUCTION + int ARES_EBADSTR + int ARES_EBADFLAGS + int ARES_ENONAME + int ARES_EBADHINTS + int ARES_ENOTINITIALIZED + int ARES_ELOADIPHLPAPI + int ARES_EADDRGETNETWORKPARAMS + int ARES_ECANCELLED + + int ARES_NI_NOFQDN + int ARES_NI_NUMERICHOST + int ARES_NI_NAMEREQD + int ARES_NI_NUMERICSERV + int ARES_NI_DGRAM + int ARES_NI_TCP + int ARES_NI_UDP + int ARES_NI_SCTP + int ARES_NI_DCCP + int ARES_NI_NUMERICSCOPE + int ARES_NI_LOOKUPHOST + int ARES_NI_LOOKUPSERVICE + + + int ares_library_init(int flags) + void ares_library_cleanup() + int ares_init_options(void *channelptr, ares_options *options, int) + int ares_init(void *channelptr) + void ares_destroy(void *channelptr) + void ares_gethostbyname(void* channel, char *name, int family, void* callback, void *arg) + void ares_gethostbyaddr(void* channel, void *addr, int addrlen, int family, void* callback, void *arg) + void ares_process_fd(void* channel, int read_fd, int write_fd) + char* ares_strerror(int code) + void ares_cancel(void* channel) + void ares_getnameinfo(void* channel, void* sa, int salen, int flags, void* callback, void *arg) + + struct in_addr: + pass + + struct ares_in6_addr: + pass + + struct addr_union: + in_addr addr4 + ares_in6_addr addr6 + + struct ares_addr_node: + ares_addr_node *next + int family + addr_union addr + + int ares_set_servers(void* channel, ares_addr_node *servers) + + +cdef extern from "cares_pton.h": + int ares_inet_pton(int af, char *src, void *dst) diff --git a/python/gevent/cares_ntop.h b/python/gevent/cares_ntop.h new file mode 100644 index 0000000..9ffc9dd --- /dev/null +++ b/python/gevent/cares_ntop.h @@ -0,0 +1,7 @@ +#ifdef CARES_EMBED +#include "ares_setup.h" +#include "ares.h" +#else +#include +#define ares_inet_ntop(w,x,y,z) inet_ntop(w,x,y,z) +#endif diff --git a/python/gevent/cares_pton.h b/python/gevent/cares_pton.h new file mode 100644 index 0000000..85af403 --- /dev/null +++ b/python/gevent/cares_pton.h @@ -0,0 +1,8 @@ +#ifdef CARES_EMBED +#include "ares_setup.h" +#include "ares_inet_net_pton.h" +#else +#include +#define ares_inet_pton(x,y,z) inet_pton(x,y,z) +#define ares_inet_net_pton(w,x,y,z) inet_net_pton(w,x,y,z) +#endif diff --git a/python/gevent/core.py b/python/gevent/core.py new file mode 100644 index 0000000..8944f12 --- /dev/null +++ b/python/gevent/core.py @@ -0,0 +1,22 @@ +# Copyright (c) 2009-2015 Denis Bilenko and gevent contributors. See LICENSE for details. +from __future__ import absolute_import + +import os + +from gevent._util import copy_globals + +try: + if os.environ.get('GEVENT_CORE_CFFI_ONLY'): + raise ImportError("Not attempting corecext") + + from gevent.libev import corecext as _core +except ImportError: + if os.environ.get('GEVENT_CORE_CEXT_ONLY'): + raise + + # CFFI/PyPy + from gevent.libev import corecffi as _core + +copy_globals(_core, globals()) + +__all__ = _core.__all__ # pylint:disable=no-member diff --git a/python/gevent/dnshelper.c b/python/gevent/dnshelper.c new file mode 100644 index 0000000..3befb69 --- /dev/null +++ b/python/gevent/dnshelper.c @@ -0,0 +1,159 @@ +/* Copyright (c) 2011 Denis Bilenko. See LICENSE for details. */ +#include "Python.h" +#ifdef CARES_EMBED +#include "ares_setup.h" +#endif + +#ifdef HAVE_NETDB_H +#include +#endif + +#include "ares.h" + +#include "cares_ntop.h" +#include "cares_pton.h" + +#if PY_VERSION_HEX < 0x02060000 + #define PyUnicode_FromString PyString_FromString +#elif PY_MAJOR_VERSION < 3 + #define PyUnicode_FromString PyBytes_FromString +#endif + + +static PyObject* _socket_error = 0; + +static PyObject* +get_socket_object(PyObject** pobject, const char* name) +{ + if (!*pobject) { + PyObject* _socket; + _socket = PyImport_ImportModule("_socket"); + if (_socket) { + *pobject = PyObject_GetAttrString(_socket, name); + if (!*pobject) { + PyErr_WriteUnraisable(Py_None); + } + Py_DECREF(_socket); + } + else { + PyErr_WriteUnraisable(Py_None); + } + if (!*pobject) { + *pobject = PyExc_IOError; + } + } + return *pobject; +} + + +static int +gevent_append_addr(PyObject* list, int family, void* src, char* tmpbuf, size_t tmpsize) { + int status = -1; + PyObject* tmp; + if (ares_inet_ntop(family, src, tmpbuf, tmpsize)) { + tmp = PyUnicode_FromString(tmpbuf); + if (tmp) { + status = PyList_Append(list, tmp); + Py_DECREF(tmp); + } + } + return status; +} + + +static PyObject* +parse_h_name(struct hostent *h) +{ + return PyUnicode_FromString(h->h_name); +} + + +static PyObject* +parse_h_aliases(struct hostent *h) +{ + char **pch; + PyObject *result = NULL; + PyObject *tmp; + + result = PyList_New(0); + + if (result && h->h_aliases) { + for (pch = h->h_aliases; *pch != NULL; pch++) { + if (*pch != h->h_name && strcmp(*pch, h->h_name)) { + int status; + tmp = PyUnicode_FromString(*pch); + if (tmp == NULL) { + break; + } + + status = PyList_Append(result, tmp); + Py_DECREF(tmp); + + if (status) { + break; + } + } + } + } + + return result; +} + + +static PyObject * +parse_h_addr_list(struct hostent *h) +{ + char **pch; + PyObject *result = NULL; + + result = PyList_New(0); + + if (result) { + switch (h->h_addrtype) { + case AF_INET: + { + char tmpbuf[sizeof "255.255.255.255"]; + for (pch = h->h_addr_list; *pch != NULL; pch++) { + if (gevent_append_addr(result, AF_INET, *pch, tmpbuf, sizeof(tmpbuf))) { + break; + } + } + break; + } + case AF_INET6: + { + char tmpbuf[sizeof("ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255")]; + for (pch = h->h_addr_list; *pch != NULL; pch++) { + if (gevent_append_addr(result, AF_INET6, *pch, tmpbuf, sizeof(tmpbuf))) { + break; + } + } + break; + } + default: + PyErr_SetString(get_socket_object(&_socket_error, "error"), "unsupported address family"); + Py_DECREF(result); + result = NULL; + } + } + + return result; +} + + +static int +gevent_make_sockaddr(char* hostp, int port, int flowinfo, int scope_id, struct sockaddr_in6* sa6) { + if ( ares_inet_pton(AF_INET, hostp, &((struct sockaddr_in*)sa6)->sin_addr.s_addr) > 0 ) { + ((struct sockaddr_in*)sa6)->sin_family = AF_INET; + ((struct sockaddr_in*)sa6)->sin_port = htons(port); + return sizeof(struct sockaddr_in); + } + else if ( ares_inet_pton(AF_INET6, hostp, &sa6->sin6_addr.s6_addr) > 0 ) { + sa6->sin6_family = AF_INET6; + sa6->sin6_port = htons(port); + sa6->sin6_flowinfo = flowinfo; + sa6->sin6_scope_id = scope_id; + return sizeof(struct sockaddr_in6); + } + return -1; +} diff --git a/python/gevent/event.py b/python/gevent/event.py new file mode 100644 index 0000000..f888b6e --- /dev/null +++ b/python/gevent/event.py @@ -0,0 +1,448 @@ +# Copyright (c) 2009-2016 Denis Bilenko, gevent contributors. See LICENSE for details. +"""Basic synchronization primitives: Event and AsyncResult""" +from __future__ import print_function +import sys +from gevent.hub import get_hub, getcurrent, _NONE +from gevent._compat import reraise +from gevent.hub import InvalidSwitchError +from gevent.timeout import Timeout +from gevent._tblib import dump_traceback, load_traceback + +__all__ = ['Event', 'AsyncResult'] + + +class _AbstractLinkable(object): + # Encapsulates the standard parts of the linking and notifying protocol + # common to both repeatable events and one-time events (AsyncResult). + + _notifier = None + + def __init__(self): + # Also previously, AsyncResult maintained the order of notifications, but Event + # did not; this implementation does not. (Event also only call callbacks one + # time (set), but AsyncResult permitted duplicates.) + + # HOWEVER, gevent.queue.Queue does guarantee the order of getters relative + # to putters. Some existing documentation out on the net likes to refer to + # gevent as "deterministic", such that running the same program twice will + # produce results in the same order (so long as I/O isn't involved). This could + # be an argument to maintain order. (One easy way to do that while guaranteeing + # uniqueness would be with a 2.7+ OrderedDict.) + self._links = set() + self.hub = get_hub() + + def ready(self): + # Instances must define this + raise NotImplementedError() + + def _check_and_notify(self): + # If this object is ready to be notified, begin the process. + if self.ready(): + if self._links and not self._notifier: + self._notifier = self.hub.loop.run_callback(self._notify_links) + + def rawlink(self, callback): + """ + Register a callback to call when this object is ready. + + *callback* will be called in the :class:`Hub `, so it must not use blocking gevent API. + *callback* will be passed one argument: this instance. + """ + if not callable(callback): + raise TypeError('Expected callable: %r' % (callback, )) + self._links.add(callback) + self._check_and_notify() + + def unlink(self, callback): + """Remove the callback set by :meth:`rawlink`""" + try: + self._links.remove(callback) + except KeyError: + pass + + def _notify_links(self): + # Actually call the notification callbacks. Those callbacks in todo that are + # still in _links are called. This method is careful to avoid iterating + # over self._links, because links could be added or removed while this + # method runs. Only links present when this method begins running + # will be called; if a callback adds a new link, it will not run + # until the next time notify_links is activated + + # We don't need to capture self._links as todo when establishing + # this callback; any links removed between now and then are handled + # by the `if` below; any links added are also grabbed + todo = set(self._links) + for link in todo: + # check that link was not notified yet and was not removed by the client + # We have to do this here, and not as part of the 'for' statement because + # a previous link(self) call might have altered self._links + if link in self._links: + try: + link(self) + except: # pylint:disable=bare-except + self.hub.handle_error((link, self), *sys.exc_info()) + if getattr(link, 'auto_unlink', None): + # This attribute can avoid having to keep a reference to the function + # *in* the function, which is a cycle + self.unlink(link) + + # save a tiny bit of memory by letting _notifier be collected + # bool(self._notifier) would turn to False as soon as we exit this + # method anyway. + del todo + del self._notifier + + def _wait_core(self, timeout, catch=Timeout): + # The core of the wait implementation, handling + # switching and linking. If *catch* is set to (), + # a timeout that elapses will be allowed to be raised. + # Returns a true value if the wait succeeded without timing out. + switch = getcurrent().switch + self.rawlink(switch) + try: + timer = Timeout._start_new_or_dummy(timeout) + try: + try: + result = self.hub.switch() + if result is not self: # pragma: no cover + raise InvalidSwitchError('Invalid switch into Event.wait(): %r' % (result, )) + return True + except catch as ex: + if ex is not timer: + raise + # test_set_and_clear and test_timeout in test_threading + # rely on the exact return values, not just truthish-ness + return False + finally: + timer.cancel() + finally: + self.unlink(switch) + + def _wait_return_value(self, waited, wait_success): + # pylint:disable=unused-argument + return None + + def _wait(self, timeout=None): + if self.ready(): + return self._wait_return_value(False, False) + + gotit = self._wait_core(timeout) + return self._wait_return_value(True, gotit) + + +class Event(_AbstractLinkable): + """A synchronization primitive that allows one greenlet to wake up one or more others. + It has the same interface as :class:`threading.Event` but works across greenlets. + + An event object manages an internal flag that can be set to true with the + :meth:`set` method and reset to false with the :meth:`clear` method. The :meth:`wait` method + blocks until the flag is true. + + .. note:: + The order and timing in which waiting greenlets are awakened is not determined. + As an implementation note, in gevent 1.1 and 1.0, waiting greenlets are awakened in a + undetermined order sometime *after* the current greenlet yields to the event loop. Other greenlets + (those not waiting to be awakened) may run between the current greenlet yielding and + the waiting greenlets being awakened. These details may change in the future. + """ + + _flag = False + + def __str__(self): + return '<%s %s _links[%s]>' % (self.__class__.__name__, (self._flag and 'set') or 'clear', len(self._links)) + + def is_set(self): + """Return true if and only if the internal flag is true.""" + return self._flag + + isSet = is_set # makes it a better drop-in replacement for threading.Event + ready = is_set # makes it compatible with AsyncResult and Greenlet (for example in wait()) + + def set(self): + """ + Set the internal flag to true. + + All greenlets waiting for it to become true are awakened in + some order at some time in the future. Greenlets that call + :meth:`wait` once the flag is true will not block at all + (until :meth:`clear` is called). + """ + self._flag = True + self._check_and_notify() + + def clear(self): + """ + Reset the internal flag to false. + + Subsequently, threads calling :meth:`wait` will block until + :meth:`set` is called to set the internal flag to true again. + """ + self._flag = False + + def _wait_return_value(self, waited, wait_success): + # To avoid the race condition outlined in http://bugs.python.org/issue13502, + # if we had to wait, then we need to return whether or not + # the condition got changed. Otherwise we simply echo + # the current state of the flag (which should be true) + if not waited: + flag = self._flag + assert flag, "if we didn't wait we should already be set" + return flag + + return wait_success + + def wait(self, timeout=None): + """ + Block until the internal flag is true. + + If the internal flag is true on entry, return immediately. Otherwise, + block until another thread (greenlet) calls :meth:`set` to set the flag to true, + or until the optional timeout occurs. + + When the *timeout* argument is present and not ``None``, it should be a + floating point number specifying a timeout for the operation in seconds + (or fractions thereof). + + :return: This method returns true if and only if the internal flag has been set to + true, either before the wait call or after the wait starts, so it will + always return ``True`` except if a timeout is given and the operation + times out. + + .. versionchanged:: 1.1 + The return value represents the flag during the elapsed wait, not + just after it elapses. This solves a race condition if one greenlet + sets and then clears the flag without switching, while other greenlets + are waiting. When the waiters wake up, this will return True; previously, + they would still wake up, but the return value would be False. This is most + noticeable when the *timeout* is present. + """ + return self._wait(timeout) + + def _reset_internal_locks(self): # pragma: no cover + # for compatibility with threading.Event (only in case of patch_all(Event=True), by default Event is not patched) + # Exception AttributeError: AttributeError("'Event' object has no attribute '_reset_internal_locks'",) + # in ignored + pass + + +class AsyncResult(_AbstractLinkable): + """A one-time event that stores a value or an exception. + + Like :class:`Event` it wakes up all the waiters when :meth:`set` or :meth:`set_exception` + is called. Waiters may receive the passed value or exception by calling :meth:`get` + instead of :meth:`wait`. An :class:`AsyncResult` instance cannot be reset. + + To pass a value call :meth:`set`. Calls to :meth:`get` (those that are currently blocking as well as + those made in the future) will return the value: + + >>> result = AsyncResult() + >>> result.set(100) + >>> result.get() + 100 + + To pass an exception call :meth:`set_exception`. This will cause :meth:`get` to raise that exception: + + >>> result = AsyncResult() + >>> result.set_exception(RuntimeError('failure')) + >>> result.get() + Traceback (most recent call last): + ... + RuntimeError: failure + + :class:`AsyncResult` implements :meth:`__call__` and thus can be used as :meth:`link` target: + + >>> import gevent + >>> result = AsyncResult() + >>> gevent.spawn(lambda : 1/0).link(result) + >>> try: + ... result.get() + ... except ZeroDivisionError: + ... print('ZeroDivisionError') + ZeroDivisionError + + .. note:: + The order and timing in which waiting greenlets are awakened is not determined. + As an implementation note, in gevent 1.1 and 1.0, waiting greenlets are awakened in a + undetermined order sometime *after* the current greenlet yields to the event loop. Other greenlets + (those not waiting to be awakened) may run between the current greenlet yielding and + the waiting greenlets being awakened. These details may change in the future. + + .. versionchanged:: 1.1 + The exact order in which waiting greenlets are awakened is not the same + as in 1.0. + .. versionchanged:: 1.1 + Callbacks :meth:`linked ` to this object are required to be hashable, and duplicates are + merged. + """ + + _value = _NONE + _exc_info = () + _notifier = None + + @property + def _exception(self): + return self._exc_info[1] if self._exc_info else _NONE + + @property + def value(self): + """ + Holds the value passed to :meth:`set` if :meth:`set` was called. Otherwise, + ``None`` + """ + return self._value if self._value is not _NONE else None + + @property + def exc_info(self): + """ + The three-tuple of exception information if :meth:`set_exception` was called. + """ + if self._exc_info: + return (self._exc_info[0], self._exc_info[1], load_traceback(self._exc_info[2])) + return () + + def __str__(self): + result = '<%s ' % (self.__class__.__name__, ) + if self.value is not None or self._exception is not _NONE: + result += 'value=%r ' % self.value + if self._exception is not None and self._exception is not _NONE: + result += 'exception=%r ' % self._exception + if self._exception is _NONE: + result += 'unset ' + return result + ' _links[%s]>' % len(self._links) + + def ready(self): + """Return true if and only if it holds a value or an exception""" + return self._exc_info or self._value is not _NONE + + def successful(self): + """Return true if and only if it is ready and holds a value""" + return self._value is not _NONE + + @property + def exception(self): + """Holds the exception instance passed to :meth:`set_exception` if :meth:`set_exception` was called. + Otherwise ``None``.""" + if self._exc_info: + return self._exc_info[1] + + def set(self, value=None): + """Store the value and wake up any waiters. + + All greenlets blocking on :meth:`get` or :meth:`wait` are awakened. + Subsequent calls to :meth:`wait` and :meth:`get` will not block at all. + """ + self._value = value + self._check_and_notify() + + def set_exception(self, exception, exc_info=None): + """Store the exception and wake up any waiters. + + All greenlets blocking on :meth:`get` or :meth:`wait` are awakened. + Subsequent calls to :meth:`wait` and :meth:`get` will not block at all. + + :keyword tuple exc_info: If given, a standard three-tuple of type, value, :class:`traceback` + as returned by :func:`sys.exc_info`. This will be used when the exception + is re-raised to propagate the correct traceback. + """ + if exc_info: + self._exc_info = (exc_info[0], exc_info[1], dump_traceback(exc_info[2])) + else: + self._exc_info = (type(exception), exception, dump_traceback(None)) + + self._check_and_notify() + + def _raise_exception(self): + reraise(*self.exc_info) + + def get(self, block=True, timeout=None): + """Return the stored value or raise the exception. + + If this instance already holds a value or an exception, return or raise it immediatelly. + Otherwise, block until another greenlet calls :meth:`set` or :meth:`set_exception` or + until the optional timeout occurs. + + When the *timeout* argument is present and not ``None``, it should be a + floating point number specifying a timeout for the operation in seconds + (or fractions thereof). If the *timeout* elapses, the *Timeout* exception will + be raised. + + :keyword bool block: If set to ``False`` and this instance is not ready, + immediately raise a :class:`Timeout` exception. + """ + if self._value is not _NONE: + return self._value + if self._exc_info: + return self._raise_exception() + + if not block: + # Not ready and not blocking, so immediately timeout + raise Timeout() + + # Wait, raising a timeout that elapses + self._wait_core(timeout, ()) + + # by definition we are now ready + return self.get(block=False) + + def get_nowait(self): + """ + Return the value or raise the exception without blocking. + + If this object is not yet :meth:`ready `, raise + :class:`gevent.Timeout` immediately. + """ + return self.get(block=False) + + def _wait_return_value(self, waited, wait_success): + # pylint:disable=unused-argument + # Always return the value. Since this is a one-shot event, + # no race condition should reset it. + return self.value + + def wait(self, timeout=None): + """Block until the instance is ready. + + If this instance already holds a value, it is returned immediately. If this + instance already holds an exception, ``None`` is returned immediately. + + Otherwise, block until another greenlet calls :meth:`set` or :meth:`set_exception` + (at which point either the value or ``None`` will be returned, respectively), + or until the optional timeout expires (at which point ``None`` will also be + returned). + + When the *timeout* argument is present and not ``None``, it should be a + floating point number specifying a timeout for the operation in seconds + (or fractions thereof). + + .. note:: If a timeout is given and expires, ``None`` will be returned + (no timeout exception will be raised). + + """ + return self._wait(timeout) + + # link protocol + def __call__(self, source): + if source.successful(): + self.set(source.value) + else: + self.set_exception(source.exception, getattr(source, 'exc_info', None)) + + # Methods to make us more like concurrent.futures.Future + + def result(self, timeout=None): + return self.get(timeout=timeout) + + set_result = set + + def done(self): + return self.ready() + + # we don't support cancelling + + def cancel(self): + return False + + def cancelled(self): + return False + + # exception is a method, we use it as a property diff --git a/python/gevent/fileobject.py b/python/gevent/fileobject.py new file mode 100644 index 0000000..6ed31f0 --- /dev/null +++ b/python/gevent/fileobject.py @@ -0,0 +1,219 @@ +""" +Wrappers to make file-like objects cooperative. + +.. class:: FileObject + + The main entry point to the file-like gevent-compatible behaviour. It will be defined + to be the best available implementation. + +There are two main implementations of ``FileObject``. On all systems, +there is :class:`FileObjectThread` which uses the built-in native +threadpool to avoid blocking the entire interpreter. On UNIX systems +(those that support the :mod:`fcntl` module), there is also +:class:`FileObjectPosix` which uses native non-blocking semantics. + +A third class, :class:`FileObjectBlock`, is simply a wrapper that executes everything +synchronously (and so is not gevent-compatible). It is provided for testing and debugging +purposes. + +Configuration +============= + +You may change the default value for ``FileObject`` using the +``GEVENT_FILE`` environment variable. Set it to ``posix``, ``thread``, +or ``block`` to choose from :class:`FileObjectPosix`, +:class:`FileObjectThread` and :class:`FileObjectBlock`, respectively. +You may also set it to the fully qualified class name of another +object that implements the file interface to use one of your own +objects. + +.. note:: The environment variable must be set at the time this module + is first imported. + +Classes +======= +""" +from __future__ import absolute_import + +import functools +import sys +import os + +from gevent._fileobjectcommon import FileObjectClosed +from gevent._fileobjectcommon import FileObjectBase +from gevent.hub import get_hub +from gevent._compat import integer_types +from gevent._compat import reraise +from gevent.lock import Semaphore, DummySemaphore + + +PYPY = hasattr(sys, 'pypy_version_info') + +if hasattr(sys, 'exc_clear'): + def _exc_clear(): + sys.exc_clear() +else: + def _exc_clear(): + return + + +__all__ = [ + 'FileObjectPosix', + 'FileObjectThread', + 'FileObject', +] + +try: + from fcntl import fcntl +except ImportError: + __all__.remove("FileObjectPosix") +else: + del fcntl + from gevent._fileobjectposix import FileObjectPosix + + +class FileObjectThread(FileObjectBase): + """ + A file-like object wrapping another file-like object, performing all blocking + operations on that object in a background thread. + + .. caution:: + Attempting to change the threadpool or lock of an existing FileObjectThread + has undefined consequences. + + .. versionchanged:: 1.1b1 + The file object is closed using the threadpool. Note that whether or + not this action is synchronous or asynchronous is not documented. + + """ + + def __init__(self, fobj, mode=None, bufsize=-1, close=True, threadpool=None, lock=True): + """ + :param fobj: The underlying file-like object to wrap, or an integer fileno + that will be pass to :func:`os.fdopen` along with *mode* and *bufsize*. + :keyword bool lock: If True (the default) then all operations will + be performed one-by-one. Note that this does not guarantee that, if using + this file object from multiple threads/greenlets, operations will be performed + in any particular order, only that no two operations will be attempted at the + same time. You can also pass your own :class:`gevent.lock.Semaphore` to synchronize + file operations with an external resource. + :keyword bool close: If True (the default) then when this object is closed, + the underlying object is closed as well. + """ + closefd = close + self.threadpool = threadpool or get_hub().threadpool + self.lock = lock + if self.lock is True: + self.lock = Semaphore() + elif not self.lock: + self.lock = DummySemaphore() + if not hasattr(self.lock, '__enter__'): + raise TypeError('Expected a Semaphore or boolean, got %r' % type(self.lock)) + if isinstance(fobj, integer_types): + if not closefd: + # we cannot do this, since fdopen object will close the descriptor + raise TypeError('FileObjectThread does not support close=False on an fd.') + if mode is None: + assert bufsize == -1, "If you use the default mode, you can't choose a bufsize" + fobj = os.fdopen(fobj) + else: + fobj = os.fdopen(fobj, mode, bufsize) + + self.__io_holder = [fobj] # signal for _wrap_method + super(FileObjectThread, self).__init__(fobj, closefd) + + def _do_close(self, fobj, closefd): + self.__io_holder[0] = None # for _wrap_method + try: + with self.lock: + self.threadpool.apply(fobj.flush) + finally: + if closefd: + # Note that we're not taking the lock; older code + # did fobj.close() without going through the threadpool at all, + # so acquiring the lock could potentially introduce deadlocks + # that weren't present before. Avoiding the lock doesn't make + # the existing race condition any worse. + # We wrap the close in an exception handler and re-raise directly + # to avoid the (common, expected) IOError from being logged by the pool + def close(): + try: + fobj.close() + except: # pylint:disable=bare-except + return sys.exc_info() + exc_info = self.threadpool.apply(close) + if exc_info: + reraise(*exc_info) + + def _do_delegate_methods(self): + super(FileObjectThread, self)._do_delegate_methods() + if not hasattr(self, 'read1') and 'r' in getattr(self._io, 'mode', ''): + self.read1 = self.read + self.__io_holder[0] = self._io + + def _extra_repr(self): + return ' threadpool=%r' % (self.threadpool,) + + def __iter__(self): + return self + + def next(self): + line = self.readline() + if line: + return line + raise StopIteration + __next__ = next + + def _wrap_method(self, method): + # NOTE: We are careful to avoid introducing a refcycle + # within self. Our wrapper cannot refer to self. + io_holder = self.__io_holder + lock = self.lock + threadpool = self.threadpool + + @functools.wraps(method) + def thread_method(*args, **kwargs): + if io_holder[0] is None: + # This is different than FileObjectPosix, etc, + # because we want to save the expensive trip through + # the threadpool. + raise FileObjectClosed() + with lock: + return threadpool.apply(method, args, kwargs) + + return thread_method + + +try: + FileObject = FileObjectPosix +except NameError: + FileObject = FileObjectThread + + +class FileObjectBlock(FileObjectBase): + + def __init__(self, fobj, *args, **kwargs): + closefd = kwargs.pop('close', True) + if kwargs: + raise TypeError('Unexpected arguments: %r' % kwargs.keys()) + if isinstance(fobj, integer_types): + if not closefd: + # we cannot do this, since fdopen object will close the descriptor + raise TypeError('FileObjectBlock does not support close=False on an fd.') + fobj = os.fdopen(fobj, *args) + super(FileObjectBlock, self).__init__(fobj, closefd) + + def _do_close(self, fobj, closefd): + fobj.close() + +config = os.environ.get('GEVENT_FILE') +if config: + klass = {'thread': 'gevent.fileobject.FileObjectThread', + 'posix': 'gevent.fileobject.FileObjectPosix', + 'block': 'gevent.fileobject.FileObjectBlock'}.get(config, config) + if klass.startswith('gevent.fileobject.'): + FileObject = globals()[klass.split('.', 2)[-1]] + else: + from gevent.hub import _import + FileObject = _import(klass) + del klass diff --git a/python/gevent/gevent._semaphore.c b/python/gevent/gevent._semaphore.c new file mode 100644 index 0000000..200c80d --- /dev/null +++ b/python/gevent/gevent._semaphore.c @@ -0,0 +1,8807 @@ +/* Generated by Cython 0.25.2 */ + +#define PY_SSIZE_T_CLEAN +#include "Python.h" +#ifndef Py_PYTHON_H + #error Python headers needed to compile C extensions, please install development version of Python. +#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03020000) + #error Cython requires Python 2.6+ or Python 3.2+. +#else +#define CYTHON_ABI "0_25_2" +#include +#ifndef offsetof + #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) +#endif +#if !defined(WIN32) && !defined(MS_WINDOWS) + #ifndef __stdcall + #define __stdcall + #endif + #ifndef __cdecl + #define __cdecl + #endif + #ifndef __fastcall + #define __fastcall + #endif +#endif +#ifndef DL_IMPORT + #define DL_IMPORT(t) t +#endif +#ifndef DL_EXPORT + #define DL_EXPORT(t) t +#endif +#ifndef HAVE_LONG_LONG + #if PY_VERSION_HEX >= 0x03030000 || (PY_MAJOR_VERSION == 2 && PY_VERSION_HEX >= 0x02070000) + #define HAVE_LONG_LONG + #endif +#endif +#ifndef PY_LONG_LONG + #define PY_LONG_LONG LONG_LONG +#endif +#ifndef Py_HUGE_VAL + #define Py_HUGE_VAL HUGE_VAL +#endif +#ifdef PYPY_VERSION + #define CYTHON_COMPILING_IN_PYPY 1 + #define CYTHON_COMPILING_IN_PYSTON 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #undef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 1 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 +#elif defined(PYSTON_VERSION) + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_PYSTON 1 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 +#else + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_PYSTON 0 + #define CYTHON_COMPILING_IN_CPYTHON 1 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #if PY_MAJOR_VERSION < 3 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #elif !defined(CYTHON_USE_ASYNC_SLOTS) + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #if PY_VERSION_HEX < 0x02070000 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #elif !defined(CYTHON_USE_PYLONG_INTERNALS) + #define CYTHON_USE_PYLONG_INTERNALS 1 + #endif + #ifndef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 1 + #endif + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #if PY_VERSION_HEX < 0x030300F0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #elif !defined(CYTHON_USE_UNICODE_WRITER) + #define CYTHON_USE_UNICODE_WRITER 1 + #endif + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #ifndef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 1 + #endif + #ifndef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 1 + #endif +#endif +#if !defined(CYTHON_FAST_PYCCALL) +#define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) +#endif +#if CYTHON_USE_PYLONG_INTERNALS + #include "longintrepr.h" + #undef SHIFT + #undef BASE + #undef MASK +#endif +#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) + #define Py_OptimizeFlag 0 +#endif +#define __PYX_BUILD_PY_SSIZE_T "n" +#define CYTHON_FORMAT_SSIZE_T "z" +#if PY_MAJOR_VERSION < 3 + #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) + #define __Pyx_DefaultClassType PyClass_Type +#else + #define __Pyx_BUILTIN_MODULE_NAME "builtins" + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) + #define __Pyx_DefaultClassType PyType_Type +#endif +#ifndef Py_TPFLAGS_CHECKTYPES + #define Py_TPFLAGS_CHECKTYPES 0 +#endif +#ifndef Py_TPFLAGS_HAVE_INDEX + #define Py_TPFLAGS_HAVE_INDEX 0 +#endif +#ifndef Py_TPFLAGS_HAVE_NEWBUFFER + #define Py_TPFLAGS_HAVE_NEWBUFFER 0 +#endif +#ifndef Py_TPFLAGS_HAVE_FINALIZE + #define Py_TPFLAGS_HAVE_FINALIZE 0 +#endif +#ifndef METH_FASTCALL + #define METH_FASTCALL 0x80 + typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject **args, + Py_ssize_t nargs, PyObject *kwnames); +#else + #define __Pyx_PyCFunctionFast _PyCFunctionFast +#endif +#if CYTHON_FAST_PYCCALL +#define __Pyx_PyFastCFunction_Check(func)\ + ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST))))) +#else +#define __Pyx_PyFastCFunction_Check(func) 0 +#endif +#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) + #define CYTHON_PEP393_ENABLED 1 + #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ + 0 : _PyUnicode_Ready((PyObject *)(op))) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) + #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) + #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) + #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) +#else + #define CYTHON_PEP393_ENABLED 0 + #define PyUnicode_1BYTE_KIND 1 + #define PyUnicode_2BYTE_KIND 2 + #define PyUnicode_4BYTE_KIND 4 + #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111) + #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) + #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) + #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = ch) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) +#endif +#if CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) +#else + #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ + PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) + #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check) + #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format) + #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) + #define PyObject_Malloc(s) PyMem_Malloc(s) + #define PyObject_Free(p) PyMem_Free(p) + #define PyObject_Realloc(p) PyMem_Realloc(p) +#endif +#if CYTHON_COMPILING_IN_PYSTON + #define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno) +#else + #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) +#endif +#define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) +#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) +#else + #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) +#endif +#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII) + #define PyObject_ASCII(o) PyObject_Repr(o) +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBaseString_Type PyUnicode_Type + #define PyStringObject PyUnicodeObject + #define PyString_Type PyUnicode_Type + #define PyString_Check PyUnicode_Check + #define PyString_CheckExact PyUnicode_CheckExact +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) + #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) +#else + #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) + #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) +#endif +#ifndef PySet_CheckExact + #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) +#endif +#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) +#define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) +#if PY_MAJOR_VERSION >= 3 + #define PyIntObject PyLongObject + #define PyInt_Type PyLong_Type + #define PyInt_Check(op) PyLong_Check(op) + #define PyInt_CheckExact(op) PyLong_CheckExact(op) + #define PyInt_FromString PyLong_FromString + #define PyInt_FromUnicode PyLong_FromUnicode + #define PyInt_FromLong PyLong_FromLong + #define PyInt_FromSize_t PyLong_FromSize_t + #define PyInt_FromSsize_t PyLong_FromSsize_t + #define PyInt_AsLong PyLong_AsLong + #define PyInt_AS_LONG PyLong_AS_LONG + #define PyInt_AsSsize_t PyLong_AsSsize_t + #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask + #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask + #define PyNumber_Int PyNumber_Long +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBoolObject PyLongObject +#endif +#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY + #ifndef PyUnicode_InternFromString + #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) + #endif +#endif +#if PY_VERSION_HEX < 0x030200A4 + typedef long Py_hash_t; + #define __Pyx_PyInt_FromHash_t PyInt_FromLong + #define __Pyx_PyInt_AsHash_t PyInt_AsLong +#else + #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t + #define __Pyx_PyInt_AsHash_t PyInt_AsSsize_t +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : PyInstanceMethod_New(func)) +#else + #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) +#endif +#if CYTHON_USE_ASYNC_SLOTS + #if PY_VERSION_HEX >= 0x030500B1 + #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods + #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) + #else + typedef struct { + unaryfunc am_await; + unaryfunc am_aiter; + unaryfunc am_anext; + } __Pyx_PyAsyncMethodsStruct; + #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) + #endif +#else + #define __Pyx_PyType_AsAsync(obj) NULL +#endif +#ifndef CYTHON_RESTRICT + #if defined(__GNUC__) + #define CYTHON_RESTRICT __restrict__ + #elif defined(_MSC_VER) && _MSC_VER >= 1400 + #define CYTHON_RESTRICT __restrict + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_RESTRICT restrict + #else + #define CYTHON_RESTRICT + #endif +#endif +#ifndef CYTHON_UNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +#endif +#ifndef CYTHON_MAYBE_UNUSED_VAR +# if defined(__cplusplus) + template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } +# else +# define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) +# endif +#endif +#ifndef CYTHON_NCP_UNUSED +# if CYTHON_COMPILING_IN_CPYTHON +# define CYTHON_NCP_UNUSED +# else +# define CYTHON_NCP_UNUSED CYTHON_UNUSED +# endif +#endif +#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) + +#ifndef CYTHON_INLINE + #if defined(__clang__) + #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) + #elif defined(__GNUC__) + #define CYTHON_INLINE __inline__ + #elif defined(_MSC_VER) + #define CYTHON_INLINE __inline + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_INLINE inline + #else + #define CYTHON_INLINE + #endif +#endif + +#if defined(WIN32) || defined(MS_WINDOWS) + #define _USE_MATH_DEFINES +#endif +#include +#ifdef NAN +#define __PYX_NAN() ((float) NAN) +#else +static CYTHON_INLINE float __PYX_NAN() { + float value; + memset(&value, 0xFF, sizeof(value)); + return value; +} +#endif +#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) +#define __Pyx_truncl trunc +#else +#define __Pyx_truncl truncl +#endif + + +#define __PYX_ERR(f_index, lineno, Ln_error) \ +{ \ + __pyx_filename = __pyx_f[f_index]; __pyx_lineno = lineno; __pyx_clineno = __LINE__; goto Ln_error; \ +} + +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) +#else + #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) +#endif + +#ifndef __PYX_EXTERN_C + #ifdef __cplusplus + #define __PYX_EXTERN_C extern "C" + #else + #define __PYX_EXTERN_C extern + #endif +#endif + +#define __PYX_HAVE__gevent___semaphore +#define __PYX_HAVE_API__gevent___semaphore +#ifdef _OPENMP +#include +#endif /* _OPENMP */ + +#ifdef PYREX_WITHOUT_ASSERTIONS +#define CYTHON_WITHOUT_ASSERTIONS +#endif + +typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding; + const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; + +#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 +#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT 0 +#define __PYX_DEFAULT_STRING_ENCODING "" +#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString +#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#define __Pyx_uchar_cast(c) ((unsigned char)c) +#define __Pyx_long_cast(x) ((long)x) +#define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ + (sizeof(type) < sizeof(Py_ssize_t)) ||\ + (sizeof(type) > sizeof(Py_ssize_t) &&\ + likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX) &&\ + (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ + v == (type)PY_SSIZE_T_MIN))) ||\ + (sizeof(type) == sizeof(Py_ssize_t) &&\ + (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX))) ) +#if defined (__cplusplus) && __cplusplus >= 201103L + #include + #define __Pyx_sst_abs(value) std::abs(value) +#elif SIZEOF_INT >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) abs(value) +#elif SIZEOF_LONG >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) labs(value) +#elif defined (_MSC_VER) && defined (_M_X64) + #define __Pyx_sst_abs(value) _abs64(value) +#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define __Pyx_sst_abs(value) llabs(value) +#elif defined (__GNUC__) + #define __Pyx_sst_abs(value) __builtin_llabs(value) +#else + #define __Pyx_sst_abs(value) ((value<0) ? -value : value) +#endif +static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject*); +static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); +#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) +#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) +#define __Pyx_PyBytes_FromString PyBytes_FromString +#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); +#if PY_MAJOR_VERSION < 3 + #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#else + #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize +#endif +#define __Pyx_PyObject_AsSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) +#define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) +#define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) +#define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) +#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) +#if PY_MAJOR_VERSION < 3 +static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) +{ + const Py_UNICODE *u_end = u; + while (*u_end++) ; + return (size_t)(u_end - u - 1); +} +#else +#define __Pyx_Py_UNICODE_strlen Py_UNICODE_strlen +#endif +#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) +#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode +#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode +#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) +#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) +#define __Pyx_PyBool_FromLong(b) ((b) ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False)) +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); +static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); +#if CYTHON_ASSUME_SAFE_MACROS +#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) +#else +#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) +#endif +#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) +#if PY_MAJOR_VERSION >= 3 +#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) +#else +#define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) +#endif +#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x)) +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII +static int __Pyx_sys_getdefaultencoding_not_ascii; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + PyObject* ascii_chars_u = NULL; + PyObject* ascii_chars_b = NULL; + const char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + if (strcmp(default_encoding_c, "ascii") == 0) { + __Pyx_sys_getdefaultencoding_not_ascii = 0; + } else { + char ascii_chars[128]; + int c; + for (c = 0; c < 128; c++) { + ascii_chars[c] = c; + } + __Pyx_sys_getdefaultencoding_not_ascii = 1; + ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); + if (!ascii_chars_u) goto bad; + ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); + if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { + PyErr_Format( + PyExc_ValueError, + "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", + default_encoding_c); + goto bad; + } + Py_DECREF(ascii_chars_u); + Py_DECREF(ascii_chars_b); + } + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + Py_XDECREF(ascii_chars_u); + Py_XDECREF(ascii_chars_b); + return -1; +} +#endif +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) +#else +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +static char* __PYX_DEFAULT_STRING_ENCODING; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c)); + if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; + strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + return -1; +} +#endif +#endif + + +/* Test for GCC > 2.95 */ +#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) + #define likely(x) __builtin_expect(!!(x), 1) + #define unlikely(x) __builtin_expect(!!(x), 0) +#else /* !__GNUC__ or GCC < 2.95 */ + #define likely(x) (x) + #define unlikely(x) (x) +#endif /* __GNUC__ */ + +static PyObject *__pyx_m; +static PyObject *__pyx_d; +static PyObject *__pyx_b; +static PyObject *__pyx_empty_tuple; +static PyObject *__pyx_empty_bytes; +static PyObject *__pyx_empty_unicode; +static int __pyx_lineno; +static int __pyx_clineno = 0; +static const char * __pyx_cfilenm= __FILE__; +static const char *__pyx_filename; + + +static const char *__pyx_f[] = { + "src\\gevent\\_semaphore.py", + "src\\gevent\\_semaphore.pxd", +}; + +/*--- Type declarations ---*/ +struct __pyx_obj_6gevent_10_semaphore_Semaphore; +struct __pyx_obj_6gevent_10_semaphore_BoundedSemaphore; +struct __pyx_opt_args_6gevent_10_semaphore_9Semaphore_wait; +struct __pyx_opt_args_6gevent_10_semaphore_9Semaphore_acquire; + +/* "gevent/_semaphore.pxd":15 + * cpdef _notify_links(self) + * cdef _do_wait(self, object timeout) + * cpdef int wait(self, object timeout=*) except -1000 # <<<<<<<<<<<<<< + * cpdef bint acquire(self, int blocking=*, object timeout=*) except -1000 + * cpdef __enter__(self) + */ +struct __pyx_opt_args_6gevent_10_semaphore_9Semaphore_wait { + int __pyx_n; + PyObject *timeout; +}; + +/* "gevent/_semaphore.pxd":16 + * cdef _do_wait(self, object timeout) + * cpdef int wait(self, object timeout=*) except -1000 + * cpdef bint acquire(self, int blocking=*, object timeout=*) except -1000 # <<<<<<<<<<<<<< + * cpdef __enter__(self) + * cpdef __exit__(self, object t, object v, object tb) + */ +struct __pyx_opt_args_6gevent_10_semaphore_9Semaphore_acquire { + int __pyx_n; + int blocking; + PyObject *timeout; +}; + +/* "gevent/_semaphore.pxd":1 + * cdef class Semaphore: # <<<<<<<<<<<<<< + * cdef public int counter + * cdef readonly object _links + */ +struct __pyx_obj_6gevent_10_semaphore_Semaphore { + PyObject_HEAD + struct __pyx_vtabstruct_6gevent_10_semaphore_Semaphore *__pyx_vtab; + int counter; + PyObject *_links; + PyObject *_notifier; + int _dirty; + PyObject *__weakref__; +}; + + +/* "gevent/_semaphore.pxd":20 + * cpdef __exit__(self, object t, object v, object tb) + * + * cdef class BoundedSemaphore(Semaphore): # <<<<<<<<<<<<<< + * cdef readonly int _initial_value + * + */ +struct __pyx_obj_6gevent_10_semaphore_BoundedSemaphore { + struct __pyx_obj_6gevent_10_semaphore_Semaphore __pyx_base; + int _initial_value; +}; + + + +/* "gevent/_semaphore.py":9 + * + * + * class Semaphore(object): # <<<<<<<<<<<<<< + * """ + * Semaphore(value=1) -> Semaphore + */ + +struct __pyx_vtabstruct_6gevent_10_semaphore_Semaphore { + int (*locked)(struct __pyx_obj_6gevent_10_semaphore_Semaphore *, int __pyx_skip_dispatch); + int (*release)(struct __pyx_obj_6gevent_10_semaphore_Semaphore *, int __pyx_skip_dispatch); + PyObject *(*rawlink)(struct __pyx_obj_6gevent_10_semaphore_Semaphore *, PyObject *, int __pyx_skip_dispatch); + PyObject *(*unlink)(struct __pyx_obj_6gevent_10_semaphore_Semaphore *, PyObject *, int __pyx_skip_dispatch); + PyObject *(*_start_notify)(struct __pyx_obj_6gevent_10_semaphore_Semaphore *, int __pyx_skip_dispatch); + PyObject *(*_notify_links)(struct __pyx_obj_6gevent_10_semaphore_Semaphore *, int __pyx_skip_dispatch); + PyObject *(*_do_wait)(struct __pyx_obj_6gevent_10_semaphore_Semaphore *, PyObject *); + int (*wait)(struct __pyx_obj_6gevent_10_semaphore_Semaphore *, int __pyx_skip_dispatch, struct __pyx_opt_args_6gevent_10_semaphore_9Semaphore_wait *__pyx_optional_args); + int (*acquire)(struct __pyx_obj_6gevent_10_semaphore_Semaphore *, int __pyx_skip_dispatch, struct __pyx_opt_args_6gevent_10_semaphore_9Semaphore_acquire *__pyx_optional_args); + PyObject *(*__pyx___enter__)(struct __pyx_obj_6gevent_10_semaphore_Semaphore *, int __pyx_skip_dispatch); + PyObject *(*__pyx___exit__)(struct __pyx_obj_6gevent_10_semaphore_Semaphore *, PyObject *, PyObject *, PyObject *, int __pyx_skip_dispatch); +}; +static struct __pyx_vtabstruct_6gevent_10_semaphore_Semaphore *__pyx_vtabptr_6gevent_10_semaphore_Semaphore; + + +/* "gevent/_semaphore.py":246 + * + * + * class BoundedSemaphore(Semaphore): # <<<<<<<<<<<<<< + * """ + * BoundedSemaphore(value=1) -> BoundedSemaphore + */ + +struct __pyx_vtabstruct_6gevent_10_semaphore_BoundedSemaphore { + struct __pyx_vtabstruct_6gevent_10_semaphore_Semaphore __pyx_base; +}; +static struct __pyx_vtabstruct_6gevent_10_semaphore_BoundedSemaphore *__pyx_vtabptr_6gevent_10_semaphore_BoundedSemaphore; + +/* --- Runtime support code (head) --- */ +/* Refnanny.proto */ +#ifndef CYTHON_REFNANNY + #define CYTHON_REFNANNY 0 +#endif +#if CYTHON_REFNANNY + typedef struct { + void (*INCREF)(void*, PyObject*, int); + void (*DECREF)(void*, PyObject*, int); + void (*GOTREF)(void*, PyObject*, int); + void (*GIVEREF)(void*, PyObject*, int); + void* (*SetupContext)(const char*, int, const char*); + void (*FinishContext)(void**); + } __Pyx_RefNannyAPIStruct; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); + #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; +#ifdef WITH_THREAD + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + if (acquire_gil) {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + PyGILState_Release(__pyx_gilstate_save);\ + } else {\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + } +#else + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) +#endif + #define __Pyx_RefNannyFinishContext()\ + __Pyx_RefNanny->FinishContext(&__pyx_refnanny) + #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) + #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) + #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) + #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) +#else + #define __Pyx_RefNannyDeclarations + #define __Pyx_RefNannySetupContext(name, acquire_gil) + #define __Pyx_RefNannyFinishContext() + #define __Pyx_INCREF(r) Py_INCREF(r) + #define __Pyx_DECREF(r) Py_DECREF(r) + #define __Pyx_GOTREF(r) + #define __Pyx_GIVEREF(r) + #define __Pyx_XINCREF(r) Py_XINCREF(r) + #define __Pyx_XDECREF(r) Py_XDECREF(r) + #define __Pyx_XGOTREF(r) + #define __Pyx_XGIVEREF(r) +#endif +#define __Pyx_XDECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_XDECREF(tmp);\ + } while (0) +#define __Pyx_DECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_DECREF(tmp);\ + } while (0) +#define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) +#define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) + +/* PyObjectGetAttrStr.proto */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro)) + return tp->tp_getattro(obj, attr_name); +#if PY_MAJOR_VERSION < 3 + if (likely(tp->tp_getattr)) + return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); +#endif + return PyObject_GetAttr(obj, attr_name); +} +#else +#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) +#endif + +/* GetBuiltinName.proto */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name); + +/* RaiseDoubleKeywords.proto */ +static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); + +/* ParseKeywords.proto */ +static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ + PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ + const char* function_name); + +/* RaiseArgTupleInvalid.proto */ +static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, + Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); + +/* PyObjectCall.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); +#else +#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) +#endif + +/* PyThreadStateGet.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; +#define __Pyx_PyThreadState_assign __pyx_tstate = PyThreadState_GET(); +#else +#define __Pyx_PyThreadState_declare +#define __Pyx_PyThreadState_assign +#endif + +/* PyErrFetchRestore.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#else +#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) +#endif + +/* RaiseException.proto */ +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); + +/* PyCFunctionFastCall.proto */ +#if CYTHON_FAST_PYCCALL +static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs); +#else +#define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL) +#endif + +/* PyFunctionFastCall.proto */ +#if CYTHON_FAST_PYCALL +#define __Pyx_PyFunction_FastCall(func, args, nargs)\ + __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) +#if 1 || PY_VERSION_HEX < 0x030600B1 +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, int nargs, PyObject *kwargs); +#else +#define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs) +#endif +#endif + +/* PyObjectCallMethO.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); +#endif + +/* PyObjectCallOneArg.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); + +/* PyObjectCallNoArg.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); +#else +#define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL) +#endif + +/* WriteUnraisableException.proto */ +static void __Pyx_WriteUnraisable(const char *name, int clineno, + int lineno, const char *filename, + int full_traceback, int nogil); + +/* GetModuleGlobalName.proto */ +static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name); + +/* SaveResetException.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#define __Pyx_ExceptionReset(type, value, tb) __Pyx__ExceptionReset(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +#else +#define __Pyx_ExceptionSave(type, value, tb) PyErr_GetExcInfo(type, value, tb) +#define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb) +#endif + +/* GetException.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb) +static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#else +static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); +#endif + +/* SwapException.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_ExceptionSwap(type, value, tb) __Pyx__ExceptionSwap(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#else +static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb); +#endif + +/* CallableCheck.proto */ +#if CYTHON_USE_TYPE_SLOTS && PY_MAJOR_VERSION >= 3 +#define __Pyx_PyCallable_Check(obj) ((obj)->ob_type->tp_call != NULL) +#else +#define __Pyx_PyCallable_Check(obj) PyCallable_Check(obj) +#endif + +/* ListAppend.proto */ +#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS +static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) { + PyListObject* L = (PyListObject*) list; + Py_ssize_t len = Py_SIZE(list); + if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) { + Py_INCREF(x); + PyList_SET_ITEM(list, len, x); + Py_SIZE(list) = len+1; + return 0; + } + return PyList_Append(list, x); +} +#else +#define __Pyx_PyList_Append(L,x) PyList_Append(L,x) +#endif + +/* PyObjectCallMethod1.proto */ +static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg); + +/* append.proto */ +static CYTHON_INLINE int __Pyx_PyObject_Append(PyObject* L, PyObject* x); + +/* PyErrExceptionMatches.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) +static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); +#else +#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) +#endif + +/* KeywordStringCheck.proto */ +static CYTHON_INLINE int __Pyx_CheckKeywordStrings(PyObject *kwdict, const char* function_name, int kw_allowed); + +/* SetVTable.proto */ +static int __Pyx_SetVtable(PyObject *dict, void *vtable); + +/* Import.proto */ +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); + +/* ImportFrom.proto */ +static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); + +/* FetchCommonType.proto */ +static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type); + +/* CythonFunction.proto */ +#define __Pyx_CyFunction_USED 1 +#include +#define __Pyx_CYFUNCTION_STATICMETHOD 0x01 +#define __Pyx_CYFUNCTION_CLASSMETHOD 0x02 +#define __Pyx_CYFUNCTION_CCLASS 0x04 +#define __Pyx_CyFunction_GetClosure(f)\ + (((__pyx_CyFunctionObject *) (f))->func_closure) +#define __Pyx_CyFunction_GetClassObj(f)\ + (((__pyx_CyFunctionObject *) (f))->func_classobj) +#define __Pyx_CyFunction_Defaults(type, f)\ + ((type *)(((__pyx_CyFunctionObject *) (f))->defaults)) +#define __Pyx_CyFunction_SetDefaultsGetter(f, g)\ + ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g) +typedef struct { + PyCFunctionObject func; +#if PY_VERSION_HEX < 0x030500A0 + PyObject *func_weakreflist; +#endif + PyObject *func_dict; + PyObject *func_name; + PyObject *func_qualname; + PyObject *func_doc; + PyObject *func_globals; + PyObject *func_code; + PyObject *func_closure; + PyObject *func_classobj; + void *defaults; + int defaults_pyobjects; + int flags; + PyObject *defaults_tuple; + PyObject *defaults_kwdict; + PyObject *(*defaults_getter)(PyObject *); + PyObject *func_annotations; +} __pyx_CyFunctionObject; +static PyTypeObject *__pyx_CyFunctionType = 0; +#define __Pyx_CyFunction_NewEx(ml, flags, qualname, self, module, globals, code)\ + __Pyx_CyFunction_New(__pyx_CyFunctionType, ml, flags, qualname, self, module, globals, code) +static PyObject *__Pyx_CyFunction_New(PyTypeObject *, PyMethodDef *ml, + int flags, PyObject* qualname, + PyObject *self, + PyObject *module, PyObject *globals, + PyObject* code); +static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *m, + size_t size, + int pyobjects); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m, + PyObject *tuple); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m, + PyObject *dict); +static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m, + PyObject *dict); +static int __pyx_CyFunction_init(void); + +/* GetNameInClass.proto */ +static PyObject *__Pyx_GetNameInClass(PyObject *nmspace, PyObject *name); + +/* CodeObjectCache.proto */ +typedef struct { + PyCodeObject* code_object; + int code_line; +} __Pyx_CodeObjectCacheEntry; +struct __Pyx_CodeObjectCache { + int count; + int max_count; + __Pyx_CodeObjectCacheEntry* entries; +}; +static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); +static PyCodeObject *__pyx_find_code_object(int code_line); +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); + +/* AddTraceback.proto */ +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); + +/* CIntFromPy.proto */ +static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); + +/* CIntFromPy.proto */ +static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); + +/* CheckBinaryVersion.proto */ +static int __Pyx_check_binary_version(void); + +/* InitStrings.proto */ +static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); + +static int __pyx_f_6gevent_10_semaphore_9Semaphore_locked(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static int __pyx_f_6gevent_10_semaphore_9Semaphore_release(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static PyObject *__pyx_f_6gevent_10_semaphore_9Semaphore__start_notify(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static PyObject *__pyx_f_6gevent_10_semaphore_9Semaphore__notify_links(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static PyObject *__pyx_f_6gevent_10_semaphore_9Semaphore_rawlink(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self, PyObject *__pyx_v_callback, int __pyx_skip_dispatch); /* proto*/ +static PyObject *__pyx_f_6gevent_10_semaphore_9Semaphore_unlink(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self, PyObject *__pyx_v_callback, int __pyx_skip_dispatch); /* proto*/ +static PyObject *__pyx_f_6gevent_10_semaphore_9Semaphore__do_wait(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self, PyObject *__pyx_v_timeout); /* proto*/ +static int __pyx_f_6gevent_10_semaphore_9Semaphore_wait(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self, int __pyx_skip_dispatch, struct __pyx_opt_args_6gevent_10_semaphore_9Semaphore_wait *__pyx_optional_args); /* proto*/ +static int __pyx_f_6gevent_10_semaphore_9Semaphore_acquire(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self, int __pyx_skip_dispatch, struct __pyx_opt_args_6gevent_10_semaphore_9Semaphore_acquire *__pyx_optional_args); /* proto*/ +static PyObject *__pyx_f_6gevent_10_semaphore_9Semaphore___enter__(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static PyObject *__pyx_f_6gevent_10_semaphore_9Semaphore___exit__(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_t, CYTHON_UNUSED PyObject *__pyx_v_v, CYTHON_UNUSED PyObject *__pyx_v_tb, int __pyx_skip_dispatch); /* proto*/ +static int __pyx_f_6gevent_10_semaphore_16BoundedSemaphore_release(struct __pyx_obj_6gevent_10_semaphore_BoundedSemaphore *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ + +/* Module declarations from 'gevent._semaphore' */ +static PyTypeObject *__pyx_ptype_6gevent_10_semaphore_Semaphore = 0; +static PyTypeObject *__pyx_ptype_6gevent_10_semaphore_BoundedSemaphore = 0; +#define __Pyx_MODULE_NAME "gevent._semaphore" +int __pyx_module_is_main_gevent___semaphore = 0; + +/* Implementation of 'gevent._semaphore' */ +static PyObject *__pyx_builtin_ValueError; +static PyObject *__pyx_builtin_TypeError; +static PyObject *__pyx_builtin_AttributeError; +static const char __pyx_k_t[] = "t"; +static const char __pyx_k_v[] = "v"; +static const char __pyx_k_tb[] = "tb"; +static const char __pyx_k_all[] = "__all__"; +static const char __pyx_k_sys[] = "sys"; +static const char __pyx_k_exit[] = "__exit__"; +static const char __pyx_k_init[] = "__init__"; +static const char __pyx_k_loop[] = "loop"; +static const char __pyx_k_main[] = "__main__"; +static const char __pyx_k_name[] = "__name__"; +static const char __pyx_k_self[] = "self"; +static const char __pyx_k_test[] = "__test__"; +static const char __pyx_k_wait[] = "wait"; +static const char __pyx_k_class[] = "__class__"; +static const char __pyx_k_enter[] = "__enter__"; +static const char __pyx_k_value[] = "value"; +static const char __pyx_k_append[] = "append"; +static const char __pyx_k_cancel[] = "cancel"; +static const char __pyx_k_import[] = "__import__"; +static const char __pyx_k_locked[] = "locked"; +static const char __pyx_k_remove[] = "remove"; +static const char __pyx_k_switch[] = "switch"; +static const char __pyx_k_unlink[] = "unlink"; +static const char __pyx_k_Timeout[] = "Timeout"; +static const char __pyx_k_acquire[] = "acquire"; +static const char __pyx_k_get_hub[] = "get_hub"; +static const char __pyx_k_rawlink[] = "rawlink"; +static const char __pyx_k_release[] = "release"; +static const char __pyx_k_timeout[] = "timeout"; +static const char __pyx_k_blocking[] = "blocking"; +static const char __pyx_k_callback[] = "callback"; +static const char __pyx_k_exc_info[] = "exc_info"; +static const char __pyx_k_Semaphore[] = "Semaphore"; +static const char __pyx_k_TypeError[] = "TypeError"; +static const char __pyx_k_ValueError[] = "ValueError"; +static const char __pyx_k_getcurrent[] = "getcurrent"; +static const char __pyx_k_gevent_hub[] = "gevent.hub"; +static const char __pyx_k_pyx_vtable[] = "__pyx_vtable__"; +static const char __pyx_k_handle_error[] = "handle_error"; +static const char __pyx_k_notify_links[] = "_notify_links"; +static const char __pyx_k_py3k_acquire[] = "_py3k_acquire"; +static const char __pyx_k_run_callback[] = "run_callback"; +static const char __pyx_k_start_notify[] = "_start_notify"; +static const char __pyx_k_AttributeError[] = "AttributeError"; +static const char __pyx_k_Semaphore_wait[] = "Semaphore.wait"; +static const char __pyx_k_gevent_timeout[] = "gevent.timeout"; +static const char __pyx_k_BoundedSemaphore[] = "BoundedSemaphore"; +static const char __pyx_k_Semaphore___exit[] = "Semaphore.__exit__"; +static const char __pyx_k_Semaphore_locked[] = "Semaphore.locked"; +static const char __pyx_k_Semaphore_unlink[] = "Semaphore.unlink"; +static const char __pyx_k_Expected_callable[] = "Expected callable:"; +static const char __pyx_k_Semaphore___enter[] = "Semaphore.__enter__"; +static const char __pyx_k_Semaphore_acquire[] = "Semaphore.acquire"; +static const char __pyx_k_Semaphore_rawlink[] = "Semaphore.rawlink"; +static const char __pyx_k_Semaphore_release[] = "Semaphore.release"; +static const char __pyx_k_gevent__semaphore[] = "gevent._semaphore"; +static const char __pyx_k_OVER_RELEASE_ERROR[] = "_OVER_RELEASE_ERROR"; +static const char __pyx_k_start_new_or_dummy[] = "_start_new_or_dummy"; +static const char __pyx_k_s_counter_s__links_s[] = "<%s counter=%s _links[%s]>"; +static const char __pyx_k_Semaphore__notify_links[] = "Semaphore._notify_links"; +static const char __pyx_k_Semaphore__start_notify[] = "Semaphore._start_notify"; +static const char __pyx_k_BoundedSemaphore_release[] = "BoundedSemaphore.release"; +static const char __pyx_k_semaphore_initial_value_must_be[] = "semaphore initial value must be >= 0"; +static const char __pyx_k_C_projects_gevent_src_gevent__se[] = "C:\\projects\\gevent\\src\\gevent\\_semaphore.py"; +static const char __pyx_k_Invalid_switch_into_Semaphore_wa[] = "Invalid switch into Semaphore.wait/acquire(): %r"; +static const char __pyx_k_Semaphore_released_too_many_time[] = "Semaphore released too many times"; +static PyObject *__pyx_n_s_AttributeError; +static PyObject *__pyx_n_s_BoundedSemaphore; +static PyObject *__pyx_n_s_BoundedSemaphore_release; +static PyObject *__pyx_kp_s_C_projects_gevent_src_gevent__se; +static PyObject *__pyx_kp_s_Expected_callable; +static PyObject *__pyx_kp_s_Invalid_switch_into_Semaphore_wa; +static PyObject *__pyx_n_s_OVER_RELEASE_ERROR; +static PyObject *__pyx_n_s_Semaphore; +static PyObject *__pyx_n_s_Semaphore___enter; +static PyObject *__pyx_n_s_Semaphore___exit; +static PyObject *__pyx_n_s_Semaphore__notify_links; +static PyObject *__pyx_n_s_Semaphore__start_notify; +static PyObject *__pyx_n_s_Semaphore_acquire; +static PyObject *__pyx_n_s_Semaphore_locked; +static PyObject *__pyx_n_s_Semaphore_rawlink; +static PyObject *__pyx_n_s_Semaphore_release; +static PyObject *__pyx_kp_s_Semaphore_released_too_many_time; +static PyObject *__pyx_n_s_Semaphore_unlink; +static PyObject *__pyx_n_s_Semaphore_wait; +static PyObject *__pyx_n_s_Timeout; +static PyObject *__pyx_n_s_TypeError; +static PyObject *__pyx_n_s_ValueError; +static PyObject *__pyx_n_s_acquire; +static PyObject *__pyx_n_s_all; +static PyObject *__pyx_n_s_append; +static PyObject *__pyx_n_s_blocking; +static PyObject *__pyx_n_s_callback; +static PyObject *__pyx_n_s_cancel; +static PyObject *__pyx_n_s_class; +static PyObject *__pyx_n_s_enter; +static PyObject *__pyx_n_s_exc_info; +static PyObject *__pyx_n_s_exit; +static PyObject *__pyx_n_s_get_hub; +static PyObject *__pyx_n_s_getcurrent; +static PyObject *__pyx_n_s_gevent__semaphore; +static PyObject *__pyx_n_s_gevent_hub; +static PyObject *__pyx_n_s_gevent_timeout; +static PyObject *__pyx_n_s_handle_error; +static PyObject *__pyx_n_s_import; +static PyObject *__pyx_n_s_init; +static PyObject *__pyx_n_s_locked; +static PyObject *__pyx_n_s_loop; +static PyObject *__pyx_n_s_main; +static PyObject *__pyx_n_s_name; +static PyObject *__pyx_n_s_notify_links; +static PyObject *__pyx_n_s_py3k_acquire; +static PyObject *__pyx_n_s_pyx_vtable; +static PyObject *__pyx_n_s_rawlink; +static PyObject *__pyx_n_s_release; +static PyObject *__pyx_n_s_remove; +static PyObject *__pyx_n_s_run_callback; +static PyObject *__pyx_kp_s_s_counter_s__links_s; +static PyObject *__pyx_n_s_self; +static PyObject *__pyx_kp_s_semaphore_initial_value_must_be; +static PyObject *__pyx_n_s_start_new_or_dummy; +static PyObject *__pyx_n_s_start_notify; +static PyObject *__pyx_n_s_switch; +static PyObject *__pyx_n_s_sys; +static PyObject *__pyx_n_s_t; +static PyObject *__pyx_n_s_tb; +static PyObject *__pyx_n_s_test; +static PyObject *__pyx_n_s_timeout; +static PyObject *__pyx_n_s_unlink; +static PyObject *__pyx_n_s_v; +static PyObject *__pyx_n_s_value; +static PyObject *__pyx_n_s_wait; +static int __pyx_pf_6gevent_10_semaphore_9Semaphore___init__(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_6gevent_10_semaphore_9Semaphore_2__str__(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_10_semaphore_9Semaphore_4locked(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_10_semaphore_9Semaphore_6release(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_10_semaphore_9Semaphore_8_start_notify(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_10_semaphore_9Semaphore_10_notify_links(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_10_semaphore_9Semaphore_12rawlink(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self, PyObject *__pyx_v_callback); /* proto */ +static PyObject *__pyx_pf_6gevent_10_semaphore_9Semaphore_14unlink(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self, PyObject *__pyx_v_callback); /* proto */ +static PyObject *__pyx_pf_6gevent_10_semaphore_9Semaphore_16wait(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self, PyObject *__pyx_v_timeout); /* proto */ +static PyObject *__pyx_pf_6gevent_10_semaphore_9Semaphore_18acquire(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self, int __pyx_v_blocking, PyObject *__pyx_v_timeout); /* proto */ +static PyObject *__pyx_pf_6gevent_10_semaphore_9Semaphore_20__enter__(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_10_semaphore_9Semaphore_22__exit__(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self, PyObject *__pyx_v_t, PyObject *__pyx_v_v, PyObject *__pyx_v_tb); /* proto */ +static PyObject *__pyx_pf_6gevent_10_semaphore_9Semaphore_7counter___get__(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_10_semaphore_9Semaphore_7counter_2__set__(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_6gevent_10_semaphore_9Semaphore_6_links___get__(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_10_semaphore_9Semaphore_9_notifier___get__(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_10_semaphore_9Semaphore_6_dirty___get__(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_10_semaphore_9Semaphore_6_dirty_2__set__(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_6gevent_10_semaphore_16BoundedSemaphore___init__(struct __pyx_obj_6gevent_10_semaphore_BoundedSemaphore *__pyx_v_self, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs); /* proto */ +static PyObject *__pyx_pf_6gevent_10_semaphore_16BoundedSemaphore_2release(struct __pyx_obj_6gevent_10_semaphore_BoundedSemaphore *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_10_semaphore_16BoundedSemaphore_14_initial_value___get__(struct __pyx_obj_6gevent_10_semaphore_BoundedSemaphore *__pyx_v_self); /* proto */ +static PyObject *__pyx_tp_new_6gevent_10_semaphore_Semaphore(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_6gevent_10_semaphore_BoundedSemaphore(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_int_0; +static PyObject *__pyx_int_1; +static PyObject *__pyx_tuple_; +static PyObject *__pyx_tuple__2; +static PyObject *__pyx_tuple__3; +static PyObject *__pyx_tuple__5; +static PyObject *__pyx_tuple__7; +static PyObject *__pyx_tuple__9; +static PyObject *__pyx_tuple__11; +static PyObject *__pyx_tuple__13; +static PyObject *__pyx_tuple__15; +static PyObject *__pyx_tuple__17; +static PyObject *__pyx_tuple__19; +static PyObject *__pyx_tuple__21; +static PyObject *__pyx_tuple__23; +static PyObject *__pyx_codeobj__4; +static PyObject *__pyx_codeobj__6; +static PyObject *__pyx_codeobj__8; +static PyObject *__pyx_codeobj__10; +static PyObject *__pyx_codeobj__12; +static PyObject *__pyx_codeobj__14; +static PyObject *__pyx_codeobj__16; +static PyObject *__pyx_codeobj__18; +static PyObject *__pyx_codeobj__20; +static PyObject *__pyx_codeobj__22; +static PyObject *__pyx_codeobj__24; + +/* "gevent/_semaphore.py":29 + * """ + * + * def __init__(self, value=1): # <<<<<<<<<<<<<< + * if value < 0: + * raise ValueError("semaphore initial value must be >= 0") + */ + +/* Python wrapper */ +static int __pyx_pw_6gevent_10_semaphore_9Semaphore_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_6gevent_10_semaphore_9Semaphore_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_value = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_value,0}; + PyObject* values[1] = {0}; + values[0] = ((PyObject *)__pyx_int_1); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_value); + if (value) { values[0] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 29, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_value = values[0]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 29, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("gevent._semaphore.Semaphore.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_10_semaphore_9Semaphore___init__(((struct __pyx_obj_6gevent_10_semaphore_Semaphore *)__pyx_v_self), __pyx_v_value); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_10_semaphore_9Semaphore___init__(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + __Pyx_RefNannySetupContext("__init__", 0); + + /* "gevent/_semaphore.py":30 + * + * def __init__(self, value=1): + * if value < 0: # <<<<<<<<<<<<<< + * raise ValueError("semaphore initial value must be >= 0") + * self.counter = value + */ + __pyx_t_1 = PyObject_RichCompare(__pyx_v_value, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 30, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 30, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "gevent/_semaphore.py":31 + * def __init__(self, value=1): + * if value < 0: + * raise ValueError("semaphore initial value must be >= 0") # <<<<<<<<<<<<<< + * self.counter = value + * self._dirty = False + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 31, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 31, __pyx_L1_error) + + /* "gevent/_semaphore.py":30 + * + * def __init__(self, value=1): + * if value < 0: # <<<<<<<<<<<<<< + * raise ValueError("semaphore initial value must be >= 0") + * self.counter = value + */ + } + + /* "gevent/_semaphore.py":32 + * if value < 0: + * raise ValueError("semaphore initial value must be >= 0") + * self.counter = value # <<<<<<<<<<<<<< + * self._dirty = False + * # In PyPy 2.6.1 with Cython 0.23, `cdef public` or `cdef + */ + __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_v_value); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 32, __pyx_L1_error) + __pyx_v_self->counter = __pyx_t_3; + + /* "gevent/_semaphore.py":33 + * raise ValueError("semaphore initial value must be >= 0") + * self.counter = value + * self._dirty = False # <<<<<<<<<<<<<< + * # In PyPy 2.6.1 with Cython 0.23, `cdef public` or `cdef + * # readonly` or simply `cdef` attributes of type `object` can appear to leak if + */ + __pyx_v_self->_dirty = 0; + + /* "gevent/_semaphore.py":47 + * # CPython ("No attribute...") + * # See https://github.com/gevent/gevent/issues/660 + * self._links = None # <<<<<<<<<<<<<< + * self._notifier = None + * # we don't want to do get_hub() here to allow defining module-level locks + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->_links); + __Pyx_DECREF(__pyx_v_self->_links); + __pyx_v_self->_links = Py_None; + + /* "gevent/_semaphore.py":48 + * # See https://github.com/gevent/gevent/issues/660 + * self._links = None + * self._notifier = None # <<<<<<<<<<<<<< + * # we don't want to do get_hub() here to allow defining module-level locks + * # without initializing the hub + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->_notifier); + __Pyx_DECREF(__pyx_v_self->_notifier); + __pyx_v_self->_notifier = Py_None; + + /* "gevent/_semaphore.py":29 + * """ + * + * def __init__(self, value=1): # <<<<<<<<<<<<<< + * if value < 0: + * raise ValueError("semaphore initial value must be >= 0") + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent._semaphore.Semaphore.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "gevent/_semaphore.py":52 + * # without initializing the hub + * + * def __str__(self): # <<<<<<<<<<<<<< + * params = (self.__class__.__name__, self.counter, len(self._links) if self._links else 0) + * return '<%s counter=%s _links[%s]>' % params + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_10_semaphore_9Semaphore_3__str__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_10_semaphore_9Semaphore_3__str__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__str__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_10_semaphore_9Semaphore_2__str__(((struct __pyx_obj_6gevent_10_semaphore_Semaphore *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_10_semaphore_9Semaphore_2__str__(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self) { + PyObject *__pyx_v_params = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + Py_ssize_t __pyx_t_6; + __Pyx_RefNannySetupContext("__str__", 0); + + /* "gevent/_semaphore.py":53 + * + * def __str__(self): + * params = (self.__class__.__name__, self.counter, len(self._links) if self._links else 0) # <<<<<<<<<<<<<< + * return '<%s counter=%s _links[%s]>' % params + * + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 53, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 53, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->counter); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 53, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_self->_links); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 53, __pyx_L1_error) + if (__pyx_t_4) { + __pyx_t_5 = __pyx_v_self->_links; + __Pyx_INCREF(__pyx_t_5); + __pyx_t_6 = PyObject_Length(__pyx_t_5); if (unlikely(__pyx_t_6 == -1)) __PYX_ERR(0, 53, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = PyInt_FromSsize_t(__pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 53, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_3 = __pyx_t_5; + __pyx_t_5 = 0; + } else { + __Pyx_INCREF(__pyx_int_0); + __pyx_t_3 = __pyx_int_0; + } + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 53, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_3); + __pyx_t_2 = 0; + __pyx_t_1 = 0; + __pyx_t_3 = 0; + __pyx_v_params = ((PyObject*)__pyx_t_5); + __pyx_t_5 = 0; + + /* "gevent/_semaphore.py":54 + * def __str__(self): + * params = (self.__class__.__name__, self.counter, len(self._links) if self._links else 0) + * return '<%s counter=%s _links[%s]>' % params # <<<<<<<<<<<<<< + * + * def locked(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_s_counter_s__links_s, __pyx_v_params); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 54, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "gevent/_semaphore.py":52 + * # without initializing the hub + * + * def __str__(self): # <<<<<<<<<<<<<< + * params = (self.__class__.__name__, self.counter, len(self._links) if self._links else 0) + * return '<%s counter=%s _links[%s]>' % params + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("gevent._semaphore.Semaphore.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_params); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "gevent/_semaphore.py":56 + * return '<%s counter=%s _links[%s]>' % params + * + * def locked(self): # <<<<<<<<<<<<<< + * """Return a boolean indicating whether the semaphore can be acquired. + * Most useful with binary semaphores.""" + */ + +static PyObject *__pyx_pw_6gevent_10_semaphore_9Semaphore_5locked(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static int __pyx_f_6gevent_10_semaphore_9Semaphore_locked(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self, int __pyx_skip_dispatch) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + __Pyx_RefNannySetupContext("locked", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_locked); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 56, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_6gevent_10_semaphore_9Semaphore_5locked)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 56, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 56, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 56, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_5; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "gevent/_semaphore.py":59 + * """Return a boolean indicating whether the semaphore can be acquired. + * Most useful with binary semaphores.""" + * return self.counter <= 0 # <<<<<<<<<<<<<< + * + * def release(self): + */ + __pyx_r = (__pyx_v_self->counter <= 0); + goto __pyx_L0; + + /* "gevent/_semaphore.py":56 + * return '<%s counter=%s _links[%s]>' % params + * + * def locked(self): # <<<<<<<<<<<<<< + * """Return a boolean indicating whether the semaphore can be acquired. + * Most useful with binary semaphores.""" + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("gevent._semaphore.Semaphore.locked", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_10_semaphore_9Semaphore_5locked(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_6gevent_10_semaphore_9Semaphore_4locked[] = "Return a boolean indicating whether the semaphore can be acquired.\n Most useful with binary semaphores."; +static PyMethodDef __pyx_mdef_6gevent_10_semaphore_9Semaphore_5locked = {"locked", (PyCFunction)__pyx_pw_6gevent_10_semaphore_9Semaphore_5locked, METH_NOARGS, __pyx_doc_6gevent_10_semaphore_9Semaphore_4locked}; +static PyObject *__pyx_pw_6gevent_10_semaphore_9Semaphore_5locked(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("locked (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_10_semaphore_9Semaphore_4locked(((struct __pyx_obj_6gevent_10_semaphore_Semaphore *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_10_semaphore_9Semaphore_4locked(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("locked", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_f_6gevent_10_semaphore_9Semaphore_locked(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 56, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent._semaphore.Semaphore.locked", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "gevent/_semaphore.py":61 + * return self.counter <= 0 + * + * def release(self): # <<<<<<<<<<<<<< + * """ + * Release the semaphore, notifying any waiters if needed. + */ + +static PyObject *__pyx_pw_6gevent_10_semaphore_9Semaphore_7release(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static int __pyx_f_6gevent_10_semaphore_9Semaphore_release(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self, int __pyx_skip_dispatch) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + __Pyx_RefNannySetupContext("release", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_release); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 61, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_6gevent_10_semaphore_9Semaphore_7release)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 61, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 61, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 61, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_5; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "gevent/_semaphore.py":65 + * Release the semaphore, notifying any waiters if needed. + * """ + * self.counter += 1 # <<<<<<<<<<<<<< + * self._start_notify() + * return self.counter + */ + __pyx_v_self->counter = (__pyx_v_self->counter + 1); + + /* "gevent/_semaphore.py":66 + * """ + * self.counter += 1 + * self._start_notify() # <<<<<<<<<<<<<< + * return self.counter + * + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_6gevent_10_semaphore_Semaphore *)__pyx_v_self->__pyx_vtab)->_start_notify(__pyx_v_self, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 66, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "gevent/_semaphore.py":67 + * self.counter += 1 + * self._start_notify() + * return self.counter # <<<<<<<<<<<<<< + * + * def _start_notify(self): + */ + __pyx_r = __pyx_v_self->counter; + goto __pyx_L0; + + /* "gevent/_semaphore.py":61 + * return self.counter <= 0 + * + * def release(self): # <<<<<<<<<<<<<< + * """ + * Release the semaphore, notifying any waiters if needed. + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("gevent._semaphore.Semaphore.release", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1000; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_10_semaphore_9Semaphore_7release(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_6gevent_10_semaphore_9Semaphore_6release[] = "\n Release the semaphore, notifying any waiters if needed.\n "; +static PyMethodDef __pyx_mdef_6gevent_10_semaphore_9Semaphore_7release = {"release", (PyCFunction)__pyx_pw_6gevent_10_semaphore_9Semaphore_7release, METH_NOARGS, __pyx_doc_6gevent_10_semaphore_9Semaphore_6release}; +static PyObject *__pyx_pw_6gevent_10_semaphore_9Semaphore_7release(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("release (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_10_semaphore_9Semaphore_6release(((struct __pyx_obj_6gevent_10_semaphore_Semaphore *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_10_semaphore_9Semaphore_6release(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("release", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_6gevent_10_semaphore_9Semaphore_release(__pyx_v_self, 1); if (unlikely(__pyx_t_1 == -1000)) __PYX_ERR(0, 61, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 61, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent._semaphore.Semaphore.release", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "gevent/_semaphore.py":69 + * return self.counter + * + * def _start_notify(self): # <<<<<<<<<<<<<< + * if self._links and self.counter > 0 and not self._notifier: + * # We create a new self._notifier each time through the loop, + */ + +static PyObject *__pyx_pw_6gevent_10_semaphore_9Semaphore_9_start_notify(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_f_6gevent_10_semaphore_9Semaphore__start_notify(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self, int __pyx_skip_dispatch) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + __Pyx_RefNannySetupContext("_start_notify", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_start_notify); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 69, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_6gevent_10_semaphore_9Semaphore_9_start_notify)) { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 69, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 69, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "gevent/_semaphore.py":70 + * + * def _start_notify(self): + * if self._links and self.counter > 0 and not self._notifier: # <<<<<<<<<<<<<< + * # We create a new self._notifier each time through the loop, + * # if needed. (it has a __bool__ method that tells whether it has + */ + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_v_self->_links); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 70, __pyx_L1_error) + if (__pyx_t_6) { + } else { + __pyx_t_5 = __pyx_t_6; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_6 = ((__pyx_v_self->counter > 0) != 0); + if (__pyx_t_6) { + } else { + __pyx_t_5 = __pyx_t_6; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_v_self->_notifier); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 70, __pyx_L1_error) + __pyx_t_7 = ((!__pyx_t_6) != 0); + __pyx_t_5 = __pyx_t_7; + __pyx_L4_bool_binop_done:; + if (__pyx_t_5) { + + /* "gevent/_semaphore.py":78 + * # with Cython <= 0.23.3. You must use >= 0.23.4. + * # See https://bitbucket.org/pypy/pypy/issues/2149/memory-leak-for-python-subclass-of-cpyext#comment-22371546 + * self._notifier = get_hub().loop.run_callback(self._notify_links) # <<<<<<<<<<<<<< + * + * def _notify_links(self): + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_get_hub); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 78, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 78, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 78, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_loop); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 78, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_run_callback); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 78, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_notify_links); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 78, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (!__pyx_t_4) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 78, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 78, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 78, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 78, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 78, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->_notifier); + __Pyx_DECREF(__pyx_v_self->_notifier); + __pyx_v_self->_notifier = __pyx_t_1; + __pyx_t_1 = 0; + + /* "gevent/_semaphore.py":70 + * + * def _start_notify(self): + * if self._links and self.counter > 0 and not self._notifier: # <<<<<<<<<<<<<< + * # We create a new self._notifier each time through the loop, + * # if needed. (it has a __bool__ method that tells whether it has + */ + } + + /* "gevent/_semaphore.py":69 + * return self.counter + * + * def _start_notify(self): # <<<<<<<<<<<<<< + * if self._links and self.counter > 0 and not self._notifier: + * # We create a new self._notifier each time through the loop, + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("gevent._semaphore.Semaphore._start_notify", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_10_semaphore_9Semaphore_9_start_notify(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyMethodDef __pyx_mdef_6gevent_10_semaphore_9Semaphore_9_start_notify = {"_start_notify", (PyCFunction)__pyx_pw_6gevent_10_semaphore_9Semaphore_9_start_notify, METH_NOARGS, 0}; +static PyObject *__pyx_pw_6gevent_10_semaphore_9Semaphore_9_start_notify(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_start_notify (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_10_semaphore_9Semaphore_8_start_notify(((struct __pyx_obj_6gevent_10_semaphore_Semaphore *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_10_semaphore_9Semaphore_8_start_notify(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("_start_notify", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_6gevent_10_semaphore_9Semaphore__start_notify(__pyx_v_self, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 69, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent._semaphore.Semaphore._start_notify", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "gevent/_semaphore.py":80 + * self._notifier = get_hub().loop.run_callback(self._notify_links) + * + * def _notify_links(self): # <<<<<<<<<<<<<< + * # Subclasses CANNOT override. This is a cdef method. + * + */ + +static PyObject *__pyx_pw_6gevent_10_semaphore_9Semaphore_11_notify_links(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_f_6gevent_10_semaphore_9Semaphore__notify_links(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self, int __pyx_skip_dispatch) { + PyObject *__pyx_v_notifier = NULL; + PyObject *__pyx_v_link = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_t_6; + Py_ssize_t __pyx_t_7; + PyObject *(*__pyx_t_8)(PyObject *); + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11 = NULL; + PyObject *__pyx_t_12 = NULL; + PyObject *__pyx_t_13 = NULL; + PyObject *__pyx_t_14 = NULL; + PyObject *__pyx_t_15 = NULL; + PyObject *__pyx_t_16 = NULL; + int __pyx_t_17; + int __pyx_t_18; + char const *__pyx_t_19; + PyObject *__pyx_t_20 = NULL; + PyObject *__pyx_t_21 = NULL; + PyObject *__pyx_t_22 = NULL; + __Pyx_RefNannySetupContext("_notify_links", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_notify_links); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 80, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_6gevent_10_semaphore_9Semaphore_11_notify_links)) { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 80, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 80, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "gevent/_semaphore.py":89 + * # no need to keep it around until that point (making it potentially climb + * # into older GC generations, notably on PyPy) + * notifier = self._notifier # <<<<<<<<<<<<<< + * try: + * while True: + */ + __pyx_t_1 = __pyx_v_self->_notifier; + __Pyx_INCREF(__pyx_t_1); + __pyx_v_notifier = __pyx_t_1; + __pyx_t_1 = 0; + + /* "gevent/_semaphore.py":90 + * # into older GC generations, notably on PyPy) + * notifier = self._notifier + * try: # <<<<<<<<<<<<<< + * while True: + * self._dirty = False + */ + /*try:*/ { + + /* "gevent/_semaphore.py":91 + * notifier = self._notifier + * try: + * while True: # <<<<<<<<<<<<<< + * self._dirty = False + * if not self._links: + */ + while (1) { + + /* "gevent/_semaphore.py":92 + * try: + * while True: + * self._dirty = False # <<<<<<<<<<<<<< + * if not self._links: + * # In case we were manually unlinked before + */ + __pyx_v_self->_dirty = 0; + + /* "gevent/_semaphore.py":93 + * while True: + * self._dirty = False + * if not self._links: # <<<<<<<<<<<<<< + * # In case we were manually unlinked before + * # the callback. Which shouldn't happen + */ + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_v_self->_links); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 93, __pyx_L4_error) + __pyx_t_6 = ((!__pyx_t_5) != 0); + if (__pyx_t_6) { + + /* "gevent/_semaphore.py":96 + * # In case we were manually unlinked before + * # the callback. Which shouldn't happen + * return # <<<<<<<<<<<<<< + * for link in self._links: + * if self.counter <= 0: + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L3_return; + + /* "gevent/_semaphore.py":93 + * while True: + * self._dirty = False + * if not self._links: # <<<<<<<<<<<<<< + * # In case we were manually unlinked before + * # the callback. Which shouldn't happen + */ + } + + /* "gevent/_semaphore.py":97 + * # the callback. Which shouldn't happen + * return + * for link in self._links: # <<<<<<<<<<<<<< + * if self.counter <= 0: + * return + */ + if (likely(PyList_CheckExact(__pyx_v_self->_links)) || PyTuple_CheckExact(__pyx_v_self->_links)) { + __pyx_t_1 = __pyx_v_self->_links; __Pyx_INCREF(__pyx_t_1); __pyx_t_7 = 0; + __pyx_t_8 = NULL; + } else { + __pyx_t_7 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_self->_links); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 97, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_8 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 97, __pyx_L4_error) + } + for (;;) { + if (likely(!__pyx_t_8)) { + if (likely(PyList_CheckExact(__pyx_t_1))) { + if (__pyx_t_7 >= PyList_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_2 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_7); __Pyx_INCREF(__pyx_t_2); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(0, 97, __pyx_L4_error) + #else + __pyx_t_2 = PySequence_ITEM(__pyx_t_1, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 97, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + #endif + } else { + if (__pyx_t_7 >= PyTuple_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_7); __Pyx_INCREF(__pyx_t_2); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(0, 97, __pyx_L4_error) + #else + __pyx_t_2 = PySequence_ITEM(__pyx_t_1, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 97, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + #endif + } + } else { + __pyx_t_2 = __pyx_t_8(__pyx_t_1); + if (unlikely(!__pyx_t_2)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 97, __pyx_L4_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_XDECREF_SET(__pyx_v_link, __pyx_t_2); + __pyx_t_2 = 0; + + /* "gevent/_semaphore.py":98 + * return + * for link in self._links: + * if self.counter <= 0: # <<<<<<<<<<<<<< + * return + * try: + */ + __pyx_t_6 = ((__pyx_v_self->counter <= 0) != 0); + if (__pyx_t_6) { + + /* "gevent/_semaphore.py":99 + * for link in self._links: + * if self.counter <= 0: + * return # <<<<<<<<<<<<<< + * try: + * link(self) # Must use Cython >= 0.23.4 on PyPy else this leaks memory + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L3_return; + + /* "gevent/_semaphore.py":98 + * return + * for link in self._links: + * if self.counter <= 0: # <<<<<<<<<<<<<< + * return + * try: + */ + } + + /* "gevent/_semaphore.py":100 + * if self.counter <= 0: + * return + * try: # <<<<<<<<<<<<<< + * link(self) # Must use Cython >= 0.23.4 on PyPy else this leaks memory + * except: # pylint:disable=bare-except + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); + __Pyx_XGOTREF(__pyx_t_9); + __Pyx_XGOTREF(__pyx_t_10); + __Pyx_XGOTREF(__pyx_t_11); + /*try:*/ { + + /* "gevent/_semaphore.py":101 + * return + * try: + * link(self) # Must use Cython >= 0.23.4 on PyPy else this leaks memory # <<<<<<<<<<<<<< + * except: # pylint:disable=bare-except + * getcurrent().handle_error((link, self), *sys.exc_info()) + */ + __Pyx_INCREF(__pyx_v_link); + __pyx_t_3 = __pyx_v_link; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 101, __pyx_L12_error) + __Pyx_GOTREF(__pyx_t_2); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, ((PyObject *)__pyx_v_self)}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 101, __pyx_L12_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, ((PyObject *)__pyx_v_self)}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 101, __pyx_L12_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + { + __pyx_t_12 = PyTuple_New(1+1); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 101, __pyx_L12_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + PyTuple_SET_ITEM(__pyx_t_12, 0+1, ((PyObject *)__pyx_v_self)); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_12, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 101, __pyx_L12_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "gevent/_semaphore.py":100 + * if self.counter <= 0: + * return + * try: # <<<<<<<<<<<<<< + * link(self) # Must use Cython >= 0.23.4 on PyPy else this leaks memory + * except: # pylint:disable=bare-except + */ + } + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + goto __pyx_L19_try_end; + __pyx_L12_error:; + __Pyx_PyThreadState_assign + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "gevent/_semaphore.py":102 + * try: + * link(self) # Must use Cython >= 0.23.4 on PyPy else this leaks memory + * except: # pylint:disable=bare-except # <<<<<<<<<<<<<< + * getcurrent().handle_error((link, self), *sys.exc_info()) + * if self._dirty: + */ + /*except:*/ { + __Pyx_AddTraceback("gevent._semaphore.Semaphore._notify_links", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_3, &__pyx_t_12) < 0) __PYX_ERR(0, 102, __pyx_L14_except_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_t_12); + + /* "gevent/_semaphore.py":103 + * link(self) # Must use Cython >= 0.23.4 on PyPy else this leaks memory + * except: # pylint:disable=bare-except + * getcurrent().handle_error((link, self), *sys.exc_info()) # <<<<<<<<<<<<<< + * if self._dirty: + * # We mutated self._links so we need to start over + */ + __pyx_t_13 = __Pyx_GetModuleGlobalName(__pyx_n_s_getcurrent); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 103, __pyx_L14_except_error) + __Pyx_GOTREF(__pyx_t_13); + __pyx_t_14 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_13))) { + __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_13); + if (likely(__pyx_t_14)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13); + __Pyx_INCREF(__pyx_t_14); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_13, function); + } + } + if (__pyx_t_14) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_t_14); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 103, __pyx_L14_except_error) + __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + } else { + __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_13); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 103, __pyx_L14_except_error) + } + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_handle_error); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 103, __pyx_L14_except_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 103, __pyx_L14_except_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_v_link); + __Pyx_GIVEREF(__pyx_v_link); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_link); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + PyTuple_SET_ITEM(__pyx_t_4, 1, ((PyObject *)__pyx_v_self)); + __pyx_t_14 = PyTuple_New(1); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 103, __pyx_L14_except_error) + __Pyx_GOTREF(__pyx_t_14); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_15 = __Pyx_GetModuleGlobalName(__pyx_n_s_sys); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 103, __pyx_L14_except_error) + __Pyx_GOTREF(__pyx_t_15); + __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_t_15, __pyx_n_s_exc_info); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 103, __pyx_L14_except_error) + __Pyx_GOTREF(__pyx_t_16); + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __pyx_t_15 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_16))) { + __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_16); + if (likely(__pyx_t_15)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_16); + __Pyx_INCREF(__pyx_t_15); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_16, function); + } + } + if (__pyx_t_15) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_16, __pyx_t_15); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 103, __pyx_L14_except_error) + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + } else { + __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_16); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 103, __pyx_L14_except_error) + } + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __pyx_t_16 = PySequence_Tuple(__pyx_t_4); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 103, __pyx_L14_except_error) + __Pyx_GOTREF(__pyx_t_16); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyNumber_Add(__pyx_t_14, __pyx_t_16); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 103, __pyx_L14_except_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __pyx_t_16 = __Pyx_PyObject_Call(__pyx_t_13, __pyx_t_4, NULL); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 103, __pyx_L14_except_error) + __Pyx_GOTREF(__pyx_t_16); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + goto __pyx_L13_exception_handled; + } + __pyx_L14_except_error:; + + /* "gevent/_semaphore.py":100 + * if self.counter <= 0: + * return + * try: # <<<<<<<<<<<<<< + * link(self) # Must use Cython >= 0.23.4 on PyPy else this leaks memory + * except: # pylint:disable=bare-except + */ + __Pyx_PyThreadState_assign + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_XGIVEREF(__pyx_t_10); + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); + goto __pyx_L4_error; + __pyx_L13_exception_handled:; + __Pyx_PyThreadState_assign + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_XGIVEREF(__pyx_t_10); + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); + __pyx_L19_try_end:; + } + + /* "gevent/_semaphore.py":104 + * except: # pylint:disable=bare-except + * getcurrent().handle_error((link, self), *sys.exc_info()) + * if self._dirty: # <<<<<<<<<<<<<< + * # We mutated self._links so we need to start over + * break + */ + __pyx_t_6 = (__pyx_v_self->_dirty != 0); + if (__pyx_t_6) { + + /* "gevent/_semaphore.py":106 + * if self._dirty: + * # We mutated self._links so we need to start over + * break # <<<<<<<<<<<<<< + * if not self._dirty: + * return + */ + goto __pyx_L10_break; + + /* "gevent/_semaphore.py":104 + * except: # pylint:disable=bare-except + * getcurrent().handle_error((link, self), *sys.exc_info()) + * if self._dirty: # <<<<<<<<<<<<<< + * # We mutated self._links so we need to start over + * break + */ + } + + /* "gevent/_semaphore.py":97 + * # the callback. Which shouldn't happen + * return + * for link in self._links: # <<<<<<<<<<<<<< + * if self.counter <= 0: + * return + */ + } + __pyx_L10_break:; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "gevent/_semaphore.py":107 + * # We mutated self._links so we need to start over + * break + * if not self._dirty: # <<<<<<<<<<<<<< + * return + * finally: + */ + __pyx_t_6 = ((!(__pyx_v_self->_dirty != 0)) != 0); + if (__pyx_t_6) { + + /* "gevent/_semaphore.py":108 + * break + * if not self._dirty: + * return # <<<<<<<<<<<<<< + * finally: + * # We should not have created a new notifier even if callbacks + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L3_return; + + /* "gevent/_semaphore.py":107 + * # We mutated self._links so we need to start over + * break + * if not self._dirty: # <<<<<<<<<<<<<< + * return + * finally: + */ + } + } + } + + /* "gevent/_semaphore.py":113 + * # released us because we loop through *all* of our links on the + * # same callback while self._notifier is still true. + * assert self._notifier is notifier # <<<<<<<<<<<<<< + * self._notifier = None + * + */ + /*finally:*/ { + /*normal exit:*/{ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(!Py_OptimizeFlag)) { + __pyx_t_6 = (__pyx_v_self->_notifier == __pyx_v_notifier); + if (unlikely(!(__pyx_t_6 != 0))) { + PyErr_SetNone(PyExc_AssertionError); + __PYX_ERR(0, 113, __pyx_L1_error) + } + } + #endif + + /* "gevent/_semaphore.py":114 + * # same callback while self._notifier is still true. + * assert self._notifier is notifier + * self._notifier = None # <<<<<<<<<<<<<< + * + * def rawlink(self, callback): + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->_notifier); + __Pyx_DECREF(__pyx_v_self->_notifier); + __pyx_v_self->_notifier = Py_None; + goto __pyx_L5; + } + /*exception exit:*/{ + __Pyx_PyThreadState_declare + __pyx_L4_error:; + __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0; + __Pyx_PyThreadState_assign + __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_20, &__pyx_t_21, &__pyx_t_22); + if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_11, &__pyx_t_10, &__pyx_t_9) < 0)) __Pyx_ErrFetch(&__pyx_t_11, &__pyx_t_10, &__pyx_t_9); + __Pyx_XGOTREF(__pyx_t_11); + __Pyx_XGOTREF(__pyx_t_10); + __Pyx_XGOTREF(__pyx_t_9); + __Pyx_XGOTREF(__pyx_t_20); + __Pyx_XGOTREF(__pyx_t_21); + __Pyx_XGOTREF(__pyx_t_22); + __pyx_t_17 = __pyx_lineno; __pyx_t_18 = __pyx_clineno; __pyx_t_19 = __pyx_filename; + { + + /* "gevent/_semaphore.py":113 + * # released us because we loop through *all* of our links on the + * # same callback while self._notifier is still true. + * assert self._notifier is notifier # <<<<<<<<<<<<<< + * self._notifier = None + * + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(!Py_OptimizeFlag)) { + __pyx_t_6 = (__pyx_v_self->_notifier == __pyx_v_notifier); + if (unlikely(!(__pyx_t_6 != 0))) { + PyErr_SetNone(PyExc_AssertionError); + __PYX_ERR(0, 113, __pyx_L25_error) + } + } + #endif + + /* "gevent/_semaphore.py":114 + * # same callback while self._notifier is still true. + * assert self._notifier is notifier + * self._notifier = None # <<<<<<<<<<<<<< + * + * def rawlink(self, callback): + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->_notifier); + __Pyx_DECREF(__pyx_v_self->_notifier); + __pyx_v_self->_notifier = Py_None; + } + __Pyx_PyThreadState_assign + if (PY_MAJOR_VERSION >= 3) { + __Pyx_XGIVEREF(__pyx_t_20); + __Pyx_XGIVEREF(__pyx_t_21); + __Pyx_XGIVEREF(__pyx_t_22); + __Pyx_ExceptionReset(__pyx_t_20, __pyx_t_21, __pyx_t_22); + } + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_XGIVEREF(__pyx_t_10); + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_ErrRestore(__pyx_t_11, __pyx_t_10, __pyx_t_9); + __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0; + __pyx_lineno = __pyx_t_17; __pyx_clineno = __pyx_t_18; __pyx_filename = __pyx_t_19; + goto __pyx_L1_error; + __pyx_L25_error:; + __Pyx_PyThreadState_assign + if (PY_MAJOR_VERSION >= 3) { + __Pyx_XGIVEREF(__pyx_t_20); + __Pyx_XGIVEREF(__pyx_t_21); + __Pyx_XGIVEREF(__pyx_t_22); + __Pyx_ExceptionReset(__pyx_t_20, __pyx_t_21, __pyx_t_22); + } + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0; + goto __pyx_L1_error; + } + __pyx_L3_return: { + __pyx_t_22 = __pyx_r; + __pyx_r = 0; + + /* "gevent/_semaphore.py":113 + * # released us because we loop through *all* of our links on the + * # same callback while self._notifier is still true. + * assert self._notifier is notifier # <<<<<<<<<<<<<< + * self._notifier = None + * + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(!Py_OptimizeFlag)) { + __pyx_t_6 = (__pyx_v_self->_notifier == __pyx_v_notifier); + if (unlikely(!(__pyx_t_6 != 0))) { + PyErr_SetNone(PyExc_AssertionError); + __PYX_ERR(0, 113, __pyx_L1_error) + } + } + #endif + + /* "gevent/_semaphore.py":114 + * # same callback while self._notifier is still true. + * assert self._notifier is notifier + * self._notifier = None # <<<<<<<<<<<<<< + * + * def rawlink(self, callback): + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->_notifier); + __Pyx_DECREF(__pyx_v_self->_notifier); + __pyx_v_self->_notifier = Py_None; + __pyx_r = __pyx_t_22; + __pyx_t_22 = 0; + goto __pyx_L0; + } + __pyx_L5:; + } + + /* "gevent/_semaphore.py":80 + * self._notifier = get_hub().loop.run_callback(self._notify_links) + * + * def _notify_links(self): # <<<<<<<<<<<<<< + * # Subclasses CANNOT override. This is a cdef method. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_XDECREF(__pyx_t_13); + __Pyx_XDECREF(__pyx_t_14); + __Pyx_XDECREF(__pyx_t_15); + __Pyx_XDECREF(__pyx_t_16); + __Pyx_AddTraceback("gevent._semaphore.Semaphore._notify_links", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_notifier); + __Pyx_XDECREF(__pyx_v_link); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_10_semaphore_9Semaphore_11_notify_links(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyMethodDef __pyx_mdef_6gevent_10_semaphore_9Semaphore_11_notify_links = {"_notify_links", (PyCFunction)__pyx_pw_6gevent_10_semaphore_9Semaphore_11_notify_links, METH_NOARGS, 0}; +static PyObject *__pyx_pw_6gevent_10_semaphore_9Semaphore_11_notify_links(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_notify_links (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_10_semaphore_9Semaphore_10_notify_links(((struct __pyx_obj_6gevent_10_semaphore_Semaphore *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_10_semaphore_9Semaphore_10_notify_links(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("_notify_links", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_6gevent_10_semaphore_9Semaphore__notify_links(__pyx_v_self, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 80, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent._semaphore.Semaphore._notify_links", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "gevent/_semaphore.py":116 + * self._notifier = None + * + * def rawlink(self, callback): # <<<<<<<<<<<<<< + * """ + * rawlink(callback) -> None + */ + +static PyObject *__pyx_pw_6gevent_10_semaphore_9Semaphore_13rawlink(PyObject *__pyx_v_self, PyObject *__pyx_v_callback); /*proto*/ +static PyObject *__pyx_f_6gevent_10_semaphore_9Semaphore_rawlink(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self, PyObject *__pyx_v_callback, int __pyx_skip_dispatch) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + int __pyx_t_7; + int __pyx_t_8; + __Pyx_RefNannySetupContext("rawlink", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_rawlink); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 116, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_6gevent_10_semaphore_9Semaphore_13rawlink)) { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_callback); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 116, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_callback}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 116, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_callback}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 116, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + { + __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 116, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_INCREF(__pyx_v_callback); + __Pyx_GIVEREF(__pyx_v_callback); + PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_v_callback); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 116, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "gevent/_semaphore.py":128 + * will not need to use it. + * """ + * if not callable(callback): # <<<<<<<<<<<<<< + * raise TypeError('Expected callable:', callback) + * if self._links is None: + */ + __pyx_t_6 = __Pyx_PyCallable_Check(__pyx_v_callback); if (unlikely(__pyx_t_6 == -1)) __PYX_ERR(0, 128, __pyx_L1_error) + __pyx_t_7 = ((!(__pyx_t_6 != 0)) != 0); + if (__pyx_t_7) { + + /* "gevent/_semaphore.py":129 + * """ + * if not callable(callback): + * raise TypeError('Expected callable:', callback) # <<<<<<<<<<<<<< + * if self._links is None: + * self._links = [callback] + */ + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 129, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_kp_s_Expected_callable); + __Pyx_GIVEREF(__pyx_kp_s_Expected_callable); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_kp_s_Expected_callable); + __Pyx_INCREF(__pyx_v_callback); + __Pyx_GIVEREF(__pyx_v_callback); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_callback); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 129, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 129, __pyx_L1_error) + + /* "gevent/_semaphore.py":128 + * will not need to use it. + * """ + * if not callable(callback): # <<<<<<<<<<<<<< + * raise TypeError('Expected callable:', callback) + * if self._links is None: + */ + } + + /* "gevent/_semaphore.py":130 + * if not callable(callback): + * raise TypeError('Expected callable:', callback) + * if self._links is None: # <<<<<<<<<<<<<< + * self._links = [callback] + * else: + */ + __pyx_t_7 = (__pyx_v_self->_links == Py_None); + __pyx_t_6 = (__pyx_t_7 != 0); + if (__pyx_t_6) { + + /* "gevent/_semaphore.py":131 + * raise TypeError('Expected callable:', callback) + * if self._links is None: + * self._links = [callback] # <<<<<<<<<<<<<< + * else: + * self._links.append(callback) + */ + __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_v_callback); + __Pyx_GIVEREF(__pyx_v_callback); + PyList_SET_ITEM(__pyx_t_2, 0, __pyx_v_callback); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_self->_links); + __Pyx_DECREF(__pyx_v_self->_links); + __pyx_v_self->_links = __pyx_t_2; + __pyx_t_2 = 0; + + /* "gevent/_semaphore.py":130 + * if not callable(callback): + * raise TypeError('Expected callable:', callback) + * if self._links is None: # <<<<<<<<<<<<<< + * self._links = [callback] + * else: + */ + goto __pyx_L4; + } + + /* "gevent/_semaphore.py":133 + * self._links = [callback] + * else: + * self._links.append(callback) # <<<<<<<<<<<<<< + * self._dirty = True + * + */ + /*else*/ { + __pyx_t_8 = __Pyx_PyObject_Append(__pyx_v_self->_links, __pyx_v_callback); if (unlikely(__pyx_t_8 == -1)) __PYX_ERR(0, 133, __pyx_L1_error) + } + __pyx_L4:; + + /* "gevent/_semaphore.py":134 + * else: + * self._links.append(callback) + * self._dirty = True # <<<<<<<<<<<<<< + * + * def unlink(self, callback): + */ + __pyx_v_self->_dirty = 1; + + /* "gevent/_semaphore.py":116 + * self._notifier = None + * + * def rawlink(self, callback): # <<<<<<<<<<<<<< + * """ + * rawlink(callback) -> None + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("gevent._semaphore.Semaphore.rawlink", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_10_semaphore_9Semaphore_13rawlink(PyObject *__pyx_v_self, PyObject *__pyx_v_callback); /*proto*/ +static char __pyx_doc_6gevent_10_semaphore_9Semaphore_12rawlink[] = "\n rawlink(callback) -> None\n\n Register a callback to call when a counter is more than zero.\n\n *callback* will be called in the :class:`Hub `, so it must not use blocking gevent API.\n *callback* will be passed one argument: this instance.\n\n This method is normally called automatically by :meth:`acquire` and :meth:`wait`; most code\n will not need to use it.\n "; +static PyMethodDef __pyx_mdef_6gevent_10_semaphore_9Semaphore_13rawlink = {"rawlink", (PyCFunction)__pyx_pw_6gevent_10_semaphore_9Semaphore_13rawlink, METH_O, __pyx_doc_6gevent_10_semaphore_9Semaphore_12rawlink}; +static PyObject *__pyx_pw_6gevent_10_semaphore_9Semaphore_13rawlink(PyObject *__pyx_v_self, PyObject *__pyx_v_callback) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("rawlink (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_10_semaphore_9Semaphore_12rawlink(((struct __pyx_obj_6gevent_10_semaphore_Semaphore *)__pyx_v_self), ((PyObject *)__pyx_v_callback)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_10_semaphore_9Semaphore_12rawlink(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self, PyObject *__pyx_v_callback) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("rawlink", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_6gevent_10_semaphore_9Semaphore_rawlink(__pyx_v_self, __pyx_v_callback, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 116, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent._semaphore.Semaphore.rawlink", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "gevent/_semaphore.py":136 + * self._dirty = True + * + * def unlink(self, callback): # <<<<<<<<<<<<<< + * """ + * unlink(callback) -> None + */ + +static PyObject *__pyx_pw_6gevent_10_semaphore_9Semaphore_15unlink(PyObject *__pyx_v_self, PyObject *__pyx_v_callback); /*proto*/ +static PyObject *__pyx_f_6gevent_10_semaphore_9Semaphore_unlink(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self, PyObject *__pyx_v_callback, int __pyx_skip_dispatch) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_t_9; + int __pyx_t_10; + int __pyx_t_11; + __Pyx_RefNannySetupContext("unlink", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_unlink); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_6gevent_10_semaphore_9Semaphore_15unlink)) { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_callback); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_callback}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_callback}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + { + __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_INCREF(__pyx_v_callback); + __Pyx_GIVEREF(__pyx_v_callback); + PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_v_callback); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "gevent/_semaphore.py":145 + * code will not need to use it. + * """ + * try: # <<<<<<<<<<<<<< + * self._links.remove(callback) + * self._dirty = True + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_6, &__pyx_t_7, &__pyx_t_8); + __Pyx_XGOTREF(__pyx_t_6); + __Pyx_XGOTREF(__pyx_t_7); + __Pyx_XGOTREF(__pyx_t_8); + /*try:*/ { + + /* "gevent/_semaphore.py":146 + * """ + * try: + * self._links.remove(callback) # <<<<<<<<<<<<<< + * self._dirty = True + * except (ValueError, AttributeError): + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_links, __pyx_n_s_remove); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 146, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (!__pyx_t_3) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_callback); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 146, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_callback}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 146, __pyx_L3_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_callback}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 146, __pyx_L3_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 146, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = NULL; + __Pyx_INCREF(__pyx_v_callback); + __Pyx_GIVEREF(__pyx_v_callback); + PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_v_callback); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 146, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "gevent/_semaphore.py":147 + * try: + * self._links.remove(callback) + * self._dirty = True # <<<<<<<<<<<<<< + * except (ValueError, AttributeError): + * pass + */ + __pyx_v_self->_dirty = 1; + + /* "gevent/_semaphore.py":145 + * code will not need to use it. + * """ + * try: # <<<<<<<<<<<<<< + * self._links.remove(callback) + * self._dirty = True + */ + } + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + goto __pyx_L10_try_end; + __pyx_L3_error:; + __Pyx_PyThreadState_assign + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "gevent/_semaphore.py":148 + * self._links.remove(callback) + * self._dirty = True + * except (ValueError, AttributeError): # <<<<<<<<<<<<<< + * pass + * if not self._links: + */ + __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_ValueError) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_AttributeError); + if (__pyx_t_9) { + __Pyx_ErrRestore(0,0,0); + goto __pyx_L4_exception_handled; + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; + + /* "gevent/_semaphore.py":145 + * code will not need to use it. + * """ + * try: # <<<<<<<<<<<<<< + * self._links.remove(callback) + * self._dirty = True + */ + __Pyx_PyThreadState_assign + __Pyx_XGIVEREF(__pyx_t_6); + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8); + goto __pyx_L1_error; + __pyx_L4_exception_handled:; + __Pyx_PyThreadState_assign + __Pyx_XGIVEREF(__pyx_t_6); + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8); + __pyx_L10_try_end:; + } + + /* "gevent/_semaphore.py":150 + * except (ValueError, AttributeError): + * pass + * if not self._links: # <<<<<<<<<<<<<< + * self._links = None + * # TODO: Cancel a notifier if there are no links? + */ + __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_v_self->_links); if (unlikely(__pyx_t_10 < 0)) __PYX_ERR(0, 150, __pyx_L1_error) + __pyx_t_11 = ((!__pyx_t_10) != 0); + if (__pyx_t_11) { + + /* "gevent/_semaphore.py":151 + * pass + * if not self._links: + * self._links = None # <<<<<<<<<<<<<< + * # TODO: Cancel a notifier if there are no links? + * + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->_links); + __Pyx_DECREF(__pyx_v_self->_links); + __pyx_v_self->_links = Py_None; + + /* "gevent/_semaphore.py":150 + * except (ValueError, AttributeError): + * pass + * if not self._links: # <<<<<<<<<<<<<< + * self._links = None + * # TODO: Cancel a notifier if there are no links? + */ + } + + /* "gevent/_semaphore.py":136 + * self._dirty = True + * + * def unlink(self, callback): # <<<<<<<<<<<<<< + * """ + * unlink(callback) -> None + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("gevent._semaphore.Semaphore.unlink", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_10_semaphore_9Semaphore_15unlink(PyObject *__pyx_v_self, PyObject *__pyx_v_callback); /*proto*/ +static char __pyx_doc_6gevent_10_semaphore_9Semaphore_14unlink[] = "\n unlink(callback) -> None\n\n Remove the callback set by :meth:`rawlink`.\n\n This method is normally called automatically by :meth:`acquire` and :meth:`wait`; most\n code will not need to use it.\n "; +static PyMethodDef __pyx_mdef_6gevent_10_semaphore_9Semaphore_15unlink = {"unlink", (PyCFunction)__pyx_pw_6gevent_10_semaphore_9Semaphore_15unlink, METH_O, __pyx_doc_6gevent_10_semaphore_9Semaphore_14unlink}; +static PyObject *__pyx_pw_6gevent_10_semaphore_9Semaphore_15unlink(PyObject *__pyx_v_self, PyObject *__pyx_v_callback) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("unlink (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_10_semaphore_9Semaphore_14unlink(((struct __pyx_obj_6gevent_10_semaphore_Semaphore *)__pyx_v_self), ((PyObject *)__pyx_v_callback)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_10_semaphore_9Semaphore_14unlink(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self, PyObject *__pyx_v_callback) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("unlink", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_6gevent_10_semaphore_9Semaphore_unlink(__pyx_v_self, __pyx_v_callback, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent._semaphore.Semaphore.unlink", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "gevent/_semaphore.py":154 + * # TODO: Cancel a notifier if there are no links? + * + * def _do_wait(self, timeout): # <<<<<<<<<<<<<< + * """ + * Wait for up to *timeout* seconds to expire. If timeout + */ + +static PyObject *__pyx_f_6gevent_10_semaphore_9Semaphore__do_wait(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self, PyObject *__pyx_v_timeout) { + PyObject *__pyx_v_switch = NULL; + PyObject *__pyx_v_timer = NULL; + PyObject *__pyx_v_result = NULL; + PyObject *__pyx_v_ex = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + int __pyx_t_9; + int __pyx_t_10; + int __pyx_t_11; + char const *__pyx_t_12; + PyObject *__pyx_t_13 = NULL; + PyObject *__pyx_t_14 = NULL; + PyObject *__pyx_t_15 = NULL; + char const *__pyx_t_16; + __Pyx_RefNannySetupContext("_do_wait", 0); + + /* "gevent/_semaphore.py":160 + * Raises timeout if a different timer expires. + * """ + * switch = getcurrent().switch # <<<<<<<<<<<<<< + * self.rawlink(switch) + * try: + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_getcurrent); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 160, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (__pyx_t_3) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 160, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 160, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_switch); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 160, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_switch = __pyx_t_2; + __pyx_t_2 = 0; + + /* "gevent/_semaphore.py":161 + * """ + * switch = getcurrent().switch + * self.rawlink(switch) # <<<<<<<<<<<<<< + * try: + * timer = Timeout._start_new_or_dummy(timeout) + */ + __pyx_t_2 = ((struct __pyx_vtabstruct_6gevent_10_semaphore_Semaphore *)__pyx_v_self->__pyx_vtab)->rawlink(__pyx_v_self, __pyx_v_switch, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 161, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "gevent/_semaphore.py":162 + * switch = getcurrent().switch + * self.rawlink(switch) + * try: # <<<<<<<<<<<<<< + * timer = Timeout._start_new_or_dummy(timeout) + * try: + */ + /*try:*/ { + + /* "gevent/_semaphore.py":163 + * self.rawlink(switch) + * try: + * timer = Timeout._start_new_or_dummy(timeout) # <<<<<<<<<<<<<< + * try: + * try: + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_Timeout); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 163, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_start_new_or_dummy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 163, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_1) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_timeout); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 163, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_1, __pyx_v_timeout}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 163, __pyx_L4_error) + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_1, __pyx_v_timeout}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 163, __pyx_L4_error) + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + { + __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 163, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); __pyx_t_1 = NULL; + __Pyx_INCREF(__pyx_v_timeout); + __Pyx_GIVEREF(__pyx_v_timeout); + PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_v_timeout); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 163, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_timer = __pyx_t_2; + __pyx_t_2 = 0; + + /* "gevent/_semaphore.py":164 + * try: + * timer = Timeout._start_new_or_dummy(timeout) + * try: # <<<<<<<<<<<<<< + * try: + * result = get_hub().switch() + */ + /*try:*/ { + + /* "gevent/_semaphore.py":165 + * timer = Timeout._start_new_or_dummy(timeout) + * try: + * try: # <<<<<<<<<<<<<< + * result = get_hub().switch() + * assert result is self, 'Invalid switch into Semaphore.wait/acquire(): %r' % (result, ) + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7); + __Pyx_XGOTREF(__pyx_t_5); + __Pyx_XGOTREF(__pyx_t_6); + __Pyx_XGOTREF(__pyx_t_7); + /*try:*/ { + + /* "gevent/_semaphore.py":166 + * try: + * try: + * result = get_hub().switch() # <<<<<<<<<<<<<< + * assert result is self, 'Invalid switch into Semaphore.wait/acquire(): %r' % (result, ) + * except Timeout as ex: + */ + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_get_hub); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 166, __pyx_L9_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (__pyx_t_1) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 166, __pyx_L9_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else { + __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 166, __pyx_L9_error) + } + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_switch); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 166, __pyx_L9_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (__pyx_t_3) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 166, __pyx_L9_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 166, __pyx_L9_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_result = __pyx_t_2; + __pyx_t_2 = 0; + + /* "gevent/_semaphore.py":167 + * try: + * result = get_hub().switch() + * assert result is self, 'Invalid switch into Semaphore.wait/acquire(): %r' % (result, ) # <<<<<<<<<<<<<< + * except Timeout as ex: + * if ex is not timer: + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(!Py_OptimizeFlag)) { + __pyx_t_8 = (__pyx_v_result == ((PyObject *)__pyx_v_self)); + if (unlikely(!(__pyx_t_8 != 0))) { + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 167, __pyx_L9_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_v_result); + __Pyx_GIVEREF(__pyx_v_result); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_result); + __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Invalid_switch_into_Semaphore_wa, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 167, __pyx_L9_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyErr_SetObject(PyExc_AssertionError, __pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(0, 167, __pyx_L9_error) + } + } + #endif + + /* "gevent/_semaphore.py":165 + * timer = Timeout._start_new_or_dummy(timeout) + * try: + * try: # <<<<<<<<<<<<<< + * result = get_hub().switch() + * assert result is self, 'Invalid switch into Semaphore.wait/acquire(): %r' % (result, ) + */ + } + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + goto __pyx_L16_try_end; + __pyx_L9_error:; + __Pyx_PyThreadState_assign + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "gevent/_semaphore.py":168 + * result = get_hub().switch() + * assert result is self, 'Invalid switch into Semaphore.wait/acquire(): %r' % (result, ) + * except Timeout as ex: # <<<<<<<<<<<<<< + * if ex is not timer: + * raise + */ + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_Timeout); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 168, __pyx_L11_except_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_9) { + __Pyx_AddTraceback("gevent._semaphore.Semaphore._do_wait", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_2, &__pyx_t_3) < 0) __PYX_ERR(0, 168, __pyx_L11_except_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __pyx_v_ex = __pyx_t_2; + + /* "gevent/_semaphore.py":169 + * assert result is self, 'Invalid switch into Semaphore.wait/acquire(): %r' % (result, ) + * except Timeout as ex: + * if ex is not timer: # <<<<<<<<<<<<<< + * raise + * return ex + */ + __pyx_t_8 = (__pyx_v_ex != __pyx_v_timer); + __pyx_t_10 = (__pyx_t_8 != 0); + if (__pyx_t_10) { + + /* "gevent/_semaphore.py":170 + * except Timeout as ex: + * if ex is not timer: + * raise # <<<<<<<<<<<<<< + * return ex + * finally: + */ + __Pyx_GIVEREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ErrRestoreWithState(__pyx_t_4, __pyx_t_2, __pyx_t_3); + __pyx_t_4 = 0; __pyx_t_2 = 0; __pyx_t_3 = 0; + __PYX_ERR(0, 170, __pyx_L11_except_error) + + /* "gevent/_semaphore.py":169 + * assert result is self, 'Invalid switch into Semaphore.wait/acquire(): %r' % (result, ) + * except Timeout as ex: + * if ex is not timer: # <<<<<<<<<<<<<< + * raise + * return ex + */ + } + + /* "gevent/_semaphore.py":171 + * if ex is not timer: + * raise + * return ex # <<<<<<<<<<<<<< + * finally: + * timer.cancel() + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_ex); + __pyx_r = __pyx_v_ex; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + goto __pyx_L12_except_return; + } + goto __pyx_L11_except_error; + __pyx_L11_except_error:; + + /* "gevent/_semaphore.py":165 + * timer = Timeout._start_new_or_dummy(timeout) + * try: + * try: # <<<<<<<<<<<<<< + * result = get_hub().switch() + * assert result is self, 'Invalid switch into Semaphore.wait/acquire(): %r' % (result, ) + */ + __Pyx_PyThreadState_assign + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_XGIVEREF(__pyx_t_6); + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_ExceptionReset(__pyx_t_5, __pyx_t_6, __pyx_t_7); + goto __pyx_L7_error; + __pyx_L12_except_return:; + __Pyx_PyThreadState_assign + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_XGIVEREF(__pyx_t_6); + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_ExceptionReset(__pyx_t_5, __pyx_t_6, __pyx_t_7); + goto __pyx_L6_return; + __pyx_L16_try_end:; + } + } + + /* "gevent/_semaphore.py":173 + * return ex + * finally: + * timer.cancel() # <<<<<<<<<<<<<< + * finally: + * self.unlink(switch) + */ + /*finally:*/ { + /*normal exit:*/{ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_timer, __pyx_n_s_cancel); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 173, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (__pyx_t_4) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 173, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 173, __pyx_L4_error) + } + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L8; + } + /*exception exit:*/{ + __Pyx_PyThreadState_declare + __pyx_L7_error:; + __pyx_t_7 = 0; __pyx_t_6 = 0; __pyx_t_5 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; + __Pyx_PyThreadState_assign + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_13, &__pyx_t_14, &__pyx_t_15); + if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_7, &__pyx_t_6, &__pyx_t_5) < 0)) __Pyx_ErrFetch(&__pyx_t_7, &__pyx_t_6, &__pyx_t_5); + __Pyx_XGOTREF(__pyx_t_7); + __Pyx_XGOTREF(__pyx_t_6); + __Pyx_XGOTREF(__pyx_t_5); + __Pyx_XGOTREF(__pyx_t_13); + __Pyx_XGOTREF(__pyx_t_14); + __Pyx_XGOTREF(__pyx_t_15); + __pyx_t_9 = __pyx_lineno; __pyx_t_11 = __pyx_clineno; __pyx_t_12 = __pyx_filename; + { + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_timer, __pyx_n_s_cancel); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 173, __pyx_L21_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (__pyx_t_4) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 173, __pyx_L21_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 173, __pyx_L21_error) + } + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_PyThreadState_assign + if (PY_MAJOR_VERSION >= 3) { + __Pyx_XGIVEREF(__pyx_t_13); + __Pyx_XGIVEREF(__pyx_t_14); + __Pyx_XGIVEREF(__pyx_t_15); + __Pyx_ExceptionReset(__pyx_t_13, __pyx_t_14, __pyx_t_15); + } + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_6); + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_ErrRestore(__pyx_t_7, __pyx_t_6, __pyx_t_5); + __pyx_t_7 = 0; __pyx_t_6 = 0; __pyx_t_5 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; + __pyx_lineno = __pyx_t_9; __pyx_clineno = __pyx_t_11; __pyx_filename = __pyx_t_12; + goto __pyx_L4_error; + __pyx_L21_error:; + __Pyx_PyThreadState_assign + if (PY_MAJOR_VERSION >= 3) { + __Pyx_XGIVEREF(__pyx_t_13); + __Pyx_XGIVEREF(__pyx_t_14); + __Pyx_XGIVEREF(__pyx_t_15); + __Pyx_ExceptionReset(__pyx_t_13, __pyx_t_14, __pyx_t_15); + } + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; + goto __pyx_L4_error; + } + __pyx_L6_return: { + __pyx_t_15 = __pyx_r; + __pyx_r = 0; + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_timer, __pyx_n_s_cancel); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 173, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (__pyx_t_4) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 173, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 173, __pyx_L4_error) + } + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_15; + __pyx_t_15 = 0; + goto __pyx_L3_return; + } + __pyx_L8:; + } + } + + /* "gevent/_semaphore.py":175 + * timer.cancel() + * finally: + * self.unlink(switch) # <<<<<<<<<<<<<< + * + * def wait(self, timeout=None): + */ + /*finally:*/ { + /*normal exit:*/{ + __pyx_t_3 = ((struct __pyx_vtabstruct_6gevent_10_semaphore_Semaphore *)__pyx_v_self->__pyx_vtab)->unlink(__pyx_v_self, __pyx_v_switch, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 175, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L5; + } + /*exception exit:*/{ + __Pyx_PyThreadState_declare + __pyx_L4_error:; + __pyx_t_15 = 0; __pyx_t_14 = 0; __pyx_t_13 = 0; __pyx_t_5 = 0; __pyx_t_6 = 0; __pyx_t_7 = 0; + __Pyx_PyThreadState_assign + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7); + if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_15, &__pyx_t_14, &__pyx_t_13) < 0)) __Pyx_ErrFetch(&__pyx_t_15, &__pyx_t_14, &__pyx_t_13); + __Pyx_XGOTREF(__pyx_t_15); + __Pyx_XGOTREF(__pyx_t_14); + __Pyx_XGOTREF(__pyx_t_13); + __Pyx_XGOTREF(__pyx_t_5); + __Pyx_XGOTREF(__pyx_t_6); + __Pyx_XGOTREF(__pyx_t_7); + __pyx_t_11 = __pyx_lineno; __pyx_t_9 = __pyx_clineno; __pyx_t_16 = __pyx_filename; + { + __pyx_t_3 = ((struct __pyx_vtabstruct_6gevent_10_semaphore_Semaphore *)__pyx_v_self->__pyx_vtab)->unlink(__pyx_v_self, __pyx_v_switch, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 175, __pyx_L23_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_PyThreadState_assign + if (PY_MAJOR_VERSION >= 3) { + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_XGIVEREF(__pyx_t_6); + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_ExceptionReset(__pyx_t_5, __pyx_t_6, __pyx_t_7); + } + __Pyx_XGIVEREF(__pyx_t_15); + __Pyx_XGIVEREF(__pyx_t_14); + __Pyx_XGIVEREF(__pyx_t_13); + __Pyx_ErrRestore(__pyx_t_15, __pyx_t_14, __pyx_t_13); + __pyx_t_15 = 0; __pyx_t_14 = 0; __pyx_t_13 = 0; __pyx_t_5 = 0; __pyx_t_6 = 0; __pyx_t_7 = 0; + __pyx_lineno = __pyx_t_11; __pyx_clineno = __pyx_t_9; __pyx_filename = __pyx_t_16; + goto __pyx_L1_error; + __pyx_L23_error:; + __Pyx_PyThreadState_assign + if (PY_MAJOR_VERSION >= 3) { + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_XGIVEREF(__pyx_t_6); + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_ExceptionReset(__pyx_t_5, __pyx_t_6, __pyx_t_7); + } + __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + __pyx_t_5 = 0; __pyx_t_6 = 0; __pyx_t_7 = 0; + goto __pyx_L1_error; + } + __pyx_L3_return: { + __pyx_t_7 = __pyx_r; + __pyx_r = 0; + __pyx_t_3 = ((struct __pyx_vtabstruct_6gevent_10_semaphore_Semaphore *)__pyx_v_self->__pyx_vtab)->unlink(__pyx_v_self, __pyx_v_switch, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 175, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_7; + __pyx_t_7 = 0; + goto __pyx_L0; + } + __pyx_L5:; + } + + /* "gevent/_semaphore.py":154 + * # TODO: Cancel a notifier if there are no links? + * + * def _do_wait(self, timeout): # <<<<<<<<<<<<<< + * """ + * Wait for up to *timeout* seconds to expire. If timeout + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("gevent._semaphore.Semaphore._do_wait", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_switch); + __Pyx_XDECREF(__pyx_v_timer); + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XDECREF(__pyx_v_ex); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "gevent/_semaphore.py":177 + * self.unlink(switch) + * + * def wait(self, timeout=None): # <<<<<<<<<<<<<< + * """ + * wait(timeout=None) -> int + */ + +static PyObject *__pyx_pw_6gevent_10_semaphore_9Semaphore_17wait(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_f_6gevent_10_semaphore_9Semaphore_wait(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self, int __pyx_skip_dispatch, struct __pyx_opt_args_6gevent_10_semaphore_9Semaphore_wait *__pyx_optional_args) { + PyObject *__pyx_v_timeout = ((PyObject *)Py_None); + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + int __pyx_t_7; + __Pyx_RefNannySetupContext("wait", 0); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_timeout = __pyx_optional_args->timeout; + } + } + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_wait); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_6gevent_10_semaphore_9Semaphore_17wait)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_timeout); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_timeout}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 177, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_timeout}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 177, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + { + __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_INCREF(__pyx_v_timeout); + __Pyx_GIVEREF(__pyx_v_timeout); + PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_v_timeout); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 177, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_6; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "gevent/_semaphore.py":192 + * before blocking. + * """ + * if self.counter > 0: # <<<<<<<<<<<<<< + * return self.counter + * + */ + __pyx_t_7 = ((__pyx_v_self->counter > 0) != 0); + if (__pyx_t_7) { + + /* "gevent/_semaphore.py":193 + * """ + * if self.counter > 0: + * return self.counter # <<<<<<<<<<<<<< + * + * self._do_wait(timeout) # return value irrelevant, whether we got it or got a timeout + */ + __pyx_r = __pyx_v_self->counter; + goto __pyx_L0; + + /* "gevent/_semaphore.py":192 + * before blocking. + * """ + * if self.counter > 0: # <<<<<<<<<<<<<< + * return self.counter + * + */ + } + + /* "gevent/_semaphore.py":195 + * return self.counter + * + * self._do_wait(timeout) # return value irrelevant, whether we got it or got a timeout # <<<<<<<<<<<<<< + * return self.counter + * + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_6gevent_10_semaphore_Semaphore *)__pyx_v_self->__pyx_vtab)->_do_wait(__pyx_v_self, __pyx_v_timeout); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 195, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "gevent/_semaphore.py":196 + * + * self._do_wait(timeout) # return value irrelevant, whether we got it or got a timeout + * return self.counter # <<<<<<<<<<<<<< + * + * def acquire(self, blocking=True, timeout=None): + */ + __pyx_r = __pyx_v_self->counter; + goto __pyx_L0; + + /* "gevent/_semaphore.py":177 + * self.unlink(switch) + * + * def wait(self, timeout=None): # <<<<<<<<<<<<<< + * """ + * wait(timeout=None) -> int + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("gevent._semaphore.Semaphore.wait", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1000; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_10_semaphore_9Semaphore_17wait(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_6gevent_10_semaphore_9Semaphore_16wait[] = "\n wait(timeout=None) -> int\n\n Wait until it is possible to acquire this semaphore, or until the optional\n *timeout* elapses.\n\n .. caution:: If this semaphore was initialized with a size of 0,\n this method will block forever if no timeout is given.\n\n :keyword float timeout: If given, specifies the maximum amount of seconds\n this method will block.\n :return: A number indicating how many times the semaphore can be acquired\n before blocking.\n "; +static PyMethodDef __pyx_mdef_6gevent_10_semaphore_9Semaphore_17wait = {"wait", (PyCFunction)__pyx_pw_6gevent_10_semaphore_9Semaphore_17wait, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6gevent_10_semaphore_9Semaphore_16wait}; +static PyObject *__pyx_pw_6gevent_10_semaphore_9Semaphore_17wait(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_timeout = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("wait (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_timeout,0}; + PyObject* values[1] = {0}; + values[0] = ((PyObject *)Py_None); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_timeout); + if (value) { values[0] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "wait") < 0)) __PYX_ERR(0, 177, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_timeout = values[0]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("wait", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 177, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("gevent._semaphore.Semaphore.wait", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_10_semaphore_9Semaphore_16wait(((struct __pyx_obj_6gevent_10_semaphore_Semaphore *)__pyx_v_self), __pyx_v_timeout); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_10_semaphore_9Semaphore_16wait(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self, PyObject *__pyx_v_timeout) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + struct __pyx_opt_args_6gevent_10_semaphore_9Semaphore_wait __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("wait", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_2.__pyx_n = 1; + __pyx_t_2.timeout = __pyx_v_timeout; + __pyx_t_1 = __pyx_vtabptr_6gevent_10_semaphore_Semaphore->wait(__pyx_v_self, 1, &__pyx_t_2); if (unlikely(__pyx_t_1 == -1000)) __PYX_ERR(0, 177, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("gevent._semaphore.Semaphore.wait", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "gevent/_semaphore.py":198 + * return self.counter + * + * def acquire(self, blocking=True, timeout=None): # <<<<<<<<<<<<<< + * """ + * acquire(blocking=True, timeout=None) -> bool + */ + +static PyObject *__pyx_pw_6gevent_10_semaphore_9Semaphore_19acquire(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_f_6gevent_10_semaphore_9Semaphore_acquire(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self, int __pyx_skip_dispatch, struct __pyx_opt_args_6gevent_10_semaphore_9Semaphore_acquire *__pyx_optional_args) { + int __pyx_v_blocking = ((int)1); + PyObject *__pyx_v_timeout = ((PyObject *)Py_None); + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + int __pyx_t_9; + __Pyx_RefNannySetupContext("acquire", 0); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_blocking = __pyx_optional_args->blocking; + if (__pyx_optional_args->__pyx_n > 1) { + __pyx_v_timeout = __pyx_optional_args->timeout; + } + } + } + __Pyx_INCREF(__pyx_v_timeout); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_acquire); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 198, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_6gevent_10_semaphore_9Semaphore_19acquire)) { + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_blocking); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 198, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_t_1); + __pyx_t_4 = __pyx_t_1; __pyx_t_5 = NULL; + __pyx_t_6 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_6 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_3, __pyx_v_timeout}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 198, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_3, __pyx_v_timeout}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 198, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + { + __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 198, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__pyx_t_5) { + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL; + } + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_t_3); + __Pyx_INCREF(__pyx_v_timeout); + __Pyx_GIVEREF(__pyx_v_timeout); + PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_v_timeout); + __pyx_t_3 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 198, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 198, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_8; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "gevent/_semaphore.py":219 + * raise a ``Timeout`` exception, if some other caller had already started a timer.) + * """ + * if self.counter > 0: # <<<<<<<<<<<<<< + * self.counter -= 1 + * return True + */ + __pyx_t_8 = ((__pyx_v_self->counter > 0) != 0); + if (__pyx_t_8) { + + /* "gevent/_semaphore.py":220 + * """ + * if self.counter > 0: + * self.counter -= 1 # <<<<<<<<<<<<<< + * return True + * + */ + __pyx_v_self->counter = (__pyx_v_self->counter - 1); + + /* "gevent/_semaphore.py":221 + * if self.counter > 0: + * self.counter -= 1 + * return True # <<<<<<<<<<<<<< + * + * if not blocking: + */ + __pyx_r = 1; + goto __pyx_L0; + + /* "gevent/_semaphore.py":219 + * raise a ``Timeout`` exception, if some other caller had already started a timer.) + * """ + * if self.counter > 0: # <<<<<<<<<<<<<< + * self.counter -= 1 + * return True + */ + } + + /* "gevent/_semaphore.py":223 + * return True + * + * if not blocking: # <<<<<<<<<<<<<< + * return False + * + */ + __pyx_t_8 = ((!(__pyx_v_blocking != 0)) != 0); + if (__pyx_t_8) { + + /* "gevent/_semaphore.py":224 + * + * if not blocking: + * return False # <<<<<<<<<<<<<< + * + * timeout = self._do_wait(timeout) + */ + __pyx_r = 0; + goto __pyx_L0; + + /* "gevent/_semaphore.py":223 + * return True + * + * if not blocking: # <<<<<<<<<<<<<< + * return False + * + */ + } + + /* "gevent/_semaphore.py":226 + * return False + * + * timeout = self._do_wait(timeout) # <<<<<<<<<<<<<< + * if timeout is not None: + * # Our timer expired. + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_6gevent_10_semaphore_Semaphore *)__pyx_v_self->__pyx_vtab)->_do_wait(__pyx_v_self, __pyx_v_timeout); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 226, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_timeout, __pyx_t_1); + __pyx_t_1 = 0; + + /* "gevent/_semaphore.py":227 + * + * timeout = self._do_wait(timeout) + * if timeout is not None: # <<<<<<<<<<<<<< + * # Our timer expired. + * return False + */ + __pyx_t_8 = (__pyx_v_timeout != Py_None); + __pyx_t_9 = (__pyx_t_8 != 0); + if (__pyx_t_9) { + + /* "gevent/_semaphore.py":229 + * if timeout is not None: + * # Our timer expired. + * return False # <<<<<<<<<<<<<< + * + * # Neither our timer no another one expired, so we blocked until + */ + __pyx_r = 0; + goto __pyx_L0; + + /* "gevent/_semaphore.py":227 + * + * timeout = self._do_wait(timeout) + * if timeout is not None: # <<<<<<<<<<<<<< + * # Our timer expired. + * return False + */ + } + + /* "gevent/_semaphore.py":233 + * # Neither our timer no another one expired, so we blocked until + * # awoke. Therefore, the counter is ours + * self.counter -= 1 # <<<<<<<<<<<<<< + * assert self.counter >= 0 + * return True + */ + __pyx_v_self->counter = (__pyx_v_self->counter - 1); + + /* "gevent/_semaphore.py":234 + * # awoke. Therefore, the counter is ours + * self.counter -= 1 + * assert self.counter >= 0 # <<<<<<<<<<<<<< + * return True + * + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(!Py_OptimizeFlag)) { + if (unlikely(!((__pyx_v_self->counter >= 0) != 0))) { + PyErr_SetNone(PyExc_AssertionError); + __PYX_ERR(0, 234, __pyx_L1_error) + } + } + #endif + + /* "gevent/_semaphore.py":235 + * self.counter -= 1 + * assert self.counter >= 0 + * return True # <<<<<<<<<<<<<< + * + * _py3k_acquire = acquire # PyPy needs this; it must be static for Cython + */ + __pyx_r = 1; + goto __pyx_L0; + + /* "gevent/_semaphore.py":198 + * return self.counter + * + * def acquire(self, blocking=True, timeout=None): # <<<<<<<<<<<<<< + * """ + * acquire(blocking=True, timeout=None) -> bool + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("gevent._semaphore.Semaphore.acquire", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1000; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_timeout); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_10_semaphore_9Semaphore_19acquire(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_6gevent_10_semaphore_9Semaphore_18acquire[] = "\n acquire(blocking=True, timeout=None) -> bool\n\n Acquire the semaphore.\n\n .. caution:: If this semaphore was initialized with a size of 0,\n this method will block forever (unless a timeout is given or blocking is\n set to false).\n\n :keyword bool blocking: If True (the default), this function will block\n until the semaphore is acquired.\n :keyword float timeout: If given, specifies the maximum amount of seconds\n this method will block.\n :return: A boolean indicating whether the semaphore was acquired.\n If ``blocking`` is True and ``timeout`` is None (the default), then\n (so long as this semaphore was initialized with a size greater than 0)\n this will always return True. If a timeout was given, and it expired before\n the semaphore was acquired, False will be returned. (Note that this can still\n raise a ``Timeout`` exception, if some other caller had already started a timer.)\n "; +static PyMethodDef __pyx_mdef_6gevent_10_semaphore_9Semaphore_19acquire = {"acquire", (PyCFunction)__pyx_pw_6gevent_10_semaphore_9Semaphore_19acquire, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6gevent_10_semaphore_9Semaphore_18acquire}; +static PyObject *__pyx_pw_6gevent_10_semaphore_9Semaphore_19acquire(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + int __pyx_v_blocking; + PyObject *__pyx_v_timeout = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("acquire (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_blocking,&__pyx_n_s_timeout,0}; + PyObject* values[2] = {0,0}; + values[1] = ((PyObject *)Py_None); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_blocking); + if (value) { values[0] = value; kw_args--; } + } + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_timeout); + if (value) { values[1] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "acquire") < 0)) __PYX_ERR(0, 198, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + if (values[0]) { + __pyx_v_blocking = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_blocking == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 198, __pyx_L3_error) + } else { + __pyx_v_blocking = ((int)1); + } + __pyx_v_timeout = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("acquire", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 198, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("gevent._semaphore.Semaphore.acquire", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_10_semaphore_9Semaphore_18acquire(((struct __pyx_obj_6gevent_10_semaphore_Semaphore *)__pyx_v_self), __pyx_v_blocking, __pyx_v_timeout); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_10_semaphore_9Semaphore_18acquire(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self, int __pyx_v_blocking, PyObject *__pyx_v_timeout) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + struct __pyx_opt_args_6gevent_10_semaphore_9Semaphore_acquire __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("acquire", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_2.__pyx_n = 2; + __pyx_t_2.blocking = __pyx_v_blocking; + __pyx_t_2.timeout = __pyx_v_timeout; + __pyx_t_1 = __pyx_vtabptr_6gevent_10_semaphore_Semaphore->acquire(__pyx_v_self, 1, &__pyx_t_2); if (unlikely(__pyx_t_1 == -1000)) __PYX_ERR(0, 198, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 198, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("gevent._semaphore.Semaphore.acquire", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "gevent/_semaphore.py":239 + * _py3k_acquire = acquire # PyPy needs this; it must be static for Cython + * + * def __enter__(self): # <<<<<<<<<<<<<< + * self.acquire() + * + */ + +static PyObject *__pyx_pw_6gevent_10_semaphore_9Semaphore_21__enter__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_f_6gevent_10_semaphore_9Semaphore___enter__(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self, int __pyx_skip_dispatch) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + __Pyx_RefNannySetupContext("__enter__", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_enter); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 239, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_6gevent_10_semaphore_9Semaphore_21__enter__)) { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 239, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 239, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "gevent/_semaphore.py":240 + * + * def __enter__(self): + * self.acquire() # <<<<<<<<<<<<<< + * + * def __exit__(self, t, v, tb): + */ + __pyx_t_5 = ((struct __pyx_vtabstruct_6gevent_10_semaphore_Semaphore *)__pyx_v_self->__pyx_vtab)->acquire(__pyx_v_self, 0, NULL); if (unlikely(__pyx_t_5 == -1000)) __PYX_ERR(0, 240, __pyx_L1_error) + + /* "gevent/_semaphore.py":239 + * _py3k_acquire = acquire # PyPy needs this; it must be static for Cython + * + * def __enter__(self): # <<<<<<<<<<<<<< + * self.acquire() + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("gevent._semaphore.Semaphore.__enter__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_10_semaphore_9Semaphore_21__enter__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyMethodDef __pyx_mdef_6gevent_10_semaphore_9Semaphore_21__enter__ = {"__enter__", (PyCFunction)__pyx_pw_6gevent_10_semaphore_9Semaphore_21__enter__, METH_NOARGS, 0}; +static PyObject *__pyx_pw_6gevent_10_semaphore_9Semaphore_21__enter__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__enter__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_10_semaphore_9Semaphore_20__enter__(((struct __pyx_obj_6gevent_10_semaphore_Semaphore *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_10_semaphore_9Semaphore_20__enter__(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__enter__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_6gevent_10_semaphore_9Semaphore___enter__(__pyx_v_self, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 239, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent._semaphore.Semaphore.__enter__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "gevent/_semaphore.py":242 + * self.acquire() + * + * def __exit__(self, t, v, tb): # <<<<<<<<<<<<<< + * self.release() + * + */ + +static PyObject *__pyx_pw_6gevent_10_semaphore_9Semaphore_23__exit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_f_6gevent_10_semaphore_9Semaphore___exit__(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_t, CYTHON_UNUSED PyObject *__pyx_v_v, CYTHON_UNUSED PyObject *__pyx_v_tb, int __pyx_skip_dispatch) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + __Pyx_RefNannySetupContext("__exit__", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_exit); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_6gevent_10_semaphore_9Semaphore_23__exit__)) { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + __pyx_t_5 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[4] = {__pyx_t_4, __pyx_v_t, __pyx_v_v, __pyx_v_tb}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 3+__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[4] = {__pyx_t_4, __pyx_v_t, __pyx_v_v, __pyx_v_tb}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 3+__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + { + __pyx_t_6 = PyTuple_New(3+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (__pyx_t_4) { + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL; + } + __Pyx_INCREF(__pyx_v_t); + __Pyx_GIVEREF(__pyx_v_t); + PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_5, __pyx_v_t); + __Pyx_INCREF(__pyx_v_v); + __Pyx_GIVEREF(__pyx_v_v); + PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, __pyx_v_v); + __Pyx_INCREF(__pyx_v_tb); + __Pyx_GIVEREF(__pyx_v_tb); + PyTuple_SET_ITEM(__pyx_t_6, 2+__pyx_t_5, __pyx_v_tb); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "gevent/_semaphore.py":243 + * + * def __exit__(self, t, v, tb): + * self.release() # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_5 = ((struct __pyx_vtabstruct_6gevent_10_semaphore_Semaphore *)__pyx_v_self->__pyx_vtab)->release(__pyx_v_self, 0); if (unlikely(__pyx_t_5 == -1000)) __PYX_ERR(0, 243, __pyx_L1_error) + + /* "gevent/_semaphore.py":242 + * self.acquire() + * + * def __exit__(self, t, v, tb): # <<<<<<<<<<<<<< + * self.release() + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("gevent._semaphore.Semaphore.__exit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_10_semaphore_9Semaphore_23__exit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_6gevent_10_semaphore_9Semaphore_23__exit__ = {"__exit__", (PyCFunction)__pyx_pw_6gevent_10_semaphore_9Semaphore_23__exit__, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6gevent_10_semaphore_9Semaphore_23__exit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_t = 0; + PyObject *__pyx_v_v = 0; + PyObject *__pyx_v_tb = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__exit__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_t,&__pyx_n_s_v,&__pyx_n_s_tb,0}; + PyObject* values[3] = {0,0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_t)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_v)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__exit__", 1, 3, 3, 1); __PYX_ERR(0, 242, __pyx_L3_error) + } + case 2: + if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_tb)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__exit__", 1, 3, 3, 2); __PYX_ERR(0, 242, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__exit__") < 0)) __PYX_ERR(0, 242, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + } + __pyx_v_t = values[0]; + __pyx_v_v = values[1]; + __pyx_v_tb = values[2]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__exit__", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 242, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("gevent._semaphore.Semaphore.__exit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_10_semaphore_9Semaphore_22__exit__(((struct __pyx_obj_6gevent_10_semaphore_Semaphore *)__pyx_v_self), __pyx_v_t, __pyx_v_v, __pyx_v_tb); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_10_semaphore_9Semaphore_22__exit__(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self, PyObject *__pyx_v_t, PyObject *__pyx_v_v, PyObject *__pyx_v_tb) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__exit__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_6gevent_10_semaphore_9Semaphore___exit__(__pyx_v_self, __pyx_v_t, __pyx_v_v, __pyx_v_tb, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent._semaphore.Semaphore.__exit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "gevent/_semaphore.pxd":2 + * cdef class Semaphore: + * cdef public int counter # <<<<<<<<<<<<<< + * cdef readonly object _links + * cdef readonly object _notifier + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_10_semaphore_9Semaphore_7counter_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_10_semaphore_9Semaphore_7counter_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_10_semaphore_9Semaphore_7counter___get__(((struct __pyx_obj_6gevent_10_semaphore_Semaphore *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_10_semaphore_9Semaphore_7counter___get__(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->counter); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent._semaphore.Semaphore.counter.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_10_semaphore_9Semaphore_7counter_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_6gevent_10_semaphore_9Semaphore_7counter_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_10_semaphore_9Semaphore_7counter_2__set__(((struct __pyx_obj_6gevent_10_semaphore_Semaphore *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_10_semaphore_9Semaphore_7counter_2__set__(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 2, __pyx_L1_error) + __pyx_v_self->counter = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("gevent._semaphore.Semaphore.counter.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "gevent/_semaphore.pxd":3 + * cdef class Semaphore: + * cdef public int counter + * cdef readonly object _links # <<<<<<<<<<<<<< + * cdef readonly object _notifier + * cdef public int _dirty + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_10_semaphore_9Semaphore_6_links_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_10_semaphore_9Semaphore_6_links_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_10_semaphore_9Semaphore_6_links___get__(((struct __pyx_obj_6gevent_10_semaphore_Semaphore *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_10_semaphore_9Semaphore_6_links___get__(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->_links); + __pyx_r = __pyx_v_self->_links; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "gevent/_semaphore.pxd":4 + * cdef public int counter + * cdef readonly object _links + * cdef readonly object _notifier # <<<<<<<<<<<<<< + * cdef public int _dirty + * cdef object __weakref__ + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_10_semaphore_9Semaphore_9_notifier_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_10_semaphore_9Semaphore_9_notifier_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_10_semaphore_9Semaphore_9_notifier___get__(((struct __pyx_obj_6gevent_10_semaphore_Semaphore *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_10_semaphore_9Semaphore_9_notifier___get__(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->_notifier); + __pyx_r = __pyx_v_self->_notifier; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "gevent/_semaphore.pxd":5 + * cdef readonly object _links + * cdef readonly object _notifier + * cdef public int _dirty # <<<<<<<<<<<<<< + * cdef object __weakref__ + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_10_semaphore_9Semaphore_6_dirty_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_10_semaphore_9Semaphore_6_dirty_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_10_semaphore_9Semaphore_6_dirty___get__(((struct __pyx_obj_6gevent_10_semaphore_Semaphore *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_10_semaphore_9Semaphore_6_dirty___get__(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->_dirty); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent._semaphore.Semaphore._dirty.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_10_semaphore_9Semaphore_6_dirty_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_6gevent_10_semaphore_9Semaphore_6_dirty_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_10_semaphore_9Semaphore_6_dirty_2__set__(((struct __pyx_obj_6gevent_10_semaphore_Semaphore *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_10_semaphore_9Semaphore_6_dirty_2__set__(struct __pyx_obj_6gevent_10_semaphore_Semaphore *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 5, __pyx_L1_error) + __pyx_v_self->_dirty = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("gevent._semaphore.Semaphore._dirty.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "gevent/_semaphore.py":262 + * _OVER_RELEASE_ERROR = ValueError + * + * def __init__(self, *args, **kwargs): # <<<<<<<<<<<<<< + * Semaphore.__init__(self, *args, **kwargs) + * self._initial_value = self.counter + */ + +/* Python wrapper */ +static int __pyx_pw_6gevent_10_semaphore_16BoundedSemaphore_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_6gevent_10_semaphore_16BoundedSemaphore_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_args = 0; + PyObject *__pyx_v_kwargs = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + if (unlikely(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__init__", 1))) return -1; + if (unlikely(__pyx_kwds)) { + __pyx_v_kwargs = PyDict_Copy(__pyx_kwds); if (unlikely(!__pyx_v_kwargs)) return -1; + __Pyx_GOTREF(__pyx_v_kwargs); + } else { + __pyx_v_kwargs = NULL; + } + __Pyx_INCREF(__pyx_args); + __pyx_v_args = __pyx_args; + __pyx_r = __pyx_pf_6gevent_10_semaphore_16BoundedSemaphore___init__(((struct __pyx_obj_6gevent_10_semaphore_BoundedSemaphore *)__pyx_v_self), __pyx_v_args, __pyx_v_kwargs); + + /* function exit code */ + __Pyx_XDECREF(__pyx_v_args); + __Pyx_XDECREF(__pyx_v_kwargs); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_10_semaphore_16BoundedSemaphore___init__(struct __pyx_obj_6gevent_10_semaphore_BoundedSemaphore *__pyx_v_self, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + __Pyx_RefNannySetupContext("__init__", 0); + + /* "gevent/_semaphore.py":263 + * + * def __init__(self, *args, **kwargs): + * Semaphore.__init__(self, *args, **kwargs) # <<<<<<<<<<<<<< + * self._initial_value = self.counter + * + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_6gevent_10_semaphore_Semaphore), __pyx_n_s_init); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 263, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 263, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + PyTuple_SET_ITEM(__pyx_t_2, 0, ((PyObject *)__pyx_v_self)); + __pyx_t_3 = PyNumber_Add(__pyx_t_2, __pyx_v_args); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 263, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, __pyx_v_kwargs); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 263, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "gevent/_semaphore.py":264 + * def __init__(self, *args, **kwargs): + * Semaphore.__init__(self, *args, **kwargs) + * self._initial_value = self.counter # <<<<<<<<<<<<<< + * + * def release(self): + */ + __pyx_t_4 = __pyx_v_self->__pyx_base.counter; + __pyx_v_self->_initial_value = __pyx_t_4; + + /* "gevent/_semaphore.py":262 + * _OVER_RELEASE_ERROR = ValueError + * + * def __init__(self, *args, **kwargs): # <<<<<<<<<<<<<< + * Semaphore.__init__(self, *args, **kwargs) + * self._initial_value = self.counter + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("gevent._semaphore.BoundedSemaphore.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "gevent/_semaphore.py":266 + * self._initial_value = self.counter + * + * def release(self): # <<<<<<<<<<<<<< + * if self.counter >= self._initial_value: + * raise self._OVER_RELEASE_ERROR("Semaphore released too many times") + */ + +static PyObject *__pyx_pw_6gevent_10_semaphore_16BoundedSemaphore_3release(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static int __pyx_f_6gevent_10_semaphore_16BoundedSemaphore_release(struct __pyx_obj_6gevent_10_semaphore_BoundedSemaphore *__pyx_v_self, int __pyx_skip_dispatch) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_t_6; + __Pyx_RefNannySetupContext("release", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_release); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 266, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_6gevent_10_semaphore_16BoundedSemaphore_3release)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 266, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 266, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 266, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_5; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "gevent/_semaphore.py":267 + * + * def release(self): + * if self.counter >= self._initial_value: # <<<<<<<<<<<<<< + * raise self._OVER_RELEASE_ERROR("Semaphore released too many times") + * return Semaphore.release(self) + */ + __pyx_t_6 = ((__pyx_v_self->__pyx_base.counter >= __pyx_v_self->_initial_value) != 0); + if (__pyx_t_6) { + + /* "gevent/_semaphore.py":268 + * def release(self): + * if self.counter >= self._initial_value: + * raise self._OVER_RELEASE_ERROR("Semaphore released too many times") # <<<<<<<<<<<<<< + * return Semaphore.release(self) + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_OVER_RELEASE_ERROR); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 268, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 268, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 268, __pyx_L1_error) + + /* "gevent/_semaphore.py":267 + * + * def release(self): + * if self.counter >= self._initial_value: # <<<<<<<<<<<<<< + * raise self._OVER_RELEASE_ERROR("Semaphore released too many times") + * return Semaphore.release(self) + */ + } + + /* "gevent/_semaphore.py":269 + * if self.counter >= self._initial_value: + * raise self._OVER_RELEASE_ERROR("Semaphore released too many times") + * return Semaphore.release(self) # <<<<<<<<<<<<<< + */ + __pyx_t_5 = __pyx_f_6gevent_10_semaphore_9Semaphore_release(((struct __pyx_obj_6gevent_10_semaphore_Semaphore *)__pyx_v_self), 1); if (unlikely(__pyx_t_5 == -1000)) __PYX_ERR(0, 269, __pyx_L1_error) + __pyx_r = __pyx_t_5; + goto __pyx_L0; + + /* "gevent/_semaphore.py":266 + * self._initial_value = self.counter + * + * def release(self): # <<<<<<<<<<<<<< + * if self.counter >= self._initial_value: + * raise self._OVER_RELEASE_ERROR("Semaphore released too many times") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("gevent._semaphore.BoundedSemaphore.release", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1000; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_10_semaphore_16BoundedSemaphore_3release(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyMethodDef __pyx_mdef_6gevent_10_semaphore_16BoundedSemaphore_3release = {"release", (PyCFunction)__pyx_pw_6gevent_10_semaphore_16BoundedSemaphore_3release, METH_NOARGS, 0}; +static PyObject *__pyx_pw_6gevent_10_semaphore_16BoundedSemaphore_3release(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("release (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_10_semaphore_16BoundedSemaphore_2release(((struct __pyx_obj_6gevent_10_semaphore_BoundedSemaphore *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_10_semaphore_16BoundedSemaphore_2release(struct __pyx_obj_6gevent_10_semaphore_BoundedSemaphore *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("release", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_6gevent_10_semaphore_16BoundedSemaphore_release(__pyx_v_self, 1); if (unlikely(__pyx_t_1 == -1000)) __PYX_ERR(0, 266, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 266, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent._semaphore.BoundedSemaphore.release", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "gevent/_semaphore.pxd":21 + * + * cdef class BoundedSemaphore(Semaphore): + * cdef readonly int _initial_value # <<<<<<<<<<<<<< + * + * cpdef int release(self) except -1000 + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_10_semaphore_16BoundedSemaphore_14_initial_value_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_10_semaphore_16BoundedSemaphore_14_initial_value_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_10_semaphore_16BoundedSemaphore_14_initial_value___get__(((struct __pyx_obj_6gevent_10_semaphore_BoundedSemaphore *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_10_semaphore_16BoundedSemaphore_14_initial_value___get__(struct __pyx_obj_6gevent_10_semaphore_BoundedSemaphore *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->_initial_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 21, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent._semaphore.BoundedSemaphore._initial_value.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +static struct __pyx_vtabstruct_6gevent_10_semaphore_Semaphore __pyx_vtable_6gevent_10_semaphore_Semaphore; + +static PyObject *__pyx_tp_new_6gevent_10_semaphore_Semaphore(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_6gevent_10_semaphore_Semaphore *p; + PyObject *o; + if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_6gevent_10_semaphore_Semaphore *)o); + p->__pyx_vtab = __pyx_vtabptr_6gevent_10_semaphore_Semaphore; + p->_links = Py_None; Py_INCREF(Py_None); + p->_notifier = Py_None; Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_6gevent_10_semaphore_Semaphore(PyObject *o) { + struct __pyx_obj_6gevent_10_semaphore_Semaphore *p = (struct __pyx_obj_6gevent_10_semaphore_Semaphore *)o; + #if PY_VERSION_HEX >= 0x030400a1 + if (unlikely(Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + PyObject_GC_UnTrack(o); + if (p->__weakref__) PyObject_ClearWeakRefs(o); + Py_CLEAR(p->_links); + Py_CLEAR(p->_notifier); + (*Py_TYPE(o)->tp_free)(o); +} + +static int __pyx_tp_traverse_6gevent_10_semaphore_Semaphore(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_6gevent_10_semaphore_Semaphore *p = (struct __pyx_obj_6gevent_10_semaphore_Semaphore *)o; + if (p->_links) { + e = (*v)(p->_links, a); if (e) return e; + } + if (p->_notifier) { + e = (*v)(p->_notifier, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_6gevent_10_semaphore_Semaphore(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_6gevent_10_semaphore_Semaphore *p = (struct __pyx_obj_6gevent_10_semaphore_Semaphore *)o; + tmp = ((PyObject*)p->_links); + p->_links = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_notifier); + p->_notifier = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_6gevent_10_semaphore_9Semaphore_counter(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_10_semaphore_9Semaphore_7counter_1__get__(o); +} + +static int __pyx_setprop_6gevent_10_semaphore_9Semaphore_counter(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_10_semaphore_9Semaphore_7counter_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_6gevent_10_semaphore_9Semaphore__links(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_10_semaphore_9Semaphore_6_links_1__get__(o); +} + +static PyObject *__pyx_getprop_6gevent_10_semaphore_9Semaphore__notifier(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_10_semaphore_9Semaphore_9_notifier_1__get__(o); +} + +static PyObject *__pyx_getprop_6gevent_10_semaphore_9Semaphore__dirty(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_10_semaphore_9Semaphore_6_dirty_1__get__(o); +} + +static int __pyx_setprop_6gevent_10_semaphore_9Semaphore__dirty(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_10_semaphore_9Semaphore_6_dirty_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyMethodDef __pyx_methods_6gevent_10_semaphore_Semaphore[] = { + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_6gevent_10_semaphore_Semaphore[] = { + {(char *)"counter", __pyx_getprop_6gevent_10_semaphore_9Semaphore_counter, __pyx_setprop_6gevent_10_semaphore_9Semaphore_counter, (char *)0, 0}, + {(char *)"_links", __pyx_getprop_6gevent_10_semaphore_9Semaphore__links, 0, (char *)0, 0}, + {(char *)"_notifier", __pyx_getprop_6gevent_10_semaphore_9Semaphore__notifier, 0, (char *)0, 0}, + {(char *)"_dirty", __pyx_getprop_6gevent_10_semaphore_9Semaphore__dirty, __pyx_setprop_6gevent_10_semaphore_9Semaphore__dirty, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; + +static PyTypeObject __pyx_type_6gevent_10_semaphore_Semaphore = { + PyVarObject_HEAD_INIT(0, 0) + "gevent._semaphore.Semaphore", /*tp_name*/ + sizeof(struct __pyx_obj_6gevent_10_semaphore_Semaphore), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_6gevent_10_semaphore_Semaphore, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + __pyx_pw_6gevent_10_semaphore_9Semaphore_3__str__, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + "\n Semaphore(value=1) -> Semaphore\n\n A semaphore manages a counter representing the number of release()\n calls minus the number of acquire() calls, plus an initial value.\n The acquire() method blocks if necessary until it can return\n without making the counter negative.\n\n If not given, ``value`` defaults to 1.\n\n The semaphore is a context manager and can be used in ``with`` statements.\n\n This Semaphore's ``__exit__`` method does not call the trace function\n on CPython, but does under PyPy.\n\n .. seealso:: :class:`BoundedSemaphore` for a safer version that prevents\n some classes of bugs.\n ", /*tp_doc*/ + __pyx_tp_traverse_6gevent_10_semaphore_Semaphore, /*tp_traverse*/ + __pyx_tp_clear_6gevent_10_semaphore_Semaphore, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_6gevent_10_semaphore_Semaphore, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_6gevent_10_semaphore_Semaphore, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + __pyx_pw_6gevent_10_semaphore_9Semaphore_1__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_6gevent_10_semaphore_Semaphore, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; +static struct __pyx_vtabstruct_6gevent_10_semaphore_BoundedSemaphore __pyx_vtable_6gevent_10_semaphore_BoundedSemaphore; + +static PyObject *__pyx_tp_new_6gevent_10_semaphore_BoundedSemaphore(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_obj_6gevent_10_semaphore_BoundedSemaphore *p; + PyObject *o = __pyx_tp_new_6gevent_10_semaphore_Semaphore(t, a, k); + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_6gevent_10_semaphore_BoundedSemaphore *)o); + p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_6gevent_10_semaphore_Semaphore*)__pyx_vtabptr_6gevent_10_semaphore_BoundedSemaphore; + return o; +} + +static PyObject *__pyx_getprop_6gevent_10_semaphore_16BoundedSemaphore__initial_value(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_10_semaphore_16BoundedSemaphore_14_initial_value_1__get__(o); +} + +static PyMethodDef __pyx_methods_6gevent_10_semaphore_BoundedSemaphore[] = { + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_6gevent_10_semaphore_BoundedSemaphore[] = { + {(char *)"_initial_value", __pyx_getprop_6gevent_10_semaphore_16BoundedSemaphore__initial_value, 0, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; + +static PyTypeObject __pyx_type_6gevent_10_semaphore_BoundedSemaphore = { + PyVarObject_HEAD_INIT(0, 0) + "gevent._semaphore.BoundedSemaphore", /*tp_name*/ + sizeof(struct __pyx_obj_6gevent_10_semaphore_BoundedSemaphore), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_6gevent_10_semaphore_Semaphore, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + #if CYTHON_COMPILING_IN_PYPY + __pyx_pw_6gevent_10_semaphore_9Semaphore_3__str__, /*tp_str*/ + #else + 0, /*tp_str*/ + #endif + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + "\n BoundedSemaphore(value=1) -> BoundedSemaphore\n\n A bounded semaphore checks to make sure its current value doesn't\n exceed its initial value. If it does, :class:`ValueError` is\n raised. In most situations semaphores are used to guard resources\n with limited capacity. If the semaphore is released too many times\n it's a sign of a bug.\n\n If not given, *value* defaults to 1.\n ", /*tp_doc*/ + __pyx_tp_traverse_6gevent_10_semaphore_Semaphore, /*tp_traverse*/ + __pyx_tp_clear_6gevent_10_semaphore_Semaphore, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_6gevent_10_semaphore_BoundedSemaphore, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_6gevent_10_semaphore_BoundedSemaphore, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + __pyx_pw_6gevent_10_semaphore_16BoundedSemaphore_1__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_6gevent_10_semaphore_BoundedSemaphore, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; + +static PyMethodDef __pyx_methods[] = { + {0, 0, 0, 0} +}; + +#if PY_MAJOR_VERSION >= 3 +static struct PyModuleDef __pyx_moduledef = { + #if PY_VERSION_HEX < 0x03020000 + { PyObject_HEAD_INIT(NULL) NULL, 0, NULL }, + #else + PyModuleDef_HEAD_INIT, + #endif + "_semaphore", + 0, /* m_doc */ + -1, /* m_size */ + __pyx_methods /* m_methods */, + NULL, /* m_reload */ + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ +}; +#endif + +static __Pyx_StringTabEntry __pyx_string_tab[] = { + {&__pyx_n_s_AttributeError, __pyx_k_AttributeError, sizeof(__pyx_k_AttributeError), 0, 0, 1, 1}, + {&__pyx_n_s_BoundedSemaphore, __pyx_k_BoundedSemaphore, sizeof(__pyx_k_BoundedSemaphore), 0, 0, 1, 1}, + {&__pyx_n_s_BoundedSemaphore_release, __pyx_k_BoundedSemaphore_release, sizeof(__pyx_k_BoundedSemaphore_release), 0, 0, 1, 1}, + {&__pyx_kp_s_C_projects_gevent_src_gevent__se, __pyx_k_C_projects_gevent_src_gevent__se, sizeof(__pyx_k_C_projects_gevent_src_gevent__se), 0, 0, 1, 0}, + {&__pyx_kp_s_Expected_callable, __pyx_k_Expected_callable, sizeof(__pyx_k_Expected_callable), 0, 0, 1, 0}, + {&__pyx_kp_s_Invalid_switch_into_Semaphore_wa, __pyx_k_Invalid_switch_into_Semaphore_wa, sizeof(__pyx_k_Invalid_switch_into_Semaphore_wa), 0, 0, 1, 0}, + {&__pyx_n_s_OVER_RELEASE_ERROR, __pyx_k_OVER_RELEASE_ERROR, sizeof(__pyx_k_OVER_RELEASE_ERROR), 0, 0, 1, 1}, + {&__pyx_n_s_Semaphore, __pyx_k_Semaphore, sizeof(__pyx_k_Semaphore), 0, 0, 1, 1}, + {&__pyx_n_s_Semaphore___enter, __pyx_k_Semaphore___enter, sizeof(__pyx_k_Semaphore___enter), 0, 0, 1, 1}, + {&__pyx_n_s_Semaphore___exit, __pyx_k_Semaphore___exit, sizeof(__pyx_k_Semaphore___exit), 0, 0, 1, 1}, + {&__pyx_n_s_Semaphore__notify_links, __pyx_k_Semaphore__notify_links, sizeof(__pyx_k_Semaphore__notify_links), 0, 0, 1, 1}, + {&__pyx_n_s_Semaphore__start_notify, __pyx_k_Semaphore__start_notify, sizeof(__pyx_k_Semaphore__start_notify), 0, 0, 1, 1}, + {&__pyx_n_s_Semaphore_acquire, __pyx_k_Semaphore_acquire, sizeof(__pyx_k_Semaphore_acquire), 0, 0, 1, 1}, + {&__pyx_n_s_Semaphore_locked, __pyx_k_Semaphore_locked, sizeof(__pyx_k_Semaphore_locked), 0, 0, 1, 1}, + {&__pyx_n_s_Semaphore_rawlink, __pyx_k_Semaphore_rawlink, sizeof(__pyx_k_Semaphore_rawlink), 0, 0, 1, 1}, + {&__pyx_n_s_Semaphore_release, __pyx_k_Semaphore_release, sizeof(__pyx_k_Semaphore_release), 0, 0, 1, 1}, + {&__pyx_kp_s_Semaphore_released_too_many_time, __pyx_k_Semaphore_released_too_many_time, sizeof(__pyx_k_Semaphore_released_too_many_time), 0, 0, 1, 0}, + {&__pyx_n_s_Semaphore_unlink, __pyx_k_Semaphore_unlink, sizeof(__pyx_k_Semaphore_unlink), 0, 0, 1, 1}, + {&__pyx_n_s_Semaphore_wait, __pyx_k_Semaphore_wait, sizeof(__pyx_k_Semaphore_wait), 0, 0, 1, 1}, + {&__pyx_n_s_Timeout, __pyx_k_Timeout, sizeof(__pyx_k_Timeout), 0, 0, 1, 1}, + {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, + {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, + {&__pyx_n_s_acquire, __pyx_k_acquire, sizeof(__pyx_k_acquire), 0, 0, 1, 1}, + {&__pyx_n_s_all, __pyx_k_all, sizeof(__pyx_k_all), 0, 0, 1, 1}, + {&__pyx_n_s_append, __pyx_k_append, sizeof(__pyx_k_append), 0, 0, 1, 1}, + {&__pyx_n_s_blocking, __pyx_k_blocking, sizeof(__pyx_k_blocking), 0, 0, 1, 1}, + {&__pyx_n_s_callback, __pyx_k_callback, sizeof(__pyx_k_callback), 0, 0, 1, 1}, + {&__pyx_n_s_cancel, __pyx_k_cancel, sizeof(__pyx_k_cancel), 0, 0, 1, 1}, + {&__pyx_n_s_class, __pyx_k_class, sizeof(__pyx_k_class), 0, 0, 1, 1}, + {&__pyx_n_s_enter, __pyx_k_enter, sizeof(__pyx_k_enter), 0, 0, 1, 1}, + {&__pyx_n_s_exc_info, __pyx_k_exc_info, sizeof(__pyx_k_exc_info), 0, 0, 1, 1}, + {&__pyx_n_s_exit, __pyx_k_exit, sizeof(__pyx_k_exit), 0, 0, 1, 1}, + {&__pyx_n_s_get_hub, __pyx_k_get_hub, sizeof(__pyx_k_get_hub), 0, 0, 1, 1}, + {&__pyx_n_s_getcurrent, __pyx_k_getcurrent, sizeof(__pyx_k_getcurrent), 0, 0, 1, 1}, + {&__pyx_n_s_gevent__semaphore, __pyx_k_gevent__semaphore, sizeof(__pyx_k_gevent__semaphore), 0, 0, 1, 1}, + {&__pyx_n_s_gevent_hub, __pyx_k_gevent_hub, sizeof(__pyx_k_gevent_hub), 0, 0, 1, 1}, + {&__pyx_n_s_gevent_timeout, __pyx_k_gevent_timeout, sizeof(__pyx_k_gevent_timeout), 0, 0, 1, 1}, + {&__pyx_n_s_handle_error, __pyx_k_handle_error, sizeof(__pyx_k_handle_error), 0, 0, 1, 1}, + {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, + {&__pyx_n_s_init, __pyx_k_init, sizeof(__pyx_k_init), 0, 0, 1, 1}, + {&__pyx_n_s_locked, __pyx_k_locked, sizeof(__pyx_k_locked), 0, 0, 1, 1}, + {&__pyx_n_s_loop, __pyx_k_loop, sizeof(__pyx_k_loop), 0, 0, 1, 1}, + {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, + {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, + {&__pyx_n_s_notify_links, __pyx_k_notify_links, sizeof(__pyx_k_notify_links), 0, 0, 1, 1}, + {&__pyx_n_s_py3k_acquire, __pyx_k_py3k_acquire, sizeof(__pyx_k_py3k_acquire), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_vtable, __pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 0, 1, 1}, + {&__pyx_n_s_rawlink, __pyx_k_rawlink, sizeof(__pyx_k_rawlink), 0, 0, 1, 1}, + {&__pyx_n_s_release, __pyx_k_release, sizeof(__pyx_k_release), 0, 0, 1, 1}, + {&__pyx_n_s_remove, __pyx_k_remove, sizeof(__pyx_k_remove), 0, 0, 1, 1}, + {&__pyx_n_s_run_callback, __pyx_k_run_callback, sizeof(__pyx_k_run_callback), 0, 0, 1, 1}, + {&__pyx_kp_s_s_counter_s__links_s, __pyx_k_s_counter_s__links_s, sizeof(__pyx_k_s_counter_s__links_s), 0, 0, 1, 0}, + {&__pyx_n_s_self, __pyx_k_self, sizeof(__pyx_k_self), 0, 0, 1, 1}, + {&__pyx_kp_s_semaphore_initial_value_must_be, __pyx_k_semaphore_initial_value_must_be, sizeof(__pyx_k_semaphore_initial_value_must_be), 0, 0, 1, 0}, + {&__pyx_n_s_start_new_or_dummy, __pyx_k_start_new_or_dummy, sizeof(__pyx_k_start_new_or_dummy), 0, 0, 1, 1}, + {&__pyx_n_s_start_notify, __pyx_k_start_notify, sizeof(__pyx_k_start_notify), 0, 0, 1, 1}, + {&__pyx_n_s_switch, __pyx_k_switch, sizeof(__pyx_k_switch), 0, 0, 1, 1}, + {&__pyx_n_s_sys, __pyx_k_sys, sizeof(__pyx_k_sys), 0, 0, 1, 1}, + {&__pyx_n_s_t, __pyx_k_t, sizeof(__pyx_k_t), 0, 0, 1, 1}, + {&__pyx_n_s_tb, __pyx_k_tb, sizeof(__pyx_k_tb), 0, 0, 1, 1}, + {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, + {&__pyx_n_s_timeout, __pyx_k_timeout, sizeof(__pyx_k_timeout), 0, 0, 1, 1}, + {&__pyx_n_s_unlink, __pyx_k_unlink, sizeof(__pyx_k_unlink), 0, 0, 1, 1}, + {&__pyx_n_s_v, __pyx_k_v, sizeof(__pyx_k_v), 0, 0, 1, 1}, + {&__pyx_n_s_value, __pyx_k_value, sizeof(__pyx_k_value), 0, 0, 1, 1}, + {&__pyx_n_s_wait, __pyx_k_wait, sizeof(__pyx_k_wait), 0, 0, 1, 1}, + {0, 0, 0, 0, 0, 0, 0} +}; +static int __Pyx_InitCachedBuiltins(void) { + __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(0, 260, __pyx_L1_error) + __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(0, 129, __pyx_L1_error) + __pyx_builtin_AttributeError = __Pyx_GetBuiltinName(__pyx_n_s_AttributeError); if (!__pyx_builtin_AttributeError) __PYX_ERR(0, 148, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} + +static int __Pyx_InitCachedConstants(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); + + /* "gevent/_semaphore.py":31 + * def __init__(self, value=1): + * if value < 0: + * raise ValueError("semaphore initial value must be >= 0") # <<<<<<<<<<<<<< + * self.counter = value + * self._dirty = False + */ + __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_s_semaphore_initial_value_must_be); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 31, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple_); + __Pyx_GIVEREF(__pyx_tuple_); + + /* "gevent/_semaphore.py":268 + * def release(self): + * if self.counter >= self._initial_value: + * raise self._OVER_RELEASE_ERROR("Semaphore released too many times") # <<<<<<<<<<<<<< + * return Semaphore.release(self) + */ + __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_s_Semaphore_released_too_many_time); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 268, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__2); + __Pyx_GIVEREF(__pyx_tuple__2); + + /* "gevent/_semaphore.py":56 + * return '<%s counter=%s _links[%s]>' % params + * + * def locked(self): # <<<<<<<<<<<<<< + * """Return a boolean indicating whether the semaphore can be acquired. + * Most useful with binary semaphores.""" + */ + __pyx_tuple__3 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 56, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__3); + __Pyx_GIVEREF(__pyx_tuple__3); + __pyx_codeobj__4 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__3, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_projects_gevent_src_gevent__se, __pyx_n_s_locked, 56, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__4)) __PYX_ERR(0, 56, __pyx_L1_error) + + /* "gevent/_semaphore.py":61 + * return self.counter <= 0 + * + * def release(self): # <<<<<<<<<<<<<< + * """ + * Release the semaphore, notifying any waiters if needed. + */ + __pyx_tuple__5 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(0, 61, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__5); + __Pyx_GIVEREF(__pyx_tuple__5); + __pyx_codeobj__6 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__5, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_projects_gevent_src_gevent__se, __pyx_n_s_release, 61, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__6)) __PYX_ERR(0, 61, __pyx_L1_error) + + /* "gevent/_semaphore.py":69 + * return self.counter + * + * def _start_notify(self): # <<<<<<<<<<<<<< + * if self._links and self.counter > 0 and not self._notifier: + * # We create a new self._notifier each time through the loop, + */ + __pyx_tuple__7 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(0, 69, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__7); + __Pyx_GIVEREF(__pyx_tuple__7); + __pyx_codeobj__8 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__7, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_projects_gevent_src_gevent__se, __pyx_n_s_start_notify, 69, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__8)) __PYX_ERR(0, 69, __pyx_L1_error) + + /* "gevent/_semaphore.py":80 + * self._notifier = get_hub().loop.run_callback(self._notify_links) + * + * def _notify_links(self): # <<<<<<<<<<<<<< + * # Subclasses CANNOT override. This is a cdef method. + * + */ + __pyx_tuple__9 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(0, 80, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__9); + __Pyx_GIVEREF(__pyx_tuple__9); + __pyx_codeobj__10 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__9, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_projects_gevent_src_gevent__se, __pyx_n_s_notify_links, 80, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__10)) __PYX_ERR(0, 80, __pyx_L1_error) + + /* "gevent/_semaphore.py":116 + * self._notifier = None + * + * def rawlink(self, callback): # <<<<<<<<<<<<<< + * """ + * rawlink(callback) -> None + */ + __pyx_tuple__11 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_callback); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(0, 116, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__11); + __Pyx_GIVEREF(__pyx_tuple__11); + __pyx_codeobj__12 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__11, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_projects_gevent_src_gevent__se, __pyx_n_s_rawlink, 116, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__12)) __PYX_ERR(0, 116, __pyx_L1_error) + + /* "gevent/_semaphore.py":136 + * self._dirty = True + * + * def unlink(self, callback): # <<<<<<<<<<<<<< + * """ + * unlink(callback) -> None + */ + __pyx_tuple__13 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_callback); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__13); + __Pyx_GIVEREF(__pyx_tuple__13); + __pyx_codeobj__14 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__13, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_projects_gevent_src_gevent__se, __pyx_n_s_unlink, 136, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__14)) __PYX_ERR(0, 136, __pyx_L1_error) + + /* "gevent/_semaphore.py":177 + * self.unlink(switch) + * + * def wait(self, timeout=None): # <<<<<<<<<<<<<< + * """ + * wait(timeout=None) -> int + */ + __pyx_tuple__15 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_timeout); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(0, 177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__15); + __Pyx_GIVEREF(__pyx_tuple__15); + __pyx_codeobj__16 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__15, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_projects_gevent_src_gevent__se, __pyx_n_s_wait, 177, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__16)) __PYX_ERR(0, 177, __pyx_L1_error) + + /* "gevent/_semaphore.py":198 + * return self.counter + * + * def acquire(self, blocking=True, timeout=None): # <<<<<<<<<<<<<< + * """ + * acquire(blocking=True, timeout=None) -> bool + */ + __pyx_tuple__17 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_blocking, __pyx_n_s_timeout); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(0, 198, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__17); + __Pyx_GIVEREF(__pyx_tuple__17); + __pyx_codeobj__18 = (PyObject*)__Pyx_PyCode_New(3, 0, 3, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__17, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_projects_gevent_src_gevent__se, __pyx_n_s_acquire, 198, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__18)) __PYX_ERR(0, 198, __pyx_L1_error) + + /* "gevent/_semaphore.py":239 + * _py3k_acquire = acquire # PyPy needs this; it must be static for Cython + * + * def __enter__(self): # <<<<<<<<<<<<<< + * self.acquire() + * + */ + __pyx_tuple__19 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__19)) __PYX_ERR(0, 239, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__19); + __Pyx_GIVEREF(__pyx_tuple__19); + __pyx_codeobj__20 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__19, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_projects_gevent_src_gevent__se, __pyx_n_s_enter, 239, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__20)) __PYX_ERR(0, 239, __pyx_L1_error) + + /* "gevent/_semaphore.py":242 + * self.acquire() + * + * def __exit__(self, t, v, tb): # <<<<<<<<<<<<<< + * self.release() + * + */ + __pyx_tuple__21 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_t, __pyx_n_s_v, __pyx_n_s_tb); if (unlikely(!__pyx_tuple__21)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__21); + __Pyx_GIVEREF(__pyx_tuple__21); + __pyx_codeobj__22 = (PyObject*)__Pyx_PyCode_New(4, 0, 4, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__21, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_projects_gevent_src_gevent__se, __pyx_n_s_exit, 242, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__22)) __PYX_ERR(0, 242, __pyx_L1_error) + + /* "gevent/_semaphore.py":266 + * self._initial_value = self.counter + * + * def release(self): # <<<<<<<<<<<<<< + * if self.counter >= self._initial_value: + * raise self._OVER_RELEASE_ERROR("Semaphore released too many times") + */ + __pyx_tuple__23 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__23)) __PYX_ERR(0, 266, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__23); + __Pyx_GIVEREF(__pyx_tuple__23); + __pyx_codeobj__24 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__23, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_projects_gevent_src_gevent__se, __pyx_n_s_release, 266, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__24)) __PYX_ERR(0, 266, __pyx_L1_error) + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_InitGlobals(void) { + if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); + __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} + +#if PY_MAJOR_VERSION < 3 +PyMODINIT_FUNC init_semaphore(void); /*proto*/ +PyMODINIT_FUNC init_semaphore(void) +#else +PyMODINIT_FUNC PyInit__semaphore(void); /*proto*/ +PyMODINIT_FUNC PyInit__semaphore(void) +#endif +{ + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannyDeclarations + #if CYTHON_REFNANNY + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); + if (!__Pyx_RefNanny) { + PyErr_Clear(); + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); + if (!__Pyx_RefNanny) + Py_FatalError("failed to import 'refnanny' module"); + } + #endif + __Pyx_RefNannySetupContext("PyMODINIT_FUNC PyInit__semaphore(void)", 0); + if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) + #ifdef __Pyx_CyFunction_USED + if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_FusedFunction_USED + if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Coroutine_USED + if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Generator_USED + if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_StopAsyncIteration_USED + if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + /*--- Library function declarations ---*/ + /*--- Threads initialization code ---*/ + #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS + #ifdef WITH_THREAD /* Python build with threading support? */ + PyEval_InitThreads(); + #endif + #endif + /*--- Module creation code ---*/ + #if PY_MAJOR_VERSION < 3 + __pyx_m = Py_InitModule4("_semaphore", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); + #else + __pyx_m = PyModule_Create(&__pyx_moduledef); + #endif + if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_d); + __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) + #if CYTHON_COMPILING_IN_PYPY + Py_INCREF(__pyx_b); + #endif + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error); + /*--- Initialize various global constants etc. ---*/ + if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) + if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + if (__pyx_module_is_main_gevent___semaphore) { + if (PyObject_SetAttrString(__pyx_m, "__name__", __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + } + #if PY_MAJOR_VERSION >= 3 + { + PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) + if (!PyDict_GetItemString(modules, "gevent._semaphore")) { + if (unlikely(PyDict_SetItemString(modules, "gevent._semaphore", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + } + } + #endif + /*--- Builtin init code ---*/ + if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Constants init code ---*/ + if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Global init code ---*/ + /*--- Variable export code ---*/ + /*--- Function export code ---*/ + /*--- Type init code ---*/ + __pyx_vtabptr_6gevent_10_semaphore_Semaphore = &__pyx_vtable_6gevent_10_semaphore_Semaphore; + __pyx_vtable_6gevent_10_semaphore_Semaphore.locked = (int (*)(struct __pyx_obj_6gevent_10_semaphore_Semaphore *, int __pyx_skip_dispatch))__pyx_f_6gevent_10_semaphore_9Semaphore_locked; + __pyx_vtable_6gevent_10_semaphore_Semaphore.release = (int (*)(struct __pyx_obj_6gevent_10_semaphore_Semaphore *, int __pyx_skip_dispatch))__pyx_f_6gevent_10_semaphore_9Semaphore_release; + __pyx_vtable_6gevent_10_semaphore_Semaphore.rawlink = (PyObject *(*)(struct __pyx_obj_6gevent_10_semaphore_Semaphore *, PyObject *, int __pyx_skip_dispatch))__pyx_f_6gevent_10_semaphore_9Semaphore_rawlink; + __pyx_vtable_6gevent_10_semaphore_Semaphore.unlink = (PyObject *(*)(struct __pyx_obj_6gevent_10_semaphore_Semaphore *, PyObject *, int __pyx_skip_dispatch))__pyx_f_6gevent_10_semaphore_9Semaphore_unlink; + __pyx_vtable_6gevent_10_semaphore_Semaphore._start_notify = (PyObject *(*)(struct __pyx_obj_6gevent_10_semaphore_Semaphore *, int __pyx_skip_dispatch))__pyx_f_6gevent_10_semaphore_9Semaphore__start_notify; + __pyx_vtable_6gevent_10_semaphore_Semaphore._notify_links = (PyObject *(*)(struct __pyx_obj_6gevent_10_semaphore_Semaphore *, int __pyx_skip_dispatch))__pyx_f_6gevent_10_semaphore_9Semaphore__notify_links; + __pyx_vtable_6gevent_10_semaphore_Semaphore._do_wait = (PyObject *(*)(struct __pyx_obj_6gevent_10_semaphore_Semaphore *, PyObject *))__pyx_f_6gevent_10_semaphore_9Semaphore__do_wait; + __pyx_vtable_6gevent_10_semaphore_Semaphore.wait = (int (*)(struct __pyx_obj_6gevent_10_semaphore_Semaphore *, int __pyx_skip_dispatch, struct __pyx_opt_args_6gevent_10_semaphore_9Semaphore_wait *__pyx_optional_args))__pyx_f_6gevent_10_semaphore_9Semaphore_wait; + __pyx_vtable_6gevent_10_semaphore_Semaphore.acquire = (int (*)(struct __pyx_obj_6gevent_10_semaphore_Semaphore *, int __pyx_skip_dispatch, struct __pyx_opt_args_6gevent_10_semaphore_9Semaphore_acquire *__pyx_optional_args))__pyx_f_6gevent_10_semaphore_9Semaphore_acquire; + __pyx_vtable_6gevent_10_semaphore_Semaphore.__pyx___enter__ = (PyObject *(*)(struct __pyx_obj_6gevent_10_semaphore_Semaphore *, int __pyx_skip_dispatch))__pyx_f_6gevent_10_semaphore_9Semaphore___enter__; + __pyx_vtable_6gevent_10_semaphore_Semaphore.__pyx___exit__ = (PyObject *(*)(struct __pyx_obj_6gevent_10_semaphore_Semaphore *, PyObject *, PyObject *, PyObject *, int __pyx_skip_dispatch))__pyx_f_6gevent_10_semaphore_9Semaphore___exit__; + if (PyType_Ready(&__pyx_type_6gevent_10_semaphore_Semaphore) < 0) __PYX_ERR(0, 9, __pyx_L1_error) + __pyx_type_6gevent_10_semaphore_Semaphore.tp_print = 0; + if (__Pyx_SetVtable(__pyx_type_6gevent_10_semaphore_Semaphore.tp_dict, __pyx_vtabptr_6gevent_10_semaphore_Semaphore) < 0) __PYX_ERR(0, 9, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "Semaphore", (PyObject *)&__pyx_type_6gevent_10_semaphore_Semaphore) < 0) __PYX_ERR(0, 9, __pyx_L1_error) + if (__pyx_type_6gevent_10_semaphore_Semaphore.tp_weaklistoffset == 0) __pyx_type_6gevent_10_semaphore_Semaphore.tp_weaklistoffset = offsetof(struct __pyx_obj_6gevent_10_semaphore_Semaphore, __weakref__); + __pyx_ptype_6gevent_10_semaphore_Semaphore = &__pyx_type_6gevent_10_semaphore_Semaphore; + __pyx_vtabptr_6gevent_10_semaphore_BoundedSemaphore = &__pyx_vtable_6gevent_10_semaphore_BoundedSemaphore; + __pyx_vtable_6gevent_10_semaphore_BoundedSemaphore.__pyx_base = *__pyx_vtabptr_6gevent_10_semaphore_Semaphore; + __pyx_vtable_6gevent_10_semaphore_BoundedSemaphore.__pyx_base.release = (int (*)(struct __pyx_obj_6gevent_10_semaphore_Semaphore *, int __pyx_skip_dispatch))__pyx_f_6gevent_10_semaphore_16BoundedSemaphore_release; + __pyx_type_6gevent_10_semaphore_BoundedSemaphore.tp_base = __pyx_ptype_6gevent_10_semaphore_Semaphore; + if (PyType_Ready(&__pyx_type_6gevent_10_semaphore_BoundedSemaphore) < 0) __PYX_ERR(0, 246, __pyx_L1_error) + __pyx_type_6gevent_10_semaphore_BoundedSemaphore.tp_print = 0; + if (__Pyx_SetVtable(__pyx_type_6gevent_10_semaphore_BoundedSemaphore.tp_dict, __pyx_vtabptr_6gevent_10_semaphore_BoundedSemaphore) < 0) __PYX_ERR(0, 246, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "BoundedSemaphore", (PyObject *)&__pyx_type_6gevent_10_semaphore_BoundedSemaphore) < 0) __PYX_ERR(0, 246, __pyx_L1_error) + if (__pyx_type_6gevent_10_semaphore_BoundedSemaphore.tp_weaklistoffset == 0) __pyx_type_6gevent_10_semaphore_BoundedSemaphore.tp_weaklistoffset = offsetof(struct __pyx_obj_6gevent_10_semaphore_BoundedSemaphore, __pyx_base.__weakref__); + __pyx_ptype_6gevent_10_semaphore_BoundedSemaphore = &__pyx_type_6gevent_10_semaphore_BoundedSemaphore; + /*--- Type import code ---*/ + /*--- Variable import code ---*/ + /*--- Function import code ---*/ + /*--- Execution code ---*/ + #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) + if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + + /* "gevent/_semaphore.py":1 + * import sys # <<<<<<<<<<<<<< + * from gevent.hub import get_hub, getcurrent + * from gevent.timeout import Timeout + */ + __pyx_t_1 = __Pyx_Import(__pyx_n_s_sys, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_sys, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "gevent/_semaphore.py":2 + * import sys + * from gevent.hub import get_hub, getcurrent # <<<<<<<<<<<<<< + * from gevent.timeout import Timeout + * + */ + __pyx_t_1 = PyList_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_get_hub); + __Pyx_GIVEREF(__pyx_n_s_get_hub); + PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_get_hub); + __Pyx_INCREF(__pyx_n_s_getcurrent); + __Pyx_GIVEREF(__pyx_n_s_getcurrent); + PyList_SET_ITEM(__pyx_t_1, 1, __pyx_n_s_getcurrent); + __pyx_t_2 = __Pyx_Import(__pyx_n_s_gevent_hub, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_get_hub); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_hub, __pyx_t_1) < 0) __PYX_ERR(0, 2, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_getcurrent); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_getcurrent, __pyx_t_1) < 0) __PYX_ERR(0, 2, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "gevent/_semaphore.py":3 + * import sys + * from gevent.hub import get_hub, getcurrent + * from gevent.timeout import Timeout # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_n_s_Timeout); + __Pyx_GIVEREF(__pyx_n_s_Timeout); + PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_Timeout); + __pyx_t_1 = __Pyx_Import(__pyx_n_s_gevent_timeout, __pyx_t_2, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_Timeout); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_Timeout, __pyx_t_2) < 0) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "gevent/_semaphore.py":6 + * + * + * __all__ = ['Semaphore', 'BoundedSemaphore'] # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = PyList_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_Semaphore); + __Pyx_GIVEREF(__pyx_n_s_Semaphore); + PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_Semaphore); + __Pyx_INCREF(__pyx_n_s_BoundedSemaphore); + __Pyx_GIVEREF(__pyx_n_s_BoundedSemaphore); + PyList_SET_ITEM(__pyx_t_1, 1, __pyx_n_s_BoundedSemaphore); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_all, __pyx_t_1) < 0) __PYX_ERR(0, 6, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "gevent/_semaphore.py":56 + * return '<%s counter=%s _links[%s]>' % params + * + * def locked(self): # <<<<<<<<<<<<<< + * """Return a boolean indicating whether the semaphore can be acquired. + * Most useful with binary semaphores.""" + */ + __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6gevent_10_semaphore_9Semaphore_5locked, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Semaphore_locked, NULL, __pyx_n_s_gevent__semaphore, __pyx_d, ((PyObject *)__pyx_codeobj__4)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 56, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem((PyObject *)__pyx_ptype_6gevent_10_semaphore_Semaphore->tp_dict, __pyx_n_s_locked, __pyx_t_1) < 0) __PYX_ERR(0, 56, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + PyType_Modified(__pyx_ptype_6gevent_10_semaphore_Semaphore); + + /* "gevent/_semaphore.py":61 + * return self.counter <= 0 + * + * def release(self): # <<<<<<<<<<<<<< + * """ + * Release the semaphore, notifying any waiters if needed. + */ + __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6gevent_10_semaphore_9Semaphore_7release, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Semaphore_release, NULL, __pyx_n_s_gevent__semaphore, __pyx_d, ((PyObject *)__pyx_codeobj__6)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 61, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem((PyObject *)__pyx_ptype_6gevent_10_semaphore_Semaphore->tp_dict, __pyx_n_s_release, __pyx_t_1) < 0) __PYX_ERR(0, 61, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + PyType_Modified(__pyx_ptype_6gevent_10_semaphore_Semaphore); + + /* "gevent/_semaphore.py":69 + * return self.counter + * + * def _start_notify(self): # <<<<<<<<<<<<<< + * if self._links and self.counter > 0 and not self._notifier: + * # We create a new self._notifier each time through the loop, + */ + __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6gevent_10_semaphore_9Semaphore_9_start_notify, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Semaphore__start_notify, NULL, __pyx_n_s_gevent__semaphore, __pyx_d, ((PyObject *)__pyx_codeobj__8)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 69, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem((PyObject *)__pyx_ptype_6gevent_10_semaphore_Semaphore->tp_dict, __pyx_n_s_start_notify, __pyx_t_1) < 0) __PYX_ERR(0, 69, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + PyType_Modified(__pyx_ptype_6gevent_10_semaphore_Semaphore); + + /* "gevent/_semaphore.py":80 + * self._notifier = get_hub().loop.run_callback(self._notify_links) + * + * def _notify_links(self): # <<<<<<<<<<<<<< + * # Subclasses CANNOT override. This is a cdef method. + * + */ + __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6gevent_10_semaphore_9Semaphore_11_notify_links, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Semaphore__notify_links, NULL, __pyx_n_s_gevent__semaphore, __pyx_d, ((PyObject *)__pyx_codeobj__10)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 80, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem((PyObject *)__pyx_ptype_6gevent_10_semaphore_Semaphore->tp_dict, __pyx_n_s_notify_links, __pyx_t_1) < 0) __PYX_ERR(0, 80, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + PyType_Modified(__pyx_ptype_6gevent_10_semaphore_Semaphore); + + /* "gevent/_semaphore.py":116 + * self._notifier = None + * + * def rawlink(self, callback): # <<<<<<<<<<<<<< + * """ + * rawlink(callback) -> None + */ + __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6gevent_10_semaphore_9Semaphore_13rawlink, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Semaphore_rawlink, NULL, __pyx_n_s_gevent__semaphore, __pyx_d, ((PyObject *)__pyx_codeobj__12)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 116, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem((PyObject *)__pyx_ptype_6gevent_10_semaphore_Semaphore->tp_dict, __pyx_n_s_rawlink, __pyx_t_1) < 0) __PYX_ERR(0, 116, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + PyType_Modified(__pyx_ptype_6gevent_10_semaphore_Semaphore); + + /* "gevent/_semaphore.py":136 + * self._dirty = True + * + * def unlink(self, callback): # <<<<<<<<<<<<<< + * """ + * unlink(callback) -> None + */ + __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6gevent_10_semaphore_9Semaphore_15unlink, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Semaphore_unlink, NULL, __pyx_n_s_gevent__semaphore, __pyx_d, ((PyObject *)__pyx_codeobj__14)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem((PyObject *)__pyx_ptype_6gevent_10_semaphore_Semaphore->tp_dict, __pyx_n_s_unlink, __pyx_t_1) < 0) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + PyType_Modified(__pyx_ptype_6gevent_10_semaphore_Semaphore); + + /* "gevent/_semaphore.py":177 + * self.unlink(switch) + * + * def wait(self, timeout=None): # <<<<<<<<<<<<<< + * """ + * wait(timeout=None) -> int + */ + __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6gevent_10_semaphore_9Semaphore_17wait, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Semaphore_wait, NULL, __pyx_n_s_gevent__semaphore, __pyx_d, ((PyObject *)__pyx_codeobj__16)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem((PyObject *)__pyx_ptype_6gevent_10_semaphore_Semaphore->tp_dict, __pyx_n_s_wait, __pyx_t_1) < 0) __PYX_ERR(0, 177, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + PyType_Modified(__pyx_ptype_6gevent_10_semaphore_Semaphore); + + /* "gevent/_semaphore.py":198 + * return self.counter + * + * def acquire(self, blocking=True, timeout=None): # <<<<<<<<<<<<<< + * """ + * acquire(blocking=True, timeout=None) -> bool + */ + __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6gevent_10_semaphore_9Semaphore_19acquire, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Semaphore_acquire, NULL, __pyx_n_s_gevent__semaphore, __pyx_d, ((PyObject *)__pyx_codeobj__18)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 198, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem((PyObject *)__pyx_ptype_6gevent_10_semaphore_Semaphore->tp_dict, __pyx_n_s_acquire, __pyx_t_1) < 0) __PYX_ERR(0, 198, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + PyType_Modified(__pyx_ptype_6gevent_10_semaphore_Semaphore); + + /* "gevent/_semaphore.py":237 + * return True + * + * _py3k_acquire = acquire # PyPy needs this; it must be static for Cython # <<<<<<<<<<<<<< + * + * def __enter__(self): + */ + __pyx_t_1 = __Pyx_GetNameInClass((PyObject *)__pyx_ptype_6gevent_10_semaphore_Semaphore, __pyx_n_s_acquire); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 237, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem((PyObject *)__pyx_ptype_6gevent_10_semaphore_Semaphore->tp_dict, __pyx_n_s_py3k_acquire, __pyx_t_1) < 0) __PYX_ERR(0, 237, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + PyType_Modified(__pyx_ptype_6gevent_10_semaphore_Semaphore); + + /* "gevent/_semaphore.py":239 + * _py3k_acquire = acquire # PyPy needs this; it must be static for Cython + * + * def __enter__(self): # <<<<<<<<<<<<<< + * self.acquire() + * + */ + __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6gevent_10_semaphore_9Semaphore_21__enter__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Semaphore___enter, NULL, __pyx_n_s_gevent__semaphore, __pyx_d, ((PyObject *)__pyx_codeobj__20)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 239, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem((PyObject *)__pyx_ptype_6gevent_10_semaphore_Semaphore->tp_dict, __pyx_n_s_enter, __pyx_t_1) < 0) __PYX_ERR(0, 239, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + PyType_Modified(__pyx_ptype_6gevent_10_semaphore_Semaphore); + + /* "gevent/_semaphore.py":242 + * self.acquire() + * + * def __exit__(self, t, v, tb): # <<<<<<<<<<<<<< + * self.release() + * + */ + __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6gevent_10_semaphore_9Semaphore_23__exit__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Semaphore___exit, NULL, __pyx_n_s_gevent__semaphore, __pyx_d, ((PyObject *)__pyx_codeobj__22)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem((PyObject *)__pyx_ptype_6gevent_10_semaphore_Semaphore->tp_dict, __pyx_n_s_exit, __pyx_t_1) < 0) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + PyType_Modified(__pyx_ptype_6gevent_10_semaphore_Semaphore); + + /* "gevent/_semaphore.py":260 + * + * #: For monkey-patching, allow changing the class of error we raise + * _OVER_RELEASE_ERROR = ValueError # <<<<<<<<<<<<<< + * + * def __init__(self, *args, **kwargs): + */ + if (PyDict_SetItem((PyObject *)__pyx_ptype_6gevent_10_semaphore_BoundedSemaphore->tp_dict, __pyx_n_s_OVER_RELEASE_ERROR, __pyx_builtin_ValueError) < 0) __PYX_ERR(0, 260, __pyx_L1_error) + PyType_Modified(__pyx_ptype_6gevent_10_semaphore_BoundedSemaphore); + + /* "gevent/_semaphore.py":266 + * self._initial_value = self.counter + * + * def release(self): # <<<<<<<<<<<<<< + * if self.counter >= self._initial_value: + * raise self._OVER_RELEASE_ERROR("Semaphore released too many times") + */ + __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6gevent_10_semaphore_16BoundedSemaphore_3release, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_BoundedSemaphore_release, NULL, __pyx_n_s_gevent__semaphore, __pyx_d, ((PyObject *)__pyx_codeobj__24)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 266, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem((PyObject *)__pyx_ptype_6gevent_10_semaphore_BoundedSemaphore->tp_dict, __pyx_n_s_release, __pyx_t_1) < 0) __PYX_ERR(0, 266, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + PyType_Modified(__pyx_ptype_6gevent_10_semaphore_BoundedSemaphore); + + /* "gevent/_semaphore.py":1 + * import sys # <<<<<<<<<<<<<< + * from gevent.hub import get_hub, getcurrent + * from gevent.timeout import Timeout + */ + __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /*--- Wrapped vars code ---*/ + + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + if (__pyx_m) { + if (__pyx_d) { + __Pyx_AddTraceback("init gevent._semaphore", __pyx_clineno, __pyx_lineno, __pyx_filename); + } + Py_DECREF(__pyx_m); __pyx_m = 0; + } else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_ImportError, "init gevent._semaphore"); + } + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + #if PY_MAJOR_VERSION < 3 + return; + #else + return __pyx_m; + #endif +} + +/* --- Runtime support code --- */ +/* Refnanny */ +#if CYTHON_REFNANNY +static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { + PyObject *m = NULL, *p = NULL; + void *r = NULL; + m = PyImport_ImportModule((char *)modname); + if (!m) goto end; + p = PyObject_GetAttrString(m, (char *)"RefNannyAPI"); + if (!p) goto end; + r = PyLong_AsVoidPtr(p); +end: + Py_XDECREF(p); + Py_XDECREF(m); + return (__Pyx_RefNannyAPIStruct *)r; +} +#endif + +/* GetBuiltinName */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name) { + PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); + if (unlikely(!result)) { + PyErr_Format(PyExc_NameError, +#if PY_MAJOR_VERSION >= 3 + "name '%U' is not defined", name); +#else + "name '%.200s' is not defined", PyString_AS_STRING(name)); +#endif + } + return result; +} + +/* RaiseDoubleKeywords */ +static void __Pyx_RaiseDoubleKeywordsError( + const char* func_name, + PyObject* kw_name) +{ + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION >= 3 + "%s() got multiple values for keyword argument '%U'", func_name, kw_name); + #else + "%s() got multiple values for keyword argument '%s'", func_name, + PyString_AsString(kw_name)); + #endif +} + +/* ParseKeywords */ +static int __Pyx_ParseOptionalKeywords( + PyObject *kwds, + PyObject **argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + const char* function_name) +{ + PyObject *key = 0, *value = 0; + Py_ssize_t pos = 0; + PyObject*** name; + PyObject*** first_kw_arg = argnames + num_pos_args; + while (PyDict_Next(kwds, &pos, &key, &value)) { + name = first_kw_arg; + while (*name && (**name != key)) name++; + if (*name) { + values[name-argnames] = value; + continue; + } + name = first_kw_arg; + #if PY_MAJOR_VERSION < 3 + if (likely(PyString_CheckExact(key)) || likely(PyString_Check(key))) { + while (*name) { + if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) + && _PyString_Eq(**name, key)) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + if ((**argname == key) || ( + (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) + && _PyString_Eq(**argname, key))) { + goto arg_passed_twice; + } + argname++; + } + } + } else + #endif + if (likely(PyUnicode_Check(key))) { + while (*name) { + int cmp = (**name == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (PyUnicode_GET_SIZE(**name) != PyUnicode_GET_SIZE(key)) ? 1 : + #endif + PyUnicode_Compare(**name, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + int cmp = (**argname == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (PyUnicode_GET_SIZE(**argname) != PyUnicode_GET_SIZE(key)) ? 1 : + #endif + PyUnicode_Compare(**argname, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) goto arg_passed_twice; + argname++; + } + } + } else + goto invalid_keyword_type; + if (kwds2) { + if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; + } else { + goto invalid_keyword; + } + } + return 0; +arg_passed_twice: + __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; +invalid_keyword_type: + PyErr_Format(PyExc_TypeError, + "%.200s() keywords must be strings", function_name); + goto bad; +invalid_keyword: + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION < 3 + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif +bad: + return -1; +} + +/* RaiseArgTupleInvalid */ +static void __Pyx_RaiseArgtupleInvalid( + const char* func_name, + int exact, + Py_ssize_t num_min, + Py_ssize_t num_max, + Py_ssize_t num_found) +{ + Py_ssize_t num_expected; + const char *more_or_less; + if (num_found < num_min) { + num_expected = num_min; + more_or_less = "at least"; + } else { + num_expected = num_max; + more_or_less = "at most"; + } + if (exact) { + more_or_less = "exactly"; + } + PyErr_Format(PyExc_TypeError, + "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", + func_name, more_or_less, num_expected, + (num_expected == 1) ? "" : "s", num_found); +} + +/* PyObjectCall */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *result; + ternaryfunc call = func->ob_type->tp_call; + if (unlikely(!call)) + return PyObject_Call(func, arg, kw); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = (*call)(func, arg, kw); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* PyErrFetchRestore */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + tmp_type = tstate->curexc_type; + tmp_value = tstate->curexc_value; + tmp_tb = tstate->curexc_traceback; + tstate->curexc_type = type; + tstate->curexc_value = value; + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +} +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + *type = tstate->curexc_type; + *value = tstate->curexc_value; + *tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +} +#endif + +/* RaiseException */ +#if PY_MAJOR_VERSION < 3 +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, + CYTHON_UNUSED PyObject *cause) { + __Pyx_PyThreadState_declare + Py_XINCREF(type); + if (!value || value == Py_None) + value = NULL; + else + Py_INCREF(value); + if (!tb || tb == Py_None) + tb = NULL; + else { + Py_INCREF(tb); + if (!PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto raise_error; + } + } + if (PyType_Check(type)) { +#if CYTHON_COMPILING_IN_PYPY + if (!value) { + Py_INCREF(Py_None); + value = Py_None; + } +#endif + PyErr_NormalizeException(&type, &value, &tb); + } else { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto raise_error; + } + value = type; + type = (PyObject*) Py_TYPE(type); + Py_INCREF(type); + if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto raise_error; + } + } + __Pyx_PyThreadState_assign + __Pyx_ErrRestore(type, value, tb); + return; +raise_error: + Py_XDECREF(value); + Py_XDECREF(type); + Py_XDECREF(tb); + return; +} +#else +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { + PyObject* owned_instance = NULL; + if (tb == Py_None) { + tb = 0; + } else if (tb && !PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto bad; + } + if (value == Py_None) + value = 0; + if (PyExceptionInstance_Check(type)) { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto bad; + } + value = type; + type = (PyObject*) Py_TYPE(value); + } else if (PyExceptionClass_Check(type)) { + PyObject *instance_class = NULL; + if (value && PyExceptionInstance_Check(value)) { + instance_class = (PyObject*) Py_TYPE(value); + if (instance_class != type) { + int is_subclass = PyObject_IsSubclass(instance_class, type); + if (!is_subclass) { + instance_class = NULL; + } else if (unlikely(is_subclass == -1)) { + goto bad; + } else { + type = instance_class; + } + } + } + if (!instance_class) { + PyObject *args; + if (!value) + args = PyTuple_New(0); + else if (PyTuple_Check(value)) { + Py_INCREF(value); + args = value; + } else + args = PyTuple_Pack(1, value); + if (!args) + goto bad; + owned_instance = PyObject_Call(type, args, NULL); + Py_DECREF(args); + if (!owned_instance) + goto bad; + value = owned_instance; + if (!PyExceptionInstance_Check(value)) { + PyErr_Format(PyExc_TypeError, + "calling %R should have returned an instance of " + "BaseException, not %R", + type, Py_TYPE(value)); + goto bad; + } + } + } else { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto bad; + } +#if PY_VERSION_HEX >= 0x03030000 + if (cause) { +#else + if (cause && cause != Py_None) { +#endif + PyObject *fixed_cause; + if (cause == Py_None) { + fixed_cause = NULL; + } else if (PyExceptionClass_Check(cause)) { + fixed_cause = PyObject_CallObject(cause, NULL); + if (fixed_cause == NULL) + goto bad; + } else if (PyExceptionInstance_Check(cause)) { + fixed_cause = cause; + Py_INCREF(fixed_cause); + } else { + PyErr_SetString(PyExc_TypeError, + "exception causes must derive from " + "BaseException"); + goto bad; + } + PyException_SetCause(value, fixed_cause); + } + PyErr_SetObject(type, value); + if (tb) { +#if CYTHON_COMPILING_IN_PYPY + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); + Py_INCREF(tb); + PyErr_Restore(tmp_type, tmp_value, tb); + Py_XDECREF(tmp_tb); +#else + PyThreadState *tstate = PyThreadState_GET(); + PyObject* tmp_tb = tstate->curexc_traceback; + if (tb != tmp_tb) { + Py_INCREF(tb); + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_tb); + } +#endif + } +bad: + Py_XDECREF(owned_instance); + return; +} +#endif + +/* PyCFunctionFastCall */ + #if CYTHON_FAST_PYCCALL +static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) { + PyCFunctionObject *func = (PyCFunctionObject*)func_obj; + PyCFunction meth = PyCFunction_GET_FUNCTION(func); + PyObject *self = PyCFunction_GET_SELF(func); + assert(PyCFunction_Check(func)); + assert(METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST))); + assert(nargs >= 0); + assert(nargs == 0 || args != NULL); + /* _PyCFunction_FastCallDict() must not be called with an exception set, + because it may clear it (directly or indirectly) and so the + caller loses its exception */ + assert(!PyErr_Occurred()); + return (*((__Pyx_PyCFunctionFast)meth)) (self, args, nargs, NULL); +} +#endif // CYTHON_FAST_PYCCALL + +/* PyFunctionFastCall */ + #if CYTHON_FAST_PYCALL +#include "frameobject.h" +static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, + PyObject *globals) { + PyFrameObject *f; + PyThreadState *tstate = PyThreadState_GET(); + PyObject **fastlocals; + Py_ssize_t i; + PyObject *result; + assert(globals != NULL); + /* XXX Perhaps we should create a specialized + PyFrame_New() that doesn't take locals, but does + take builtins without sanity checking them. + */ + assert(tstate != NULL); + f = PyFrame_New(tstate, co, globals, NULL); + if (f == NULL) { + return NULL; + } + fastlocals = f->f_localsplus; + for (i = 0; i < na; i++) { + Py_INCREF(*args); + fastlocals[i] = *args++; + } + result = PyEval_EvalFrameEx(f,0); + ++tstate->recursion_depth; + Py_DECREF(f); + --tstate->recursion_depth; + return result; +} +#if 1 || PY_VERSION_HEX < 0x030600B1 +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, int nargs, PyObject *kwargs) { + PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); + PyObject *globals = PyFunction_GET_GLOBALS(func); + PyObject *argdefs = PyFunction_GET_DEFAULTS(func); + PyObject *closure; +#if PY_MAJOR_VERSION >= 3 + PyObject *kwdefs; +#endif + PyObject *kwtuple, **k; + PyObject **d; + Py_ssize_t nd; + Py_ssize_t nk; + PyObject *result; + assert(kwargs == NULL || PyDict_Check(kwargs)); + nk = kwargs ? PyDict_Size(kwargs) : 0; + if (Py_EnterRecursiveCall((char*)" while calling a Python object")) { + return NULL; + } + if ( +#if PY_MAJOR_VERSION >= 3 + co->co_kwonlyargcount == 0 && +#endif + likely(kwargs == NULL || nk == 0) && + co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { + if (argdefs == NULL && co->co_argcount == nargs) { + result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); + goto done; + } + else if (nargs == 0 && argdefs != NULL + && co->co_argcount == Py_SIZE(argdefs)) { + /* function called with no arguments, but all parameters have + a default value: use default values as arguments .*/ + args = &PyTuple_GET_ITEM(argdefs, 0); + result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); + goto done; + } + } + if (kwargs != NULL) { + Py_ssize_t pos, i; + kwtuple = PyTuple_New(2 * nk); + if (kwtuple == NULL) { + result = NULL; + goto done; + } + k = &PyTuple_GET_ITEM(kwtuple, 0); + pos = i = 0; + while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { + Py_INCREF(k[i]); + Py_INCREF(k[i+1]); + i += 2; + } + nk = i / 2; + } + else { + kwtuple = NULL; + k = NULL; + } + closure = PyFunction_GET_CLOSURE(func); +#if PY_MAJOR_VERSION >= 3 + kwdefs = PyFunction_GET_KW_DEFAULTS(func); +#endif + if (argdefs != NULL) { + d = &PyTuple_GET_ITEM(argdefs, 0); + nd = Py_SIZE(argdefs); + } + else { + d = NULL; + nd = 0; + } +#if PY_MAJOR_VERSION >= 3 + result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, + args, nargs, + k, (int)nk, + d, (int)nd, kwdefs, closure); +#else + result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, + args, nargs, + k, (int)nk, + d, (int)nd, closure); +#endif + Py_XDECREF(kwtuple); +done: + Py_LeaveRecursiveCall(); + return result; +} +#endif // CPython < 3.6 +#endif // CYTHON_FAST_PYCALL + +/* PyObjectCallMethO */ + #if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { + PyObject *self, *result; + PyCFunction cfunc; + cfunc = PyCFunction_GET_FUNCTION(func); + self = PyCFunction_GET_SELF(func); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = cfunc(self, arg); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* PyObjectCallOneArg */ + #if CYTHON_COMPILING_IN_CPYTHON +static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_New(1); + if (unlikely(!args)) return NULL; + Py_INCREF(arg); + PyTuple_SET_ITEM(args, 0, arg); + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { +#if CYTHON_FAST_PYCALL + if (PyFunction_Check(func)) { + return __Pyx_PyFunction_FastCall(func, &arg, 1); + } +#endif +#ifdef __Pyx_CyFunction_USED + if (likely(PyCFunction_Check(func) || PyObject_TypeCheck(func, __pyx_CyFunctionType))) { +#else + if (likely(PyCFunction_Check(func))) { +#endif + if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { + return __Pyx_PyObject_CallMethO(func, arg); +#if CYTHON_FAST_PYCCALL + } else if (PyCFunction_GET_FLAGS(func) & METH_FASTCALL) { + return __Pyx_PyCFunction_FastCall(func, &arg, 1); +#endif + } + } + return __Pyx__PyObject_CallOneArg(func, arg); +} +#else +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_Pack(1, arg); + if (unlikely(!args)) return NULL; + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +#endif + +/* PyObjectCallNoArg */ + #if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { +#if CYTHON_FAST_PYCALL + if (PyFunction_Check(func)) { + return __Pyx_PyFunction_FastCall(func, NULL, 0); + } +#endif +#ifdef __Pyx_CyFunction_USED + if (likely(PyCFunction_Check(func) || PyObject_TypeCheck(func, __pyx_CyFunctionType))) { +#else + if (likely(PyCFunction_Check(func))) { +#endif + if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) { + return __Pyx_PyObject_CallMethO(func, NULL); + } + } + return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL); +} +#endif + +/* WriteUnraisableException */ + static void __Pyx_WriteUnraisable(const char *name, CYTHON_UNUSED int clineno, + CYTHON_UNUSED int lineno, CYTHON_UNUSED const char *filename, + int full_traceback, CYTHON_UNUSED int nogil) { + PyObject *old_exc, *old_val, *old_tb; + PyObject *ctx; + __Pyx_PyThreadState_declare +#ifdef WITH_THREAD + PyGILState_STATE state; + if (nogil) + state = PyGILState_Ensure(); +#ifdef _MSC_VER + else state = (PyGILState_STATE)-1; +#endif +#endif + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&old_exc, &old_val, &old_tb); + if (full_traceback) { + Py_XINCREF(old_exc); + Py_XINCREF(old_val); + Py_XINCREF(old_tb); + __Pyx_ErrRestore(old_exc, old_val, old_tb); + PyErr_PrintEx(1); + } + #if PY_MAJOR_VERSION < 3 + ctx = PyString_FromString(name); + #else + ctx = PyUnicode_FromString(name); + #endif + __Pyx_ErrRestore(old_exc, old_val, old_tb); + if (!ctx) { + PyErr_WriteUnraisable(Py_None); + } else { + PyErr_WriteUnraisable(ctx); + Py_DECREF(ctx); + } +#ifdef WITH_THREAD + if (nogil) + PyGILState_Release(state); +#endif +} + +/* GetModuleGlobalName */ + static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name) { + PyObject *result; +#if !CYTHON_AVOID_BORROWED_REFS + result = PyDict_GetItem(__pyx_d, name); + if (likely(result)) { + Py_INCREF(result); + } else { +#else + result = PyObject_GetItem(__pyx_d, name); + if (!result) { + PyErr_Clear(); +#endif + result = __Pyx_GetBuiltinName(name); + } + return result; +} + +/* SaveResetException */ + #if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + *type = tstate->exc_type; + *value = tstate->exc_value; + *tb = tstate->exc_traceback; + Py_XINCREF(*type); + Py_XINCREF(*value); + Py_XINCREF(*tb); +} +static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = type; + tstate->exc_value = value; + tstate->exc_traceback = tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +} +#endif + +/* GetException */ + #if CYTHON_FAST_THREAD_STATE +static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { +#else +static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) { +#endif + PyObject *local_type, *local_value, *local_tb; +#if CYTHON_FAST_THREAD_STATE + PyObject *tmp_type, *tmp_value, *tmp_tb; + local_type = tstate->curexc_type; + local_value = tstate->curexc_value; + local_tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +#else + PyErr_Fetch(&local_type, &local_value, &local_tb); +#endif + PyErr_NormalizeException(&local_type, &local_value, &local_tb); +#if CYTHON_FAST_THREAD_STATE + if (unlikely(tstate->curexc_type)) +#else + if (unlikely(PyErr_Occurred())) +#endif + goto bad; + #if PY_MAJOR_VERSION >= 3 + if (local_tb) { + if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) + goto bad; + } + #endif + Py_XINCREF(local_tb); + Py_XINCREF(local_type); + Py_XINCREF(local_value); + *type = local_type; + *value = local_value; + *tb = local_tb; +#if CYTHON_FAST_THREAD_STATE + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = local_type; + tstate->exc_value = local_value; + tstate->exc_traceback = local_tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +#else + PyErr_SetExcInfo(local_type, local_value, local_tb); +#endif + return 0; +bad: + *type = 0; + *value = 0; + *tb = 0; + Py_XDECREF(local_type); + Py_XDECREF(local_value); + Py_XDECREF(local_tb); + return -1; +} + +/* SwapException */ + #if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = *type; + tstate->exc_value = *value; + tstate->exc_traceback = *tb; + *type = tmp_type; + *value = tmp_value; + *tb = tmp_tb; +} +#else +static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_GetExcInfo(&tmp_type, &tmp_value, &tmp_tb); + PyErr_SetExcInfo(*type, *value, *tb); + *type = tmp_type; + *value = tmp_value; + *tb = tmp_tb; +} +#endif + +/* PyObjectCallMethod1 */ + static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg) { + PyObject *method, *result = NULL; + method = __Pyx_PyObject_GetAttrStr(obj, method_name); + if (unlikely(!method)) goto done; +#if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(method))) { + PyObject *self = PyMethod_GET_SELF(method); + if (likely(self)) { + PyObject *args; + PyObject *function = PyMethod_GET_FUNCTION(method); + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(function)) { + PyObject *args[2] = {self, arg}; + result = __Pyx_PyFunction_FastCall(function, args, 2); + goto done; + } + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(function)) { + PyObject *args[2] = {self, arg}; + result = __Pyx_PyCFunction_FastCall(function, args, 2); + goto done; + } + #endif + args = PyTuple_New(2); + if (unlikely(!args)) goto done; + Py_INCREF(self); + PyTuple_SET_ITEM(args, 0, self); + Py_INCREF(arg); + PyTuple_SET_ITEM(args, 1, arg); + Py_INCREF(function); + Py_DECREF(method); method = NULL; + result = __Pyx_PyObject_Call(function, args, NULL); + Py_DECREF(args); + Py_DECREF(function); + return result; + } + } +#endif + result = __Pyx_PyObject_CallOneArg(method, arg); +done: + Py_XDECREF(method); + return result; +} + +/* append */ + static CYTHON_INLINE int __Pyx_PyObject_Append(PyObject* L, PyObject* x) { + if (likely(PyList_CheckExact(L))) { + if (unlikely(__Pyx_PyList_Append(L, x) < 0)) return -1; + } else { + PyObject* retval = __Pyx_PyObject_CallMethod1(L, __pyx_n_s_append, x); + if (unlikely(!retval)) + return -1; + Py_DECREF(retval); + } + return 0; +} + +/* PyErrExceptionMatches */ + #if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) { + PyObject *exc_type = tstate->curexc_type; + if (exc_type == err) return 1; + if (unlikely(!exc_type)) return 0; + return PyErr_GivenExceptionMatches(exc_type, err); +} +#endif + +/* KeywordStringCheck */ + static CYTHON_INLINE int __Pyx_CheckKeywordStrings( + PyObject *kwdict, + const char* function_name, + int kw_allowed) +{ + PyObject* key = 0; + Py_ssize_t pos = 0; +#if CYTHON_COMPILING_IN_PYPY + if (!kw_allowed && PyDict_Next(kwdict, &pos, &key, 0)) + goto invalid_keyword; + return 1; +#else + while (PyDict_Next(kwdict, &pos, &key, 0)) { + #if PY_MAJOR_VERSION < 3 + if (unlikely(!PyString_CheckExact(key)) && unlikely(!PyString_Check(key))) + #endif + if (unlikely(!PyUnicode_Check(key))) + goto invalid_keyword_type; + } + if ((!kw_allowed) && unlikely(key)) + goto invalid_keyword; + return 1; +invalid_keyword_type: + PyErr_Format(PyExc_TypeError, + "%.200s() keywords must be strings", function_name); + return 0; +#endif +invalid_keyword: + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION < 3 + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif + return 0; +} + +/* SetVTable */ + static int __Pyx_SetVtable(PyObject *dict, void *vtable) { +#if PY_VERSION_HEX >= 0x02070000 + PyObject *ob = PyCapsule_New(vtable, 0, 0); +#else + PyObject *ob = PyCObject_FromVoidPtr(vtable, 0); +#endif + if (!ob) + goto bad; + if (PyDict_SetItem(dict, __pyx_n_s_pyx_vtable, ob) < 0) + goto bad; + Py_DECREF(ob); + return 0; +bad: + Py_XDECREF(ob); + return -1; +} + +/* Import */ + static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { + PyObject *empty_list = 0; + PyObject *module = 0; + PyObject *global_dict = 0; + PyObject *empty_dict = 0; + PyObject *list; + #if PY_VERSION_HEX < 0x03030000 + PyObject *py_import; + py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); + if (!py_import) + goto bad; + #endif + if (from_list) + list = from_list; + else { + empty_list = PyList_New(0); + if (!empty_list) + goto bad; + list = empty_list; + } + global_dict = PyModule_GetDict(__pyx_m); + if (!global_dict) + goto bad; + empty_dict = PyDict_New(); + if (!empty_dict) + goto bad; + { + #if PY_MAJOR_VERSION >= 3 + if (level == -1) { + if (strchr(__Pyx_MODULE_NAME, '.')) { + #if PY_VERSION_HEX < 0x03030000 + PyObject *py_level = PyInt_FromLong(1); + if (!py_level) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, global_dict, empty_dict, list, py_level, NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, 1); + #endif + if (!module) { + if (!PyErr_ExceptionMatches(PyExc_ImportError)) + goto bad; + PyErr_Clear(); + } + } + level = 0; + } + #endif + if (!module) { + #if PY_VERSION_HEX < 0x03030000 + PyObject *py_level = PyInt_FromLong(level); + if (!py_level) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, global_dict, empty_dict, list, py_level, NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, level); + #endif + } + } +bad: + #if PY_VERSION_HEX < 0x03030000 + Py_XDECREF(py_import); + #endif + Py_XDECREF(empty_list); + Py_XDECREF(empty_dict); + return module; +} + +/* ImportFrom */ + static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { + PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); + if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Format(PyExc_ImportError, + #if PY_MAJOR_VERSION < 3 + "cannot import name %.230s", PyString_AS_STRING(name)); + #else + "cannot import name %S", name); + #endif + } + return value; +} + +/* FetchCommonType */ + static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) { + PyObject* fake_module; + PyTypeObject* cached_type = NULL; + fake_module = PyImport_AddModule((char*) "_cython_" CYTHON_ABI); + if (!fake_module) return NULL; + Py_INCREF(fake_module); + cached_type = (PyTypeObject*) PyObject_GetAttrString(fake_module, type->tp_name); + if (cached_type) { + if (!PyType_Check((PyObject*)cached_type)) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s is not a type object", + type->tp_name); + goto bad; + } + if (cached_type->tp_basicsize != type->tp_basicsize) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s has the wrong size, try recompiling", + type->tp_name); + goto bad; + } + } else { + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; + PyErr_Clear(); + if (PyType_Ready(type) < 0) goto bad; + if (PyObject_SetAttrString(fake_module, type->tp_name, (PyObject*) type) < 0) + goto bad; + Py_INCREF(type); + cached_type = type; + } +done: + Py_DECREF(fake_module); + return cached_type; +bad: + Py_XDECREF(cached_type); + cached_type = NULL; + goto done; +} + +/* CythonFunction */ + static PyObject * +__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *closure) +{ + if (unlikely(op->func_doc == NULL)) { + if (op->func.m_ml->ml_doc) { +#if PY_MAJOR_VERSION >= 3 + op->func_doc = PyUnicode_FromString(op->func.m_ml->ml_doc); +#else + op->func_doc = PyString_FromString(op->func.m_ml->ml_doc); +#endif + if (unlikely(op->func_doc == NULL)) + return NULL; + } else { + Py_INCREF(Py_None); + return Py_None; + } + } + Py_INCREF(op->func_doc); + return op->func_doc; +} +static int +__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value) +{ + PyObject *tmp = op->func_doc; + if (value == NULL) { + value = Py_None; + } + Py_INCREF(value); + op->func_doc = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op) +{ + if (unlikely(op->func_name == NULL)) { +#if PY_MAJOR_VERSION >= 3 + op->func_name = PyUnicode_InternFromString(op->func.m_ml->ml_name); +#else + op->func_name = PyString_InternFromString(op->func.m_ml->ml_name); +#endif + if (unlikely(op->func_name == NULL)) + return NULL; + } + Py_INCREF(op->func_name); + return op->func_name; +} +static int +__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value) +{ + PyObject *tmp; +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) { +#else + if (unlikely(value == NULL || !PyString_Check(value))) { +#endif + PyErr_SetString(PyExc_TypeError, + "__name__ must be set to a string object"); + return -1; + } + tmp = op->func_name; + Py_INCREF(value); + op->func_name = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op) +{ + Py_INCREF(op->func_qualname); + return op->func_qualname; +} +static int +__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value) +{ + PyObject *tmp; +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) { +#else + if (unlikely(value == NULL || !PyString_Check(value))) { +#endif + PyErr_SetString(PyExc_TypeError, + "__qualname__ must be set to a string object"); + return -1; + } + tmp = op->func_qualname; + Py_INCREF(value); + op->func_qualname = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_self(__pyx_CyFunctionObject *m, CYTHON_UNUSED void *closure) +{ + PyObject *self; + self = m->func_closure; + if (self == NULL) + self = Py_None; + Py_INCREF(self); + return self; +} +static PyObject * +__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op) +{ + if (unlikely(op->func_dict == NULL)) { + op->func_dict = PyDict_New(); + if (unlikely(op->func_dict == NULL)) + return NULL; + } + Py_INCREF(op->func_dict); + return op->func_dict; +} +static int +__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value) +{ + PyObject *tmp; + if (unlikely(value == NULL)) { + PyErr_SetString(PyExc_TypeError, + "function's dictionary may not be deleted"); + return -1; + } + if (unlikely(!PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "setting function's dictionary to a non-dict"); + return -1; + } + tmp = op->func_dict; + Py_INCREF(value); + op->func_dict = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op) +{ + Py_INCREF(op->func_globals); + return op->func_globals; +} +static PyObject * +__Pyx_CyFunction_get_closure(CYTHON_UNUSED __pyx_CyFunctionObject *op) +{ + Py_INCREF(Py_None); + return Py_None; +} +static PyObject * +__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op) +{ + PyObject* result = (op->func_code) ? op->func_code : Py_None; + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) { + int result = 0; + PyObject *res = op->defaults_getter((PyObject *) op); + if (unlikely(!res)) + return -1; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + op->defaults_tuple = PyTuple_GET_ITEM(res, 0); + Py_INCREF(op->defaults_tuple); + op->defaults_kwdict = PyTuple_GET_ITEM(res, 1); + Py_INCREF(op->defaults_kwdict); + #else + op->defaults_tuple = PySequence_ITEM(res, 0); + if (unlikely(!op->defaults_tuple)) result = -1; + else { + op->defaults_kwdict = PySequence_ITEM(res, 1); + if (unlikely(!op->defaults_kwdict)) result = -1; + } + #endif + Py_DECREF(res); + return result; +} +static int +__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value) { + PyObject* tmp; + if (!value) { + value = Py_None; + } else if (value != Py_None && !PyTuple_Check(value)) { + PyErr_SetString(PyExc_TypeError, + "__defaults__ must be set to a tuple object"); + return -1; + } + Py_INCREF(value); + tmp = op->defaults_tuple; + op->defaults_tuple = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op) { + PyObject* result = op->defaults_tuple; + if (unlikely(!result)) { + if (op->defaults_getter) { + if (__Pyx_CyFunction_init_defaults(op) < 0) return NULL; + result = op->defaults_tuple; + } else { + result = Py_None; + } + } + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value) { + PyObject* tmp; + if (!value) { + value = Py_None; + } else if (value != Py_None && !PyDict_Check(value)) { + PyErr_SetString(PyExc_TypeError, + "__kwdefaults__ must be set to a dict object"); + return -1; + } + Py_INCREF(value); + tmp = op->defaults_kwdict; + op->defaults_kwdict = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op) { + PyObject* result = op->defaults_kwdict; + if (unlikely(!result)) { + if (op->defaults_getter) { + if (__Pyx_CyFunction_init_defaults(op) < 0) return NULL; + result = op->defaults_kwdict; + } else { + result = Py_None; + } + } + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value) { + PyObject* tmp; + if (!value || value == Py_None) { + value = NULL; + } else if (!PyDict_Check(value)) { + PyErr_SetString(PyExc_TypeError, + "__annotations__ must be set to a dict object"); + return -1; + } + Py_XINCREF(value); + tmp = op->func_annotations; + op->func_annotations = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op) { + PyObject* result = op->func_annotations; + if (unlikely(!result)) { + result = PyDict_New(); + if (unlikely(!result)) return NULL; + op->func_annotations = result; + } + Py_INCREF(result); + return result; +} +static PyGetSetDef __pyx_CyFunction_getsets[] = { + {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {(char *) "__doc__", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0}, + {(char *) "__self__", (getter)__Pyx_CyFunction_get_self, 0, 0, 0}, + {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0}, + {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0}, + {0, 0, 0, 0, 0} +}; +static PyMemberDef __pyx_CyFunction_members[] = { + {(char *) "__module__", T_OBJECT, offsetof(__pyx_CyFunctionObject, func.m_module), PY_WRITE_RESTRICTED, 0}, + {0, 0, 0, 0, 0} +}; +static PyObject * +__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, CYTHON_UNUSED PyObject *args) +{ +#if PY_MAJOR_VERSION >= 3 + return PyUnicode_FromString(m->func.m_ml->ml_name); +#else + return PyString_FromString(m->func.m_ml->ml_name); +#endif +} +static PyMethodDef __pyx_CyFunction_methods[] = { + {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0}, + {0, 0, 0, 0} +}; +#if PY_VERSION_HEX < 0x030500A0 +#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist) +#else +#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func.m_weakreflist) +#endif +static PyObject *__Pyx_CyFunction_New(PyTypeObject *type, PyMethodDef *ml, int flags, PyObject* qualname, + PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { + __pyx_CyFunctionObject *op = PyObject_GC_New(__pyx_CyFunctionObject, type); + if (op == NULL) + return NULL; + op->flags = flags; + __Pyx_CyFunction_weakreflist(op) = NULL; + op->func.m_ml = ml; + op->func.m_self = (PyObject *) op; + Py_XINCREF(closure); + op->func_closure = closure; + Py_XINCREF(module); + op->func.m_module = module; + op->func_dict = NULL; + op->func_name = NULL; + Py_INCREF(qualname); + op->func_qualname = qualname; + op->func_doc = NULL; + op->func_classobj = NULL; + op->func_globals = globals; + Py_INCREF(op->func_globals); + Py_XINCREF(code); + op->func_code = code; + op->defaults_pyobjects = 0; + op->defaults = NULL; + op->defaults_tuple = NULL; + op->defaults_kwdict = NULL; + op->defaults_getter = NULL; + op->func_annotations = NULL; + PyObject_GC_Track(op); + return (PyObject *) op; +} +static int +__Pyx_CyFunction_clear(__pyx_CyFunctionObject *m) +{ + Py_CLEAR(m->func_closure); + Py_CLEAR(m->func.m_module); + Py_CLEAR(m->func_dict); + Py_CLEAR(m->func_name); + Py_CLEAR(m->func_qualname); + Py_CLEAR(m->func_doc); + Py_CLEAR(m->func_globals); + Py_CLEAR(m->func_code); + Py_CLEAR(m->func_classobj); + Py_CLEAR(m->defaults_tuple); + Py_CLEAR(m->defaults_kwdict); + Py_CLEAR(m->func_annotations); + if (m->defaults) { + PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); + int i; + for (i = 0; i < m->defaults_pyobjects; i++) + Py_XDECREF(pydefaults[i]); + PyObject_Free(m->defaults); + m->defaults = NULL; + } + return 0; +} +static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m) +{ + PyObject_GC_UnTrack(m); + if (__Pyx_CyFunction_weakreflist(m) != NULL) + PyObject_ClearWeakRefs((PyObject *) m); + __Pyx_CyFunction_clear(m); + PyObject_GC_Del(m); +} +static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg) +{ + Py_VISIT(m->func_closure); + Py_VISIT(m->func.m_module); + Py_VISIT(m->func_dict); + Py_VISIT(m->func_name); + Py_VISIT(m->func_qualname); + Py_VISIT(m->func_doc); + Py_VISIT(m->func_globals); + Py_VISIT(m->func_code); + Py_VISIT(m->func_classobj); + Py_VISIT(m->defaults_tuple); + Py_VISIT(m->defaults_kwdict); + if (m->defaults) { + PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); + int i; + for (i = 0; i < m->defaults_pyobjects; i++) + Py_VISIT(pydefaults[i]); + } + return 0; +} +static PyObject *__Pyx_CyFunction_descr_get(PyObject *func, PyObject *obj, PyObject *type) +{ + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + if (m->flags & __Pyx_CYFUNCTION_STATICMETHOD) { + Py_INCREF(func); + return func; + } + if (m->flags & __Pyx_CYFUNCTION_CLASSMETHOD) { + if (type == NULL) + type = (PyObject *)(Py_TYPE(obj)); + return __Pyx_PyMethod_New(func, type, (PyObject *)(Py_TYPE(type))); + } + if (obj == Py_None) + obj = NULL; + return __Pyx_PyMethod_New(func, obj, type); +} +static PyObject* +__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op) +{ +#if PY_MAJOR_VERSION >= 3 + return PyUnicode_FromFormat("", + op->func_qualname, (void *)op); +#else + return PyString_FromFormat("", + PyString_AsString(op->func_qualname), (void *)op); +#endif +} +static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) { + PyCFunctionObject* f = (PyCFunctionObject*)func; + PyCFunction meth = f->m_ml->ml_meth; + Py_ssize_t size; + switch (f->m_ml->ml_flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) { + case METH_VARARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) + return (*meth)(self, arg); + break; + case METH_VARARGS | METH_KEYWORDS: + return (*(PyCFunctionWithKeywords)meth)(self, arg, kw); + case METH_NOARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { + size = PyTuple_GET_SIZE(arg); + if (likely(size == 0)) + return (*meth)(self, NULL); + PyErr_Format(PyExc_TypeError, + "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", + f->m_ml->ml_name, size); + return NULL; + } + break; + case METH_O: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { + size = PyTuple_GET_SIZE(arg); + if (likely(size == 1)) { + PyObject *result, *arg0 = PySequence_ITEM(arg, 0); + if (unlikely(!arg0)) return NULL; + result = (*meth)(self, arg0); + Py_DECREF(arg0); + return result; + } + PyErr_Format(PyExc_TypeError, + "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", + f->m_ml->ml_name, size); + return NULL; + } + break; + default: + PyErr_SetString(PyExc_SystemError, "Bad call flags in " + "__Pyx_CyFunction_Call. METH_OLDARGS is no " + "longer supported!"); + return NULL; + } + PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments", + f->m_ml->ml_name); + return NULL; +} +static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) { + return __Pyx_CyFunction_CallMethod(func, ((PyCFunctionObject*)func)->m_self, arg, kw); +} +static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) { + PyObject *result; + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func; + if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { + Py_ssize_t argc; + PyObject *new_args; + PyObject *self; + argc = PyTuple_GET_SIZE(args); + new_args = PyTuple_GetSlice(args, 1, argc); + if (unlikely(!new_args)) + return NULL; + self = PyTuple_GetItem(args, 0); + if (unlikely(!self)) { + Py_DECREF(new_args); + return NULL; + } + result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw); + Py_DECREF(new_args); + } else { + result = __Pyx_CyFunction_Call(func, args, kw); + } + return result; +} +static PyTypeObject __pyx_CyFunctionType_type = { + PyVarObject_HEAD_INIT(0, 0) + "cython_function_or_method", + sizeof(__pyx_CyFunctionObject), + 0, + (destructor) __Pyx_CyFunction_dealloc, + 0, + 0, + 0, +#if PY_MAJOR_VERSION < 3 + 0, +#else + 0, +#endif + (reprfunc) __Pyx_CyFunction_repr, + 0, + 0, + 0, + 0, + __Pyx_CyFunction_CallAsMethod, + 0, + 0, + 0, + 0, + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, + 0, + (traverseproc) __Pyx_CyFunction_traverse, + (inquiry) __Pyx_CyFunction_clear, + 0, +#if PY_VERSION_HEX < 0x030500A0 + offsetof(__pyx_CyFunctionObject, func_weakreflist), +#else + offsetof(PyCFunctionObject, m_weakreflist), +#endif + 0, + 0, + __pyx_CyFunction_methods, + __pyx_CyFunction_members, + __pyx_CyFunction_getsets, + 0, + 0, + __Pyx_CyFunction_descr_get, + 0, + offsetof(__pyx_CyFunctionObject, func_dict), + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, +#if PY_VERSION_HEX >= 0x030400a1 + 0, +#endif +}; +static int __pyx_CyFunction_init(void) { + __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type); + if (__pyx_CyFunctionType == NULL) { + return -1; + } + return 0; +} +static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults = PyObject_Malloc(size); + if (!m->defaults) + return PyErr_NoMemory(); + memset(m->defaults, 0, size); + m->defaults_pyobjects = pyobjects; + return m->defaults; +} +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults_tuple = tuple; + Py_INCREF(tuple); +} +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults_kwdict = dict; + Py_INCREF(dict); +} +static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->func_annotations = dict; + Py_INCREF(dict); +} + +/* GetNameInClass */ + static PyObject *__Pyx_GetNameInClass(PyObject *nmspace, PyObject *name) { + PyObject *result; + result = __Pyx_PyObject_GetAttrStr(nmspace, name); + if (!result) + result = __Pyx_GetModuleGlobalName(name); + return result; +} + +/* CodeObjectCache */ + static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { + int start = 0, mid = 0, end = count - 1; + if (end >= 0 && code_line > entries[end].code_line) { + return count; + } + while (start < end) { + mid = start + (end - start) / 2; + if (code_line < entries[mid].code_line) { + end = mid; + } else if (code_line > entries[mid].code_line) { + start = mid + 1; + } else { + return mid; + } + } + if (code_line <= entries[mid].code_line) { + return mid; + } else { + return mid + 1; + } +} +static PyCodeObject *__pyx_find_code_object(int code_line) { + PyCodeObject* code_object; + int pos; + if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { + return NULL; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { + return NULL; + } + code_object = __pyx_code_cache.entries[pos].code_object; + Py_INCREF(code_object); + return code_object; +} +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { + int pos, i; + __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; + if (unlikely(!code_line)) { + return; + } + if (unlikely(!entries)) { + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); + if (likely(entries)) { + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = 64; + __pyx_code_cache.count = 1; + entries[0].code_line = code_line; + entries[0].code_object = code_object; + Py_INCREF(code_object); + } + return; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { + PyCodeObject* tmp = entries[pos].code_object; + entries[pos].code_object = code_object; + Py_DECREF(tmp); + return; + } + if (__pyx_code_cache.count == __pyx_code_cache.max_count) { + int new_max = __pyx_code_cache.max_count + 64; + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( + __pyx_code_cache.entries, (size_t)new_max*sizeof(__Pyx_CodeObjectCacheEntry)); + if (unlikely(!entries)) { + return; + } + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = new_max; + } + for (i=__pyx_code_cache.count; i>pos; i--) { + entries[i] = entries[i-1]; + } + entries[pos].code_line = code_line; + entries[pos].code_object = code_object; + __pyx_code_cache.count++; + Py_INCREF(code_object); +} + +/* AddTraceback */ + #include "compile.h" +#include "frameobject.h" +#include "traceback.h" +static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( + const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyObject *py_srcfile = 0; + PyObject *py_funcname = 0; + #if PY_MAJOR_VERSION < 3 + py_srcfile = PyString_FromString(filename); + #else + py_srcfile = PyUnicode_FromString(filename); + #endif + if (!py_srcfile) goto bad; + if (c_line) { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #else + py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #endif + } + else { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromString(funcname); + #else + py_funcname = PyUnicode_FromString(funcname); + #endif + } + if (!py_funcname) goto bad; + py_code = __Pyx_PyCode_New( + 0, + 0, + 0, + 0, + 0, + __pyx_empty_bytes, /*PyObject *code,*/ + __pyx_empty_tuple, /*PyObject *consts,*/ + __pyx_empty_tuple, /*PyObject *names,*/ + __pyx_empty_tuple, /*PyObject *varnames,*/ + __pyx_empty_tuple, /*PyObject *freevars,*/ + __pyx_empty_tuple, /*PyObject *cellvars,*/ + py_srcfile, /*PyObject *filename,*/ + py_funcname, /*PyObject *name,*/ + py_line, + __pyx_empty_bytes /*PyObject *lnotab*/ + ); + Py_DECREF(py_srcfile); + Py_DECREF(py_funcname); + return py_code; +bad: + Py_XDECREF(py_srcfile); + Py_XDECREF(py_funcname); + return NULL; +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyFrameObject *py_frame = 0; + py_code = __pyx_find_code_object(c_line ? c_line : py_line); + if (!py_code) { + py_code = __Pyx_CreateCodeObjectForTraceback( + funcname, c_line, py_line, filename); + if (!py_code) goto bad; + __pyx_insert_code_object(c_line ? c_line : py_line, py_code); + } + py_frame = PyFrame_New( + PyThreadState_GET(), /*PyThreadState *tstate,*/ + py_code, /*PyCodeObject *code,*/ + __pyx_d, /*PyObject *globals,*/ + 0 /*PyObject *locals*/ + ); + if (!py_frame) goto bad; + __Pyx_PyFrame_SetLineNumber(py_frame, py_line); + PyTraceBack_Here(py_frame); +bad: + Py_XDECREF(py_code); + Py_XDECREF(py_frame); +} + +/* CIntFromPyVerify */ + #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) +#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) +#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ + {\ + func_type value = func_value;\ + if (sizeof(target_type) < sizeof(func_type)) {\ + if (unlikely(value != (func_type) (target_type) value)) {\ + func_type zero = 0;\ + if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ + return (target_type) -1;\ + if (is_unsigned && unlikely(value < zero))\ + goto raise_neg_overflow;\ + else\ + goto raise_overflow;\ + }\ + }\ + return (target_type) value;\ + } + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { + const int neg_one = (int) -1, const_zero = (int) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(int) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(int) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(int) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(int), + little, !is_unsigned); + } +} + +/* CIntFromPy */ + static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { + const int neg_one = (int) -1, const_zero = (int) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(int) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (int) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { + return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { + return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { + return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(int) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) + case -2: + if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + } +#endif + if (sizeof(int) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + int val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (int) -1; + } + } else { + int val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (int) -1; + val = __Pyx_PyInt_As_int(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to int"); + return (int) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to int"); + return (int) -1; +} + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { + const long neg_one = (long) -1, const_zero = (long) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(long) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(long) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(long) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(long), + little, !is_unsigned); + } +} + +/* CIntFromPy */ + static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { + const long neg_one = (long) -1, const_zero = (long) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(long) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (long) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { + return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { + return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { + return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (long) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(long) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) + case -2: + if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + } +#endif + if (sizeof(long) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + long val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (long) -1; + } + } else { + long val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (long) -1; + val = __Pyx_PyInt_As_long(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to long"); + return (long) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to long"); + return (long) -1; +} + +/* CheckBinaryVersion */ + static int __Pyx_check_binary_version(void) { + char ctversion[4], rtversion[4]; + PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); + PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion()); + if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) { + char message[200]; + PyOS_snprintf(message, sizeof(message), + "compiletime version %s of module '%.100s' " + "does not match runtime version %s", + ctversion, __Pyx_MODULE_NAME, rtversion); + return PyErr_WarnEx(NULL, message, 1); + } + return 0; +} + +/* InitStrings */ + static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { + while (t->p) { + #if PY_MAJOR_VERSION < 3 + if (t->is_unicode) { + *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); + } else if (t->intern) { + *t->p = PyString_InternFromString(t->s); + } else { + *t->p = PyString_FromStringAndSize(t->s, t->n - 1); + } + #else + if (t->is_unicode | t->is_str) { + if (t->intern) { + *t->p = PyUnicode_InternFromString(t->s); + } else if (t->encoding) { + *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); + } else { + *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); + } + } else { + *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); + } + #endif + if (!*t->p) + return -1; + ++t; + } + return 0; +} + +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { + return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); +} +static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject* o) { + Py_ssize_t ignore; + return __Pyx_PyObject_AsStringAndSize(o, &ignore); +} +static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { +#if CYTHON_COMPILING_IN_CPYTHON && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) + if ( +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + __Pyx_sys_getdefaultencoding_not_ascii && +#endif + PyUnicode_Check(o)) { +#if PY_VERSION_HEX < 0x03030000 + char* defenc_c; + PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); + if (!defenc) return NULL; + defenc_c = PyBytes_AS_STRING(defenc); +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + { + char* end = defenc_c + PyBytes_GET_SIZE(defenc); + char* c; + for (c = defenc_c; c < end; c++) { + if ((unsigned char) (*c) >= 128) { + PyUnicode_AsASCIIString(o); + return NULL; + } + } + } +#endif + *length = PyBytes_GET_SIZE(defenc); + return defenc_c; +#else + if (__Pyx_PyUnicode_READY(o) == -1) return NULL; +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + if (PyUnicode_IS_ASCII(o)) { + *length = PyUnicode_GET_LENGTH(o); + return PyUnicode_AsUTF8(o); + } else { + PyUnicode_AsASCIIString(o); + return NULL; + } +#else + return PyUnicode_AsUTF8AndSize(o, length); +#endif +#endif + } else +#endif +#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) + if (PyByteArray_Check(o)) { + *length = PyByteArray_GET_SIZE(o); + return PyByteArray_AS_STRING(o); + } else +#endif + { + char* result; + int r = PyBytes_AsStringAndSize(o, &result, length); + if (unlikely(r < 0)) { + return NULL; + } else { + return result; + } + } +} +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { + int is_true = x == Py_True; + if (is_true | (x == Py_False) | (x == Py_None)) return is_true; + else return PyObject_IsTrue(x); +} +static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { +#if CYTHON_USE_TYPE_SLOTS + PyNumberMethods *m; +#endif + const char *name = NULL; + PyObject *res = NULL; +#if PY_MAJOR_VERSION < 3 + if (PyInt_Check(x) || PyLong_Check(x)) +#else + if (PyLong_Check(x)) +#endif + return __Pyx_NewRef(x); +#if CYTHON_USE_TYPE_SLOTS + m = Py_TYPE(x)->tp_as_number; + #if PY_MAJOR_VERSION < 3 + if (m && m->nb_int) { + name = "int"; + res = PyNumber_Int(x); + } + else if (m && m->nb_long) { + name = "long"; + res = PyNumber_Long(x); + } + #else + if (m && m->nb_int) { + name = "int"; + res = PyNumber_Long(x); + } + #endif +#else + res = PyNumber_Int(x); +#endif + if (res) { +#if PY_MAJOR_VERSION < 3 + if (!PyInt_Check(res) && !PyLong_Check(res)) { +#else + if (!PyLong_Check(res)) { +#endif + PyErr_Format(PyExc_TypeError, + "__%.4s__ returned non-%.4s (type %.200s)", + name, name, Py_TYPE(res)->tp_name); + Py_DECREF(res); + return NULL; + } + } + else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, + "an integer is required"); + } + return res; +} +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { + Py_ssize_t ival; + PyObject *x; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(b))) { + if (sizeof(Py_ssize_t) >= sizeof(long)) + return PyInt_AS_LONG(b); + else + return PyInt_AsSsize_t(x); + } +#endif + if (likely(PyLong_CheckExact(b))) { + #if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)b)->ob_digit; + const Py_ssize_t size = Py_SIZE(b); + if (likely(__Pyx_sst_abs(size) <= 1)) { + ival = likely(size) ? digits[0] : 0; + if (size == -1) ival = -ival; + return ival; + } else { + switch (size) { + case 2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + } + } + #endif + return PyLong_AsSsize_t(b); + } + x = PyNumber_Index(b); + if (!x) return -1; + ival = PyInt_AsSsize_t(x); + Py_DECREF(x); + return ival; +} +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { + return PyInt_FromSize_t(ival); +} + + +#endif /* Py_PYTHON_H */ diff --git a/python/gevent/gevent.ares.c b/python/gevent/gevent.ares.c new file mode 100644 index 0000000..e1680ce --- /dev/null +++ b/python/gevent/gevent.ares.c @@ -0,0 +1,14103 @@ +/* Generated by Cython 0.25.2 */ + +#define PY_SSIZE_T_CLEAN +#include "Python.h" +#ifndef Py_PYTHON_H + #error Python headers needed to compile C extensions, please install development version of Python. +#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03020000) + #error Cython requires Python 2.6+ or Python 3.2+. +#else +#define CYTHON_ABI "0_25_2" +#include +#ifndef offsetof + #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) +#endif +#if !defined(WIN32) && !defined(MS_WINDOWS) + #ifndef __stdcall + #define __stdcall + #endif + #ifndef __cdecl + #define __cdecl + #endif + #ifndef __fastcall + #define __fastcall + #endif +#endif +#ifndef DL_IMPORT + #define DL_IMPORT(t) t +#endif +#ifndef DL_EXPORT + #define DL_EXPORT(t) t +#endif +#ifndef HAVE_LONG_LONG + #if PY_VERSION_HEX >= 0x03030000 || (PY_MAJOR_VERSION == 2 && PY_VERSION_HEX >= 0x02070000) + #define HAVE_LONG_LONG + #endif +#endif +#ifndef PY_LONG_LONG + #define PY_LONG_LONG LONG_LONG +#endif +#ifndef Py_HUGE_VAL + #define Py_HUGE_VAL HUGE_VAL +#endif +#ifdef PYPY_VERSION + #define CYTHON_COMPILING_IN_PYPY 1 + #define CYTHON_COMPILING_IN_PYSTON 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #undef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 1 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 +#elif defined(PYSTON_VERSION) + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_PYSTON 1 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 +#else + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_PYSTON 0 + #define CYTHON_COMPILING_IN_CPYTHON 1 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #if PY_MAJOR_VERSION < 3 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #elif !defined(CYTHON_USE_ASYNC_SLOTS) + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #if PY_VERSION_HEX < 0x02070000 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #elif !defined(CYTHON_USE_PYLONG_INTERNALS) + #define CYTHON_USE_PYLONG_INTERNALS 1 + #endif + #ifndef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 1 + #endif + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #if PY_VERSION_HEX < 0x030300F0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #elif !defined(CYTHON_USE_UNICODE_WRITER) + #define CYTHON_USE_UNICODE_WRITER 1 + #endif + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #ifndef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 1 + #endif + #ifndef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 1 + #endif +#endif +#if !defined(CYTHON_FAST_PYCCALL) +#define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) +#endif +#if CYTHON_USE_PYLONG_INTERNALS + #include "longintrepr.h" + #undef SHIFT + #undef BASE + #undef MASK +#endif +#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) + #define Py_OptimizeFlag 0 +#endif +#define __PYX_BUILD_PY_SSIZE_T "n" +#define CYTHON_FORMAT_SSIZE_T "z" +#if PY_MAJOR_VERSION < 3 + #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) + #define __Pyx_DefaultClassType PyClass_Type +#else + #define __Pyx_BUILTIN_MODULE_NAME "builtins" + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) + #define __Pyx_DefaultClassType PyType_Type +#endif +#ifndef Py_TPFLAGS_CHECKTYPES + #define Py_TPFLAGS_CHECKTYPES 0 +#endif +#ifndef Py_TPFLAGS_HAVE_INDEX + #define Py_TPFLAGS_HAVE_INDEX 0 +#endif +#ifndef Py_TPFLAGS_HAVE_NEWBUFFER + #define Py_TPFLAGS_HAVE_NEWBUFFER 0 +#endif +#ifndef Py_TPFLAGS_HAVE_FINALIZE + #define Py_TPFLAGS_HAVE_FINALIZE 0 +#endif +#ifndef METH_FASTCALL + #define METH_FASTCALL 0x80 + typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject **args, + Py_ssize_t nargs, PyObject *kwnames); +#else + #define __Pyx_PyCFunctionFast _PyCFunctionFast +#endif +#if CYTHON_FAST_PYCCALL +#define __Pyx_PyFastCFunction_Check(func)\ + ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST))))) +#else +#define __Pyx_PyFastCFunction_Check(func) 0 +#endif +#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) + #define CYTHON_PEP393_ENABLED 1 + #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ + 0 : _PyUnicode_Ready((PyObject *)(op))) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) + #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) + #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) + #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) +#else + #define CYTHON_PEP393_ENABLED 0 + #define PyUnicode_1BYTE_KIND 1 + #define PyUnicode_2BYTE_KIND 2 + #define PyUnicode_4BYTE_KIND 4 + #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111) + #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) + #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) + #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = ch) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) +#endif +#if CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) +#else + #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ + PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) + #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check) + #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format) + #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) + #define PyObject_Malloc(s) PyMem_Malloc(s) + #define PyObject_Free(p) PyMem_Free(p) + #define PyObject_Realloc(p) PyMem_Realloc(p) +#endif +#if CYTHON_COMPILING_IN_PYSTON + #define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno) +#else + #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) +#endif +#define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) +#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) +#else + #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) +#endif +#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII) + #define PyObject_ASCII(o) PyObject_Repr(o) +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBaseString_Type PyUnicode_Type + #define PyStringObject PyUnicodeObject + #define PyString_Type PyUnicode_Type + #define PyString_Check PyUnicode_Check + #define PyString_CheckExact PyUnicode_CheckExact +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) + #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) +#else + #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) + #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) +#endif +#ifndef PySet_CheckExact + #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) +#endif +#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) +#define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) +#if PY_MAJOR_VERSION >= 3 + #define PyIntObject PyLongObject + #define PyInt_Type PyLong_Type + #define PyInt_Check(op) PyLong_Check(op) + #define PyInt_CheckExact(op) PyLong_CheckExact(op) + #define PyInt_FromString PyLong_FromString + #define PyInt_FromUnicode PyLong_FromUnicode + #define PyInt_FromLong PyLong_FromLong + #define PyInt_FromSize_t PyLong_FromSize_t + #define PyInt_FromSsize_t PyLong_FromSsize_t + #define PyInt_AsLong PyLong_AsLong + #define PyInt_AS_LONG PyLong_AS_LONG + #define PyInt_AsSsize_t PyLong_AsSsize_t + #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask + #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask + #define PyNumber_Int PyNumber_Long +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBoolObject PyLongObject +#endif +#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY + #ifndef PyUnicode_InternFromString + #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) + #endif +#endif +#if PY_VERSION_HEX < 0x030200A4 + typedef long Py_hash_t; + #define __Pyx_PyInt_FromHash_t PyInt_FromLong + #define __Pyx_PyInt_AsHash_t PyInt_AsLong +#else + #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t + #define __Pyx_PyInt_AsHash_t PyInt_AsSsize_t +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : PyInstanceMethod_New(func)) +#else + #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) +#endif +#if CYTHON_USE_ASYNC_SLOTS + #if PY_VERSION_HEX >= 0x030500B1 + #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods + #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) + #else + typedef struct { + unaryfunc am_await; + unaryfunc am_aiter; + unaryfunc am_anext; + } __Pyx_PyAsyncMethodsStruct; + #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) + #endif +#else + #define __Pyx_PyType_AsAsync(obj) NULL +#endif +#ifndef CYTHON_RESTRICT + #if defined(__GNUC__) + #define CYTHON_RESTRICT __restrict__ + #elif defined(_MSC_VER) && _MSC_VER >= 1400 + #define CYTHON_RESTRICT __restrict + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_RESTRICT restrict + #else + #define CYTHON_RESTRICT + #endif +#endif +#ifndef CYTHON_UNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +#endif +#ifndef CYTHON_MAYBE_UNUSED_VAR +# if defined(__cplusplus) + template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } +# else +# define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) +# endif +#endif +#ifndef CYTHON_NCP_UNUSED +# if CYTHON_COMPILING_IN_CPYTHON +# define CYTHON_NCP_UNUSED +# else +# define CYTHON_NCP_UNUSED CYTHON_UNUSED +# endif +#endif +#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) + +#ifndef CYTHON_INLINE + #if defined(__clang__) + #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) + #elif defined(__GNUC__) + #define CYTHON_INLINE __inline__ + #elif defined(_MSC_VER) + #define CYTHON_INLINE __inline + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_INLINE inline + #else + #define CYTHON_INLINE + #endif +#endif + +#if defined(WIN32) || defined(MS_WINDOWS) + #define _USE_MATH_DEFINES +#endif +#include +#ifdef NAN +#define __PYX_NAN() ((float) NAN) +#else +static CYTHON_INLINE float __PYX_NAN() { + float value; + memset(&value, 0xFF, sizeof(value)); + return value; +} +#endif +#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) +#define __Pyx_truncl trunc +#else +#define __Pyx_truncl truncl +#endif + + +#define __PYX_ERR(f_index, lineno, Ln_error) \ +{ \ + __pyx_filename = __pyx_f[f_index]; __pyx_lineno = lineno; __pyx_clineno = __LINE__; goto Ln_error; \ +} + +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) +#else + #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) +#endif + +#ifndef __PYX_EXTERN_C + #ifdef __cplusplus + #define __PYX_EXTERN_C extern "C" + #else + #define __PYX_EXTERN_C extern + #endif +#endif + +#define __PYX_HAVE__gevent__ares +#define __PYX_HAVE_API__gevent__ares +#include "ares.h" +#include "cares_pton.h" +#include "frameobject.h" +#include "dnshelper.c" +#ifdef _OPENMP +#include +#endif /* _OPENMP */ + +#ifdef PYREX_WITHOUT_ASSERTIONS +#define CYTHON_WITHOUT_ASSERTIONS +#endif + +typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding; + const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; + +#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 +#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT 0 +#define __PYX_DEFAULT_STRING_ENCODING "" +#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString +#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#define __Pyx_uchar_cast(c) ((unsigned char)c) +#define __Pyx_long_cast(x) ((long)x) +#define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ + (sizeof(type) < sizeof(Py_ssize_t)) ||\ + (sizeof(type) > sizeof(Py_ssize_t) &&\ + likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX) &&\ + (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ + v == (type)PY_SSIZE_T_MIN))) ||\ + (sizeof(type) == sizeof(Py_ssize_t) &&\ + (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX))) ) +#if defined (__cplusplus) && __cplusplus >= 201103L + #include + #define __Pyx_sst_abs(value) std::abs(value) +#elif SIZEOF_INT >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) abs(value) +#elif SIZEOF_LONG >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) labs(value) +#elif defined (_MSC_VER) && defined (_M_X64) + #define __Pyx_sst_abs(value) _abs64(value) +#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define __Pyx_sst_abs(value) llabs(value) +#elif defined (__GNUC__) + #define __Pyx_sst_abs(value) __builtin_llabs(value) +#else + #define __Pyx_sst_abs(value) ((value<0) ? -value : value) +#endif +static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject*); +static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); +#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) +#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) +#define __Pyx_PyBytes_FromString PyBytes_FromString +#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); +#if PY_MAJOR_VERSION < 3 + #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#else + #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize +#endif +#define __Pyx_PyObject_AsSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) +#define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) +#define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) +#define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) +#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) +#if PY_MAJOR_VERSION < 3 +static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) +{ + const Py_UNICODE *u_end = u; + while (*u_end++) ; + return (size_t)(u_end - u - 1); +} +#else +#define __Pyx_Py_UNICODE_strlen Py_UNICODE_strlen +#endif +#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) +#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode +#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode +#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) +#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) +#define __Pyx_PyBool_FromLong(b) ((b) ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False)) +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); +static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); +#if CYTHON_ASSUME_SAFE_MACROS +#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) +#else +#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) +#endif +#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) +#if PY_MAJOR_VERSION >= 3 +#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) +#else +#define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) +#endif +#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x)) +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII +static int __Pyx_sys_getdefaultencoding_not_ascii; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + PyObject* ascii_chars_u = NULL; + PyObject* ascii_chars_b = NULL; + const char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + if (strcmp(default_encoding_c, "ascii") == 0) { + __Pyx_sys_getdefaultencoding_not_ascii = 0; + } else { + char ascii_chars[128]; + int c; + for (c = 0; c < 128; c++) { + ascii_chars[c] = c; + } + __Pyx_sys_getdefaultencoding_not_ascii = 1; + ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); + if (!ascii_chars_u) goto bad; + ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); + if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { + PyErr_Format( + PyExc_ValueError, + "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", + default_encoding_c); + goto bad; + } + Py_DECREF(ascii_chars_u); + Py_DECREF(ascii_chars_b); + } + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + Py_XDECREF(ascii_chars_u); + Py_XDECREF(ascii_chars_b); + return -1; +} +#endif +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) +#else +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +static char* __PYX_DEFAULT_STRING_ENCODING; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c)); + if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; + strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + return -1; +} +#endif +#endif + + +/* Test for GCC > 2.95 */ +#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) + #define likely(x) __builtin_expect(!!(x), 1) + #define unlikely(x) __builtin_expect(!!(x), 0) +#else /* !__GNUC__ or GCC < 2.95 */ + #define likely(x) (x) + #define unlikely(x) (x) +#endif /* __GNUC__ */ + +static PyObject *__pyx_m; +static PyObject *__pyx_d; +static PyObject *__pyx_b; +static PyObject *__pyx_empty_tuple; +static PyObject *__pyx_empty_bytes; +static PyObject *__pyx_empty_unicode; +static int __pyx_lineno; +static int __pyx_clineno = 0; +static const char * __pyx_cfilenm= __FILE__; +static const char *__pyx_filename; + + +static const char *__pyx_f[] = { + "src\\gevent\\ares.pyx", +}; + +/*--- Type declarations ---*/ +struct __pyx_obj_6gevent_4ares_result; +struct PyGeventAresChannelObject; +struct __pyx_opt_args_6gevent_4ares__convert_cares_flags; + +/* "gevent/ares.pyx":137 + * + * + * cpdef _convert_cares_flags(int flags, int default=cares.ARES_NI_LOOKUPHOST|cares.ARES_NI_LOOKUPSERVICE): # <<<<<<<<<<<<<< + * if _cares_flag_map is None: + * _prepare_cares_flag_map() + */ +struct __pyx_opt_args_6gevent_4ares__convert_cares_flags { + int __pyx_n; + int __pyx_default; +}; + +/* "gevent/ares.pyx":164 + * + * + * cdef class result: # <<<<<<<<<<<<<< + * cdef public object value + * cdef public object exception + */ +struct __pyx_obj_6gevent_4ares_result { + PyObject_HEAD + PyObject *value; + PyObject *exception; +}; + + +/* "gevent/ares.pyx":245 + * + * + * cdef public class channel [object PyGeventAresChannelObject, type PyGeventAresChannel_Type]: # <<<<<<<<<<<<<< + * + * cdef public object loop + */ +struct PyGeventAresChannelObject { + PyObject_HEAD + struct __pyx_vtabstruct_6gevent_4ares_channel *__pyx_vtab; + PyObject *loop; + struct ares_channeldata *channel; + PyObject *_watchers; + PyObject *_timer; +}; + +__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyGeventAresChannel_Type; + +__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyGeventAresChannel_Type; + +struct __pyx_vtabstruct_6gevent_4ares_channel { + PyObject *(*_sock_state_callback)(struct PyGeventAresChannelObject *, int, int, int); + PyObject *(*_getnameinfo)(struct PyGeventAresChannelObject *, PyObject *, PyObject *, int, int __pyx_skip_dispatch); +}; +static struct __pyx_vtabstruct_6gevent_4ares_channel *__pyx_vtabptr_6gevent_4ares_channel; + +/* --- Runtime support code (head) --- */ +/* Refnanny.proto */ +#ifndef CYTHON_REFNANNY + #define CYTHON_REFNANNY 0 +#endif +#if CYTHON_REFNANNY + typedef struct { + void (*INCREF)(void*, PyObject*, int); + void (*DECREF)(void*, PyObject*, int); + void (*GOTREF)(void*, PyObject*, int); + void (*GIVEREF)(void*, PyObject*, int); + void* (*SetupContext)(const char*, int, const char*); + void (*FinishContext)(void**); + } __Pyx_RefNannyAPIStruct; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); + #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; +#ifdef WITH_THREAD + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + if (acquire_gil) {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + PyGILState_Release(__pyx_gilstate_save);\ + } else {\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + } +#else + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) +#endif + #define __Pyx_RefNannyFinishContext()\ + __Pyx_RefNanny->FinishContext(&__pyx_refnanny) + #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) + #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) + #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) + #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) +#else + #define __Pyx_RefNannyDeclarations + #define __Pyx_RefNannySetupContext(name, acquire_gil) + #define __Pyx_RefNannyFinishContext() + #define __Pyx_INCREF(r) Py_INCREF(r) + #define __Pyx_DECREF(r) Py_DECREF(r) + #define __Pyx_GOTREF(r) + #define __Pyx_GIVEREF(r) + #define __Pyx_XINCREF(r) Py_XINCREF(r) + #define __Pyx_XDECREF(r) Py_XDECREF(r) + #define __Pyx_XGOTREF(r) + #define __Pyx_XGIVEREF(r) +#endif +#define __Pyx_XDECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_XDECREF(tmp);\ + } while (0) +#define __Pyx_DECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_DECREF(tmp);\ + } while (0) +#define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) +#define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) + +/* PyObjectGetAttrStr.proto */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro)) + return tp->tp_getattro(obj, attr_name); +#if PY_MAJOR_VERSION < 3 + if (likely(tp->tp_getattr)) + return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); +#endif + return PyObject_GetAttr(obj, attr_name); +} +#else +#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) +#endif + +/* GetBuiltinName.proto */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name); + +/* Import.proto */ +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); + +/* GetAttr.proto */ +static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *); + +/* GetAttr3.proto */ +static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *, PyObject *, PyObject *); + +/* GetModuleGlobalName.proto */ +static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name); + +/* RaiseTooManyValuesToUnpack.proto */ +static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); + +/* RaiseNeedMoreValuesToUnpack.proto */ +static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); + +/* IterFinish.proto */ +static CYTHON_INLINE int __Pyx_IterFinish(void); + +/* UnpackItemEndCheck.proto */ +static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected); + +/* PyFunctionFastCall.proto */ +#if CYTHON_FAST_PYCALL +#define __Pyx_PyFunction_FastCall(func, args, nargs)\ + __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) +#if 1 || PY_VERSION_HEX < 0x030600B1 +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, int nargs, PyObject *kwargs); +#else +#define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs) +#endif +#endif + +/* PyCFunctionFastCall.proto */ +#if CYTHON_FAST_PYCCALL +static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs); +#else +#define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL) +#endif + +/* PyObjectCall.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); +#else +#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) +#endif + +/* PyThreadStateGet.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; +#define __Pyx_PyThreadState_assign __pyx_tstate = PyThreadState_GET(); +#else +#define __Pyx_PyThreadState_declare +#define __Pyx_PyThreadState_assign +#endif + +/* PyErrFetchRestore.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#else +#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) +#endif + +/* RaiseException.proto */ +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); + +/* RaiseDoubleKeywords.proto */ +static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); + +/* ParseKeywords.proto */ +static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ + PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ + const char* function_name); + +/* RaiseArgTupleInvalid.proto */ +static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, + Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); + +/* PyObjectCallMethO.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); +#endif + +/* PyObjectCallOneArg.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); + +/* WriteUnraisableException.proto */ +static void __Pyx_WriteUnraisable(const char *name, int clineno, + int lineno, const char *filename, + int full_traceback, int nogil); + +/* PyObjectSetAttrStr.proto */ +#if CYTHON_USE_TYPE_SLOTS +#define __Pyx_PyObject_DelAttrStr(o,n) __Pyx_PyObject_SetAttrStr(o,n,NULL) +static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr_name, PyObject* value) { + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_setattro)) + return tp->tp_setattro(obj, attr_name, value); +#if PY_MAJOR_VERSION < 3 + if (likely(tp->tp_setattr)) + return tp->tp_setattr(obj, PyString_AS_STRING(attr_name), value); +#endif + return PyObject_SetAttr(obj, attr_name, value); +} +#else +#define __Pyx_PyObject_DelAttrStr(o,n) PyObject_DelAttr(o,n) +#define __Pyx_PyObject_SetAttrStr(o,n,v) PyObject_SetAttr(o,n,v) +#endif + +/* RaiseNoneIterError.proto */ +static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); + +/* ExtTypeTest.proto */ +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); + +/* SaveResetException.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#define __Pyx_ExceptionReset(type, value, tb) __Pyx__ExceptionReset(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +#else +#define __Pyx_ExceptionSave(type, value, tb) PyErr_GetExcInfo(type, value, tb) +#define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb) +#endif + +/* GetException.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb) +static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#else +static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); +#endif + +/* PyObjectCallNoArg.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); +#else +#define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL) +#endif + +/* GetItemInt.proto */ +#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\ + (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\ + __Pyx_GetItemInt_Generic(o, to_py_func(i)))) +#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ + (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck); +#define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ + (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL)) +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck); +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, + int is_list, int wraparound, int boundscheck); + +/* pyobject_as_double.proto */ +static double __Pyx__PyObject_AsDouble(PyObject* obj); +#if CYTHON_COMPILING_IN_PYPY +#define __Pyx_PyObject_AsDouble(obj)\ +(likely(PyFloat_CheckExact(obj)) ? PyFloat_AS_DOUBLE(obj) :\ + likely(PyInt_CheckExact(obj)) ?\ + PyFloat_AsDouble(obj) : __Pyx__PyObject_AsDouble(obj)) +#else +#define __Pyx_PyObject_AsDouble(obj)\ +((likely(PyFloat_CheckExact(obj))) ?\ + PyFloat_AS_DOUBLE(obj) : __Pyx__PyObject_AsDouble(obj)) +#endif + +/* py_dict_clear.proto */ +#define __Pyx_PyDict_Clear(d) (PyDict_Clear(d), 0) + +/* SwapException.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_ExceptionSwap(type, value, tb) __Pyx__ExceptionSwap(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#else +static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb); +#endif + +/* dict_getitem_default.proto */ +static PyObject* __Pyx_PyDict_GetItemDefault(PyObject* d, PyObject* key, PyObject* default_value); + +/* ArgTypeTest.proto */ +static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed, + const char *name, int exact); + +/* PyErrExceptionMatches.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) +static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); +#else +#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) +#endif + +/* SetVTable.proto */ +static int __Pyx_SetVtable(PyObject *dict, void *vtable); + +/* ImportFrom.proto */ +static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); + +/* CalculateMetaclass.proto */ +static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases); + +/* Py3ClassCreate.proto */ +static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name, PyObject *qualname, + PyObject *mkw, PyObject *modname, PyObject *doc); +static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases, PyObject *dict, + PyObject *mkw, int calculate_metaclass, int allow_py2_metaclass); + +/* FetchCommonType.proto */ +static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type); + +/* CythonFunction.proto */ +#define __Pyx_CyFunction_USED 1 +#include +#define __Pyx_CYFUNCTION_STATICMETHOD 0x01 +#define __Pyx_CYFUNCTION_CLASSMETHOD 0x02 +#define __Pyx_CYFUNCTION_CCLASS 0x04 +#define __Pyx_CyFunction_GetClosure(f)\ + (((__pyx_CyFunctionObject *) (f))->func_closure) +#define __Pyx_CyFunction_GetClassObj(f)\ + (((__pyx_CyFunctionObject *) (f))->func_classobj) +#define __Pyx_CyFunction_Defaults(type, f)\ + ((type *)(((__pyx_CyFunctionObject *) (f))->defaults)) +#define __Pyx_CyFunction_SetDefaultsGetter(f, g)\ + ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g) +typedef struct { + PyCFunctionObject func; +#if PY_VERSION_HEX < 0x030500A0 + PyObject *func_weakreflist; +#endif + PyObject *func_dict; + PyObject *func_name; + PyObject *func_qualname; + PyObject *func_doc; + PyObject *func_globals; + PyObject *func_code; + PyObject *func_closure; + PyObject *func_classobj; + void *defaults; + int defaults_pyobjects; + int flags; + PyObject *defaults_tuple; + PyObject *defaults_kwdict; + PyObject *(*defaults_getter)(PyObject *); + PyObject *func_annotations; +} __pyx_CyFunctionObject; +static PyTypeObject *__pyx_CyFunctionType = 0; +#define __Pyx_CyFunction_NewEx(ml, flags, qualname, self, module, globals, code)\ + __Pyx_CyFunction_New(__pyx_CyFunctionType, ml, flags, qualname, self, module, globals, code) +static PyObject *__Pyx_CyFunction_New(PyTypeObject *, PyMethodDef *ml, + int flags, PyObject* qualname, + PyObject *self, + PyObject *module, PyObject *globals, + PyObject* code); +static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *m, + size_t size, + int pyobjects); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m, + PyObject *tuple); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m, + PyObject *dict); +static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m, + PyObject *dict); +static int __pyx_CyFunction_init(void); + +/* CodeObjectCache.proto */ +typedef struct { + PyCodeObject* code_object; + int code_line; +} __Pyx_CodeObjectCacheEntry; +struct __Pyx_CodeObjectCache { + int count; + int max_count; + __Pyx_CodeObjectCacheEntry* entries; +}; +static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); +static PyCodeObject *__pyx_find_code_object(int code_line); +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); + +/* AddTraceback.proto */ +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); + +/* CIntFromPy.proto */ +static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); + +/* CIntFromPy.proto */ +static CYTHON_INLINE unsigned short __Pyx_PyInt_As_unsigned_short(PyObject *); + +/* CIntFromPy.proto */ +static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); + +/* CheckBinaryVersion.proto */ +static int __Pyx_check_binary_version(void); + +/* InitStrings.proto */ +static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); + +static PyObject *__pyx_f_6gevent_4ares_7channel__sock_state_callback(struct PyGeventAresChannelObject *__pyx_v_self, int __pyx_v_socket, int __pyx_v_read, int __pyx_v_write); /* proto*/ +static PyObject *__pyx_f_6gevent_4ares_7channel__getnameinfo(struct PyGeventAresChannelObject *__pyx_v_self, PyObject *__pyx_v_callback, PyObject *__pyx_v_sockaddr, int __pyx_v_flags, int __pyx_skip_dispatch); /* proto*/ + +/* Module declarations from 'gevent.cares' */ + +/* Module declarations from 'gevent.python' */ + +/* Module declarations from 'gevent.ares' */ +static PyTypeObject *__pyx_ptype_6gevent_4ares_result = 0; +static PyTypeObject *__pyx_ptype_6gevent_4ares_channel = 0; +static PyObject *__pyx_v_6gevent_4ares_string_types = 0; +static PyObject *__pyx_v_6gevent_4ares_text_type = 0; +static PyObject *__pyx_f_6gevent_4ares__prepare_cares_flag_map(void); /*proto*/ +static PyObject *__pyx_f_6gevent_4ares__convert_cares_flags(int, int __pyx_skip_dispatch, struct __pyx_opt_args_6gevent_4ares__convert_cares_flags *__pyx_optional_args); /*proto*/ +static PyObject *__pyx_f_6gevent_4ares_strerror(PyObject *, int __pyx_skip_dispatch); /*proto*/ +static void __pyx_f_6gevent_4ares_gevent_sock_state_callback(void *, int, int, int); /*proto*/ +static void __pyx_f_6gevent_4ares_gevent_ares_host_callback(void *, int, int, struct hostent *); /*proto*/ +static void __pyx_f_6gevent_4ares_gevent_ares_nameinfo_callback(void *, int, int, char *, char *); /*proto*/ +#define __Pyx_MODULE_NAME "gevent.ares" +int __pyx_module_is_main_gevent__ares = 0; + +/* Implementation of 'gevent.ares' */ +static PyObject *__pyx_builtin_ValueError; +static PyObject *__pyx_builtin_id; +static PyObject *__pyx_builtin_MemoryError; +static PyObject *__pyx_builtin_TypeError; +static const char __pyx_k__2[] = ","; +static const char __pyx_k_fd[] = "fd"; +static const char __pyx_k_id[] = "id"; +static const char __pyx_k_io[] = "io"; +static const char __pyx_k_all[] = "__all__"; +static const char __pyx_k_cls[] = "cls"; +static const char __pyx_k_doc[] = "__doc__"; +static const char __pyx_k_get[] = "get"; +static const char __pyx_k_new[] = "__new__"; +static const char __pyx_k_pop[] = "pop"; +static const char __pyx_k_s_r[] = "%s(%r)"; +static const char __pyx_k_s_s[] = "%s: %s"; +static const char __pyx_k_sys[] = "sys"; +static const char __pyx_k_addr[] = "addr"; +static const char __pyx_k_loop[] = "loop"; +static const char __pyx_k_main[] = "__main__"; +static const char __pyx_k_name[] = "__name__"; +static const char __pyx_k_self[] = "self"; +static const char __pyx_k_stop[] = "stop"; +static const char __pyx_k_test[] = "__test__"; +static const char __pyx_k_again[] = "again"; +static const char __pyx_k_ascii[] = "ascii"; +static const char __pyx_k_class[] = "__class__"; +static const char __pyx_k_flags[] = "flags"; +static const char __pyx_k_ndots[] = "ndots"; +static const char __pyx_k_split[] = "split"; +static const char __pyx_k_start[] = "start"; +static const char __pyx_k_timer[] = "timer"; +static const char __pyx_k_tries[] = "tries"; +static const char __pyx_k_value[] = "value"; +static const char __pyx_k_encode[] = "encode"; +static const char __pyx_k_events[] = "events"; +static const char __pyx_k_family[] = "family"; +static const char __pyx_k_import[] = "__import__"; +static const char __pyx_k_module[] = "__module__"; +static const char __pyx_k_name_2[] = "name"; +static const char __pyx_k_socket[] = "_socket"; +static const char __pyx_k_TIMEOUT[] = "TIMEOUT"; +static const char __pyx_k_channel[] = "channel"; +static const char __pyx_k_default[] = "default"; +static const char __pyx_k_destroy[] = "destroy"; +static const char __pyx_k_prepare[] = "__prepare__"; +static const char __pyx_k_servers[] = "servers"; +static const char __pyx_k_timeout[] = "timeout"; +static const char __pyx_k_unicode[] = "unicode"; +static const char __pyx_k_watcher[] = "watcher"; +static const char __pyx_k_ARES_EOF[] = "ARES_EOF"; +static const char __pyx_k_NI_DGRAM[] = "NI_DGRAM"; +static const char __pyx_k_builtins[] = "__builtins__"; +static const char __pyx_k_callback[] = "callback"; +static const char __pyx_k_exc_info[] = "exc_info"; +static const char __pyx_k_gaierror[] = "gaierror"; +static const char __pyx_k_iterable[] = "iterable"; +static const char __pyx_k_on_timer[] = "_on_timer"; +static const char __pyx_k_qualname[] = "__qualname__"; +static const char __pyx_k_sockaddr[] = "sockaddr"; +static const char __pyx_k_tcp_port[] = "tcp_port"; +static const char __pyx_k_udp_port[] = "udp_port"; +static const char __pyx_k_InvalidIP[] = "InvalidIP"; +static const char __pyx_k_NI_NOFQDN[] = "NI_NOFQDN"; +static const char __pyx_k_TypeError[] = "TypeError"; +static const char __pyx_k_exception[] = "exception"; +static const char __pyx_k_metaclass[] = "__metaclass__"; +static const char __pyx_k_ARES_EFILE[] = "ARES_EFILE"; +static const char __pyx_k_ValueError[] = "ValueError"; +static const char __pyx_k_basestring[] = "basestring"; +static const char __pyx_k_getnewargs[] = "__getnewargs__"; +static const char __pyx_k_process_fd[] = "_process_fd"; +static const char __pyx_k_pyx_vtable[] = "__pyx_vtable__"; +static const char __pyx_k_ARES_ENOMEM[] = "ARES_ENOMEM"; +static const char __pyx_k_MemoryError[] = "MemoryError"; +static const char __pyx_k_NI_NAMEREQD[] = "NI_NAMEREQD"; +static const char __pyx_k_ares_errors[] = "_ares_errors"; +static const char __pyx_k_getnameinfo[] = "_getnameinfo"; +static const char __pyx_k_gevent_ares[] = "gevent.ares"; +static const char __pyx_k_pass_events[] = "pass_events"; +static const char __pyx_k_set_servers[] = "set_servers"; +static const char __pyx_k_ARES_EBADSTR[] = "ARES_EBADSTR"; +static const char __pyx_k_ARES_ENODATA[] = "ARES_ENODATA"; +static const char __pyx_k_ARES_ENONAME[] = "ARES_ENONAME"; +static const char __pyx_k_ARES_ENOTIMP[] = "ARES_ENOTIMP"; +static const char __pyx_k_ARES_SUCCESS[] = "ARES_SUCCESS"; +static const char __pyx_k_handle_error[] = "handle_error"; +static const char __pyx_k_version_info[] = "version_info"; +static const char __pyx_k_ARES_EBADNAME[] = "ARES_EBADNAME"; +static const char __pyx_k_ARES_EBADRESP[] = "ARES_EBADRESP"; +static const char __pyx_k_ARES_EFORMERR[] = "ARES_EFORMERR"; +static const char __pyx_k_ARES_EREFUSED[] = "ARES_EREFUSED"; +static const char __pyx_k_ARES_ETIMEOUT[] = "ARES_ETIMEOUT"; +static const char __pyx_k_s_exception_r[] = "%s(exception=%r)"; +static const char __pyx_k_ARES_EBADFLAGS[] = "ARES_EBADFLAGS"; +static const char __pyx_k_ARES_EBADHINTS[] = "ARES_EBADHINTS"; +static const char __pyx_k_ARES_EBADQUERY[] = "ARES_EBADQUERY"; +static const char __pyx_k_ARES_ENOTFOUND[] = "ARES_ENOTFOUND"; +static const char __pyx_k_ARES_ESERVFAIL[] = "ARES_ESERVFAIL"; +static const char __pyx_k_NI_NUMERICHOST[] = "NI_NUMERICHOST"; +static const char __pyx_k_NI_NUMERICSERV[] = "NI_NUMERICSERV"; +static const char __pyx_k_cares_flag_map[] = "_cares_flag_map"; +static const char __pyx_k_ARES_EBADFAMILY[] = "ARES_EBADFAMILY"; +static const char __pyx_k_ARES_ECANCELLED[] = "ARES_ECANCELLED"; +static const char __pyx_k_ARES_FLAG_IGNTC[] = "ARES_FLAG_IGNTC"; +static const char __pyx_k_ARES_FLAG_USEVC[] = "ARES_FLAG_USEVC"; +static const char __pyx_k_ares_host_result[] = "ares_host_result"; +static const char __pyx_k_ARES_ECONNREFUSED[] = "ARES_ECONNREFUSED"; +static const char __pyx_k_ARES_EDESTRUCTION[] = "ARES_EDESTRUCTION"; +static const char __pyx_k_ARES_FLAG_PRIMARY[] = "ARES_FLAG_PRIMARY"; +static const char __pyx_k_ARES_ELOADIPHLPAPI[] = "ARES_ELOADIPHLPAPI"; +static const char __pyx_k_ARES_FLAG_NOSEARCH[] = "ARES_FLAG_NOSEARCH"; +static const char __pyx_k_ARES_FLAG_STAYOPEN[] = "ARES_FLAG_STAYOPEN"; +static const char __pyx_k_ARES_FLAG_NOALIASES[] = "ARES_FLAG_NOALIASES"; +static const char __pyx_k_ARES_FLAG_NORECURSE[] = "ARES_FLAG_NORECURSE"; +static const char __pyx_k_ARES_ENOTINITIALIZED[] = "ARES_ENOTINITIALIZED"; +static const char __pyx_k_ARES_FLAG_NOCHECKRESP[] = "ARES_FLAG_NOCHECKRESP"; +static const char __pyx_k_s_value_r_exception_r[] = "%s(value=%r, exception=%r)"; +static const char __pyx_k_ares_host_result___new[] = "ares_host_result.__new__"; +static const char __pyx_k_expected_a_tuple_got_r[] = "expected a tuple, got %r"; +static const char __pyx_k_Invalid_value_for_port_r[] = "Invalid value for port: %r"; +static const char __pyx_k_ARES_EADDRGETNETWORKPARAMS[] = "ARES_EADDRGETNETWORKPARAMS"; +static const char __pyx_k_Bad_value_for_ai_flags_0x_x[] = "Bad value for ai_flags: 0x%x"; +static const char __pyx_k_ares_host_result___getnewargs[] = "ares_host_result.__getnewargs__"; +static const char __pyx_k_s_at_0x_x__timer_r__watchers_s[] = "<%s at 0x%x _timer=%r _watchers[%s]>"; +static const char __pyx_k_C_projects_gevent_src_gevent_are[] = "C:\\projects\\gevent\\src\\gevent\\ares.pyx"; +static const char __pyx_k_this_ares_channel_has_been_destr[] = "this ares channel has been destroyed"; +static PyObject *__pyx_n_s_ARES_EADDRGETNETWORKPARAMS; +static PyObject *__pyx_n_s_ARES_EBADFAMILY; +static PyObject *__pyx_n_s_ARES_EBADFLAGS; +static PyObject *__pyx_n_s_ARES_EBADHINTS; +static PyObject *__pyx_n_s_ARES_EBADNAME; +static PyObject *__pyx_n_s_ARES_EBADQUERY; +static PyObject *__pyx_n_s_ARES_EBADRESP; +static PyObject *__pyx_n_s_ARES_EBADSTR; +static PyObject *__pyx_n_s_ARES_ECANCELLED; +static PyObject *__pyx_n_s_ARES_ECONNREFUSED; +static PyObject *__pyx_n_s_ARES_EDESTRUCTION; +static PyObject *__pyx_n_s_ARES_EFILE; +static PyObject *__pyx_n_s_ARES_EFORMERR; +static PyObject *__pyx_n_s_ARES_ELOADIPHLPAPI; +static PyObject *__pyx_n_s_ARES_ENODATA; +static PyObject *__pyx_n_s_ARES_ENOMEM; +static PyObject *__pyx_n_s_ARES_ENONAME; +static PyObject *__pyx_n_s_ARES_ENOTFOUND; +static PyObject *__pyx_n_s_ARES_ENOTIMP; +static PyObject *__pyx_n_s_ARES_ENOTINITIALIZED; +static PyObject *__pyx_n_s_ARES_EOF; +static PyObject *__pyx_n_s_ARES_EREFUSED; +static PyObject *__pyx_n_s_ARES_ESERVFAIL; +static PyObject *__pyx_n_s_ARES_ETIMEOUT; +static PyObject *__pyx_n_s_ARES_FLAG_IGNTC; +static PyObject *__pyx_n_s_ARES_FLAG_NOALIASES; +static PyObject *__pyx_n_s_ARES_FLAG_NOCHECKRESP; +static PyObject *__pyx_n_s_ARES_FLAG_NORECURSE; +static PyObject *__pyx_n_s_ARES_FLAG_NOSEARCH; +static PyObject *__pyx_n_s_ARES_FLAG_PRIMARY; +static PyObject *__pyx_n_s_ARES_FLAG_STAYOPEN; +static PyObject *__pyx_n_s_ARES_FLAG_USEVC; +static PyObject *__pyx_n_s_ARES_SUCCESS; +static PyObject *__pyx_kp_s_Bad_value_for_ai_flags_0x_x; +static PyObject *__pyx_kp_s_C_projects_gevent_src_gevent_are; +static PyObject *__pyx_n_s_InvalidIP; +static PyObject *__pyx_kp_s_Invalid_value_for_port_r; +static PyObject *__pyx_n_s_MemoryError; +static PyObject *__pyx_n_s_NI_DGRAM; +static PyObject *__pyx_n_s_NI_NAMEREQD; +static PyObject *__pyx_n_s_NI_NOFQDN; +static PyObject *__pyx_n_s_NI_NUMERICHOST; +static PyObject *__pyx_n_s_NI_NUMERICSERV; +static PyObject *__pyx_n_s_TIMEOUT; +static PyObject *__pyx_n_s_TypeError; +static PyObject *__pyx_n_s_ValueError; +static PyObject *__pyx_kp_s__2; +static PyObject *__pyx_n_s_addr; +static PyObject *__pyx_n_s_again; +static PyObject *__pyx_n_s_all; +static PyObject *__pyx_n_s_ares_errors; +static PyObject *__pyx_n_s_ares_host_result; +static PyObject *__pyx_n_s_ares_host_result___getnewargs; +static PyObject *__pyx_n_s_ares_host_result___new; +static PyObject *__pyx_n_s_ascii; +static PyObject *__pyx_n_s_basestring; +static PyObject *__pyx_n_s_builtins; +static PyObject *__pyx_n_s_callback; +static PyObject *__pyx_n_s_cares_flag_map; +static PyObject *__pyx_n_s_channel; +static PyObject *__pyx_n_s_class; +static PyObject *__pyx_n_s_cls; +static PyObject *__pyx_n_s_default; +static PyObject *__pyx_n_s_destroy; +static PyObject *__pyx_n_s_doc; +static PyObject *__pyx_n_s_encode; +static PyObject *__pyx_n_s_events; +static PyObject *__pyx_n_s_exc_info; +static PyObject *__pyx_n_s_exception; +static PyObject *__pyx_kp_s_expected_a_tuple_got_r; +static PyObject *__pyx_n_s_family; +static PyObject *__pyx_n_s_fd; +static PyObject *__pyx_n_s_flags; +static PyObject *__pyx_n_s_gaierror; +static PyObject *__pyx_n_s_get; +static PyObject *__pyx_n_s_getnameinfo; +static PyObject *__pyx_n_s_getnewargs; +static PyObject *__pyx_n_s_gevent_ares; +static PyObject *__pyx_n_s_handle_error; +static PyObject *__pyx_n_s_id; +static PyObject *__pyx_n_s_import; +static PyObject *__pyx_n_s_io; +static PyObject *__pyx_n_s_iterable; +static PyObject *__pyx_n_s_loop; +static PyObject *__pyx_n_s_main; +static PyObject *__pyx_n_s_metaclass; +static PyObject *__pyx_n_s_module; +static PyObject *__pyx_n_s_name; +static PyObject *__pyx_n_s_name_2; +static PyObject *__pyx_n_s_ndots; +static PyObject *__pyx_n_s_new; +static PyObject *__pyx_n_s_on_timer; +static PyObject *__pyx_n_s_pass_events; +static PyObject *__pyx_n_s_pop; +static PyObject *__pyx_n_s_prepare; +static PyObject *__pyx_n_s_process_fd; +static PyObject *__pyx_n_s_pyx_vtable; +static PyObject *__pyx_n_s_qualname; +static PyObject *__pyx_kp_s_s_at_0x_x__timer_r__watchers_s; +static PyObject *__pyx_kp_s_s_exception_r; +static PyObject *__pyx_kp_s_s_r; +static PyObject *__pyx_kp_s_s_s; +static PyObject *__pyx_kp_s_s_value_r_exception_r; +static PyObject *__pyx_n_s_self; +static PyObject *__pyx_n_s_servers; +static PyObject *__pyx_n_s_set_servers; +static PyObject *__pyx_n_s_sockaddr; +static PyObject *__pyx_n_s_socket; +static PyObject *__pyx_n_s_split; +static PyObject *__pyx_n_s_start; +static PyObject *__pyx_n_s_stop; +static PyObject *__pyx_n_s_sys; +static PyObject *__pyx_n_s_tcp_port; +static PyObject *__pyx_n_s_test; +static PyObject *__pyx_kp_s_this_ares_channel_has_been_destr; +static PyObject *__pyx_n_s_timeout; +static PyObject *__pyx_n_s_timer; +static PyObject *__pyx_n_s_tries; +static PyObject *__pyx_n_s_udp_port; +static PyObject *__pyx_n_s_unicode; +static PyObject *__pyx_n_s_value; +static PyObject *__pyx_n_s_version_info; +static PyObject *__pyx_n_s_watcher; +static PyObject *__pyx_pf_6gevent_4ares__convert_cares_flags(CYTHON_UNUSED PyObject *__pyx_self, int __pyx_v_flags, int __pyx_v_default); /* proto */ +static PyObject *__pyx_pf_6gevent_4ares_2strerror(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_code); /* proto */ +static int __pyx_pf_6gevent_4ares_6result___init__(struct __pyx_obj_6gevent_4ares_result *__pyx_v_self, PyObject *__pyx_v_value, PyObject *__pyx_v_exception); /* proto */ +static PyObject *__pyx_pf_6gevent_4ares_6result_2__repr__(struct __pyx_obj_6gevent_4ares_result *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_4ares_6result_4successful(struct __pyx_obj_6gevent_4ares_result *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_4ares_6result_6get(struct __pyx_obj_6gevent_4ares_result *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_4ares_6result_5value___get__(struct __pyx_obj_6gevent_4ares_result *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_4ares_6result_5value_2__set__(struct __pyx_obj_6gevent_4ares_result *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_6gevent_4ares_6result_5value_4__del__(struct __pyx_obj_6gevent_4ares_result *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_4ares_6result_9exception___get__(struct __pyx_obj_6gevent_4ares_result *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_4ares_6result_9exception_2__set__(struct __pyx_obj_6gevent_4ares_result *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_6gevent_4ares_6result_9exception_4__del__(struct __pyx_obj_6gevent_4ares_result *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_4ares_16ares_host_result___new__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_cls, PyObject *__pyx_v_family, PyObject *__pyx_v_iterable); /* proto */ +static PyObject *__pyx_pf_6gevent_4ares_16ares_host_result_2__getnewargs__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_4ares_7channel___init__(struct PyGeventAresChannelObject *__pyx_v_self, PyObject *__pyx_v_loop, PyObject *__pyx_v_flags, PyObject *__pyx_v_timeout, PyObject *__pyx_v_tries, PyObject *__pyx_v_ndots, PyObject *__pyx_v_udp_port, PyObject *__pyx_v_tcp_port, PyObject *__pyx_v_servers); /* proto */ +static PyObject *__pyx_pf_6gevent_4ares_7channel_2__repr__(struct PyGeventAresChannelObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_4ares_7channel_4destroy(struct PyGeventAresChannelObject *__pyx_v_self); /* proto */ +static void __pyx_pf_6gevent_4ares_7channel_6__dealloc__(struct PyGeventAresChannelObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_4ares_7channel_8set_servers(struct PyGeventAresChannelObject *__pyx_v_self, PyObject *__pyx_v_servers); /* proto */ +static PyObject *__pyx_pf_6gevent_4ares_7channel_10_on_timer(struct PyGeventAresChannelObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_4ares_7channel_12_process_fd(struct PyGeventAresChannelObject *__pyx_v_self, int __pyx_v_events, PyObject *__pyx_v_watcher); /* proto */ +static PyObject *__pyx_pf_6gevent_4ares_7channel_14gethostbyname(struct PyGeventAresChannelObject *__pyx_v_self, PyObject *__pyx_v_callback, char *__pyx_v_name, int __pyx_v_family); /* proto */ +static PyObject *__pyx_pf_6gevent_4ares_7channel_16gethostbyaddr(struct PyGeventAresChannelObject *__pyx_v_self, PyObject *__pyx_v_callback, char *__pyx_v_addr); /* proto */ +static PyObject *__pyx_pf_6gevent_4ares_7channel_18_getnameinfo(struct PyGeventAresChannelObject *__pyx_v_self, PyObject *__pyx_v_callback, PyObject *__pyx_v_sockaddr, int __pyx_v_flags); /* proto */ +static PyObject *__pyx_pf_6gevent_4ares_7channel_20getnameinfo(struct PyGeventAresChannelObject *__pyx_v_self, PyObject *__pyx_v_callback, PyObject *__pyx_v_sockaddr, int __pyx_v_flags); /* proto */ +static PyObject *__pyx_pf_6gevent_4ares_7channel_4loop___get__(struct PyGeventAresChannelObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_4ares_7channel_4loop_2__set__(struct PyGeventAresChannelObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_6gevent_4ares_7channel_4loop_4__del__(struct PyGeventAresChannelObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_4ares_7channel_9_watchers___get__(struct PyGeventAresChannelObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_4ares_7channel_9_watchers_2__set__(struct PyGeventAresChannelObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_6gevent_4ares_7channel_9_watchers_4__del__(struct PyGeventAresChannelObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_4ares_7channel_6_timer___get__(struct PyGeventAresChannelObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_4ares_7channel_6_timer_2__set__(struct PyGeventAresChannelObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_6gevent_4ares_7channel_6_timer_4__del__(struct PyGeventAresChannelObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_tp_new_6gevent_4ares_result(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_6gevent_4ares_channel(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_int_1; +static PyObject *__pyx_int_2; +static PyObject *__pyx_int_3; +static PyObject *__pyx_int_4; +static PyObject *__pyx_int_8; +static PyObject *__pyx_int_16; +static PyObject *__pyx_int_neg_1; +static PyObject *__pyx_int_neg_8; +static int __pyx_k_; +static int __pyx_k__5; +static PyObject *__pyx_tuple__3; +static PyObject *__pyx_tuple__4; +static PyObject *__pyx_tuple__6; +static PyObject *__pyx_tuple__8; +static PyObject *__pyx_codeobj__7; +static PyObject *__pyx_codeobj__9; + +/* "gevent/ares.pyx":126 + * + * + * cdef _prepare_cares_flag_map(): # <<<<<<<<<<<<<< + * global _cares_flag_map + * import _socket + */ + +static PyObject *__pyx_f_6gevent_4ares__prepare_cares_flag_map(void) { + PyObject *__pyx_v__socket = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + __Pyx_RefNannySetupContext("_prepare_cares_flag_map", 0); + + /* "gevent/ares.pyx":128 + * cdef _prepare_cares_flag_map(): + * global _cares_flag_map + * import _socket # <<<<<<<<<<<<<< + * _cares_flag_map = [ + * (getattr(_socket, 'NI_NUMERICHOST', 1), cares.ARES_NI_NUMERICHOST), + */ + __pyx_t_1 = __Pyx_Import(__pyx_n_s_socket, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 128, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__socket = __pyx_t_1; + __pyx_t_1 = 0; + + /* "gevent/ares.pyx":130 + * import _socket + * _cares_flag_map = [ + * (getattr(_socket, 'NI_NUMERICHOST', 1), cares.ARES_NI_NUMERICHOST), # <<<<<<<<<<<<<< + * (getattr(_socket, 'NI_NUMERICSERV', 2), cares.ARES_NI_NUMERICSERV), + * (getattr(_socket, 'NI_NOFQDN', 4), cares.ARES_NI_NOFQDN), + */ + __pyx_t_1 = __Pyx_GetAttr3(__pyx_v__socket, __pyx_n_s_NI_NUMERICHOST, __pyx_int_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 130, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_NI_NUMERICHOST); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 130, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 130, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + + /* "gevent/ares.pyx":131 + * _cares_flag_map = [ + * (getattr(_socket, 'NI_NUMERICHOST', 1), cares.ARES_NI_NUMERICHOST), + * (getattr(_socket, 'NI_NUMERICSERV', 2), cares.ARES_NI_NUMERICSERV), # <<<<<<<<<<<<<< + * (getattr(_socket, 'NI_NOFQDN', 4), cares.ARES_NI_NOFQDN), + * (getattr(_socket, 'NI_NAMEREQD', 8), cares.ARES_NI_NAMEREQD), + */ + __pyx_t_2 = __Pyx_GetAttr3(__pyx_v__socket, __pyx_n_s_NI_NUMERICSERV, __pyx_int_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = __Pyx_PyInt_From_int(ARES_NI_NUMERICSERV); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1); + __pyx_t_2 = 0; + __pyx_t_1 = 0; + + /* "gevent/ares.pyx":132 + * (getattr(_socket, 'NI_NUMERICHOST', 1), cares.ARES_NI_NUMERICHOST), + * (getattr(_socket, 'NI_NUMERICSERV', 2), cares.ARES_NI_NUMERICSERV), + * (getattr(_socket, 'NI_NOFQDN', 4), cares.ARES_NI_NOFQDN), # <<<<<<<<<<<<<< + * (getattr(_socket, 'NI_NAMEREQD', 8), cares.ARES_NI_NAMEREQD), + * (getattr(_socket, 'NI_DGRAM', 16), cares.ARES_NI_DGRAM)] + */ + __pyx_t_1 = __Pyx_GetAttr3(__pyx_v__socket, __pyx_n_s_NI_NOFQDN, __pyx_int_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 132, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_NI_NOFQDN); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 132, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 132, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + + /* "gevent/ares.pyx":133 + * (getattr(_socket, 'NI_NUMERICSERV', 2), cares.ARES_NI_NUMERICSERV), + * (getattr(_socket, 'NI_NOFQDN', 4), cares.ARES_NI_NOFQDN), + * (getattr(_socket, 'NI_NAMEREQD', 8), cares.ARES_NI_NAMEREQD), # <<<<<<<<<<<<<< + * (getattr(_socket, 'NI_DGRAM', 16), cares.ARES_NI_DGRAM)] + * + */ + __pyx_t_2 = __Pyx_GetAttr3(__pyx_v__socket, __pyx_n_s_NI_NAMEREQD, __pyx_int_8); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 133, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = __Pyx_PyInt_From_int(ARES_NI_NAMEREQD); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 133, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 133, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_1); + __pyx_t_2 = 0; + __pyx_t_1 = 0; + + /* "gevent/ares.pyx":134 + * (getattr(_socket, 'NI_NOFQDN', 4), cares.ARES_NI_NOFQDN), + * (getattr(_socket, 'NI_NAMEREQD', 8), cares.ARES_NI_NAMEREQD), + * (getattr(_socket, 'NI_DGRAM', 16), cares.ARES_NI_DGRAM)] # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __Pyx_GetAttr3(__pyx_v__socket, __pyx_n_s_NI_DGRAM, __pyx_int_16); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 134, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_NI_DGRAM); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 134, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 134, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_2); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + + /* "gevent/ares.pyx":129 + * global _cares_flag_map + * import _socket + * _cares_flag_map = [ # <<<<<<<<<<<<<< + * (getattr(_socket, 'NI_NUMERICHOST', 1), cares.ARES_NI_NUMERICHOST), + * (getattr(_socket, 'NI_NUMERICSERV', 2), cares.ARES_NI_NUMERICSERV), + */ + __pyx_t_2 = PyList_New(5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 129, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); + PyList_SET_ITEM(__pyx_t_2, 0, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + PyList_SET_ITEM(__pyx_t_2, 1, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + PyList_SET_ITEM(__pyx_t_2, 2, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_6); + PyList_SET_ITEM(__pyx_t_2, 3, __pyx_t_6); + __Pyx_GIVEREF(__pyx_t_7); + PyList_SET_ITEM(__pyx_t_2, 4, __pyx_t_7); + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_t_5 = 0; + __pyx_t_6 = 0; + __pyx_t_7 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_cares_flag_map, __pyx_t_2) < 0) __PYX_ERR(0, 129, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "gevent/ares.pyx":126 + * + * + * cdef _prepare_cares_flag_map(): # <<<<<<<<<<<<<< + * global _cares_flag_map + * import _socket + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("gevent.ares._prepare_cares_flag_map", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v__socket); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "gevent/ares.pyx":137 + * + * + * cpdef _convert_cares_flags(int flags, int default=cares.ARES_NI_LOOKUPHOST|cares.ARES_NI_LOOKUPSERVICE): # <<<<<<<<<<<<<< + * if _cares_flag_map is None: + * _prepare_cares_flag_map() + */ + +static PyObject *__pyx_pw_6gevent_4ares_1_convert_cares_flags(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_f_6gevent_4ares__convert_cares_flags(int __pyx_v_flags, CYTHON_UNUSED int __pyx_skip_dispatch, struct __pyx_opt_args_6gevent_4ares__convert_cares_flags *__pyx_optional_args) { + int __pyx_v_default = __pyx_k_; + PyObject *__pyx_v_socket_flag = NULL; + PyObject *__pyx_v_cares_flag = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + Py_ssize_t __pyx_t_5; + PyObject *(*__pyx_t_6)(PyObject *); + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *(*__pyx_t_10)(PyObject *); + int __pyx_t_11; + __Pyx_RefNannySetupContext("_convert_cares_flags", 0); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_default = __pyx_optional_args->__pyx_default; + } + } + + /* "gevent/ares.pyx":138 + * + * cpdef _convert_cares_flags(int flags, int default=cares.ARES_NI_LOOKUPHOST|cares.ARES_NI_LOOKUPSERVICE): + * if _cares_flag_map is None: # <<<<<<<<<<<<<< + * _prepare_cares_flag_map() + * for socket_flag, cares_flag in _cares_flag_map: + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_cares_flag_map); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__pyx_t_1 == Py_None); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = (__pyx_t_2 != 0); + if (__pyx_t_3) { + + /* "gevent/ares.pyx":139 + * cpdef _convert_cares_flags(int flags, int default=cares.ARES_NI_LOOKUPHOST|cares.ARES_NI_LOOKUPSERVICE): + * if _cares_flag_map is None: + * _prepare_cares_flag_map() # <<<<<<<<<<<<<< + * for socket_flag, cares_flag in _cares_flag_map: + * if socket_flag & flags: + */ + __pyx_t_1 = __pyx_f_6gevent_4ares__prepare_cares_flag_map(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 139, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "gevent/ares.pyx":138 + * + * cpdef _convert_cares_flags(int flags, int default=cares.ARES_NI_LOOKUPHOST|cares.ARES_NI_LOOKUPSERVICE): + * if _cares_flag_map is None: # <<<<<<<<<<<<<< + * _prepare_cares_flag_map() + * for socket_flag, cares_flag in _cares_flag_map: + */ + } + + /* "gevent/ares.pyx":140 + * if _cares_flag_map is None: + * _prepare_cares_flag_map() + * for socket_flag, cares_flag in _cares_flag_map: # <<<<<<<<<<<<<< + * if socket_flag & flags: + * default |= cares_flag + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_cares_flag_map); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 140, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) { + __pyx_t_4 = __pyx_t_1; __Pyx_INCREF(__pyx_t_4); __pyx_t_5 = 0; + __pyx_t_6 = NULL; + } else { + __pyx_t_5 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 140, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 140, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + for (;;) { + if (likely(!__pyx_t_6)) { + if (likely(PyList_CheckExact(__pyx_t_4))) { + if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_4)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_1 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_1); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 140, __pyx_L1_error) + #else + __pyx_t_1 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 140, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + #endif + } else { + if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_4)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_1); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 140, __pyx_L1_error) + #else + __pyx_t_1 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 140, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + #endif + } + } else { + __pyx_t_1 = __pyx_t_6(__pyx_t_4); + if (unlikely(!__pyx_t_1)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 140, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_1); + } + if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) { + PyObject* sequence = __pyx_t_1; + #if !CYTHON_COMPILING_IN_PYPY + Py_ssize_t size = Py_SIZE(sequence); + #else + Py_ssize_t size = PySequence_Size(sequence); + #endif + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 140, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_7 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_8 = PyTuple_GET_ITEM(sequence, 1); + } else { + __pyx_t_7 = PyList_GET_ITEM(sequence, 0); + __pyx_t_8 = PyList_GET_ITEM(sequence, 1); + } + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(__pyx_t_8); + #else + __pyx_t_7 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 140, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 140, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + #endif + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_9 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 140, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_10 = Py_TYPE(__pyx_t_9)->tp_iternext; + index = 0; __pyx_t_7 = __pyx_t_10(__pyx_t_9); if (unlikely(!__pyx_t_7)) goto __pyx_L6_unpacking_failed; + __Pyx_GOTREF(__pyx_t_7); + index = 1; __pyx_t_8 = __pyx_t_10(__pyx_t_9); if (unlikely(!__pyx_t_8)) goto __pyx_L6_unpacking_failed; + __Pyx_GOTREF(__pyx_t_8); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_10(__pyx_t_9), 2) < 0) __PYX_ERR(0, 140, __pyx_L1_error) + __pyx_t_10 = NULL; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L7_unpacking_done; + __pyx_L6_unpacking_failed:; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_10 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 140, __pyx_L1_error) + __pyx_L7_unpacking_done:; + } + __Pyx_XDECREF_SET(__pyx_v_socket_flag, __pyx_t_7); + __pyx_t_7 = 0; + __Pyx_XDECREF_SET(__pyx_v_cares_flag, __pyx_t_8); + __pyx_t_8 = 0; + + /* "gevent/ares.pyx":141 + * _prepare_cares_flag_map() + * for socket_flag, cares_flag in _cares_flag_map: + * if socket_flag & flags: # <<<<<<<<<<<<<< + * default |= cares_flag + * flags &= ~socket_flag + */ + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 141, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_8 = PyNumber_And(__pyx_v_socket_flag, __pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 141, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 141, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (__pyx_t_3) { + + /* "gevent/ares.pyx":142 + * for socket_flag, cares_flag in _cares_flag_map: + * if socket_flag & flags: + * default |= cares_flag # <<<<<<<<<<<<<< + * flags &= ~socket_flag + * if not flags: + */ + __pyx_t_8 = __Pyx_PyInt_From_int(__pyx_v_default); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 142, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_1 = PyNumber_InPlaceOr(__pyx_t_8, __pyx_v_cares_flag); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 142, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_11 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_11 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 142, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_default = __pyx_t_11; + + /* "gevent/ares.pyx":143 + * if socket_flag & flags: + * default |= cares_flag + * flags &= ~socket_flag # <<<<<<<<<<<<<< + * if not flags: + * return default + */ + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 143, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_8 = PyNumber_Invert(__pyx_v_socket_flag); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 143, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_7 = PyNumber_InPlaceAnd(__pyx_t_1, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 143, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_11 = __Pyx_PyInt_As_int(__pyx_t_7); if (unlikely((__pyx_t_11 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 143, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_v_flags = __pyx_t_11; + + /* "gevent/ares.pyx":141 + * _prepare_cares_flag_map() + * for socket_flag, cares_flag in _cares_flag_map: + * if socket_flag & flags: # <<<<<<<<<<<<<< + * default |= cares_flag + * flags &= ~socket_flag + */ + } + + /* "gevent/ares.pyx":144 + * default |= cares_flag + * flags &= ~socket_flag + * if not flags: # <<<<<<<<<<<<<< + * return default + * raise gaierror(-1, "Bad value for ai_flags: 0x%x" % flags) + */ + __pyx_t_3 = ((!(__pyx_v_flags != 0)) != 0); + if (__pyx_t_3) { + + /* "gevent/ares.pyx":145 + * flags &= ~socket_flag + * if not flags: + * return default # <<<<<<<<<<<<<< + * raise gaierror(-1, "Bad value for ai_flags: 0x%x" % flags) + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_7 = __Pyx_PyInt_From_int(__pyx_v_default); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 145, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_r = __pyx_t_7; + __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + goto __pyx_L0; + + /* "gevent/ares.pyx":144 + * default |= cares_flag + * flags &= ~socket_flag + * if not flags: # <<<<<<<<<<<<<< + * return default + * raise gaierror(-1, "Bad value for ai_flags: 0x%x" % flags) + */ + } + + /* "gevent/ares.pyx":140 + * if _cares_flag_map is None: + * _prepare_cares_flag_map() + * for socket_flag, cares_flag in _cares_flag_map: # <<<<<<<<<<<<<< + * if socket_flag & flags: + * default |= cares_flag + */ + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "gevent/ares.pyx":146 + * if not flags: + * return default + * raise gaierror(-1, "Bad value for ai_flags: 0x%x" % flags) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_gaierror); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = __Pyx_PyInt_From_int(__pyx_v_flags); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Bad_value_for_ai_flags_0x_x, __pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = NULL; + __pyx_t_11 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + __pyx_t_11 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_7)) { + PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_int_neg_1, __pyx_t_1}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 146, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) { + PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_int_neg_1, __pyx_t_1}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 146, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else + #endif + { + __pyx_t_9 = PyTuple_New(2+__pyx_t_11); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if (__pyx_t_8) { + __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_8); __pyx_t_8 = NULL; + } + __Pyx_INCREF(__pyx_int_neg_1); + __Pyx_GIVEREF(__pyx_int_neg_1); + PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_11, __pyx_int_neg_1); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_11, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_9, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(0, 146, __pyx_L1_error) + + /* "gevent/ares.pyx":137 + * + * + * cpdef _convert_cares_flags(int flags, int default=cares.ARES_NI_LOOKUPHOST|cares.ARES_NI_LOOKUPSERVICE): # <<<<<<<<<<<<<< + * if _cares_flag_map is None: + * _prepare_cares_flag_map() + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("gevent.ares._convert_cares_flags", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_socket_flag); + __Pyx_XDECREF(__pyx_v_cares_flag); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_4ares_1_convert_cares_flags(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6gevent_4ares_1_convert_cares_flags(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + int __pyx_v_flags; + int __pyx_v_default; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_convert_cares_flags (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_flags,&__pyx_n_s_default,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_flags)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_default); + if (value) { values[1] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_convert_cares_flags") < 0)) __PYX_ERR(0, 137, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_flags = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_flags == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 137, __pyx_L3_error) + if (values[1]) { + __pyx_v_default = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_default == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 137, __pyx_L3_error) + } else { + __pyx_v_default = __pyx_k_; + } + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("_convert_cares_flags", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 137, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.ares._convert_cares_flags", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_4ares__convert_cares_flags(__pyx_self, __pyx_v_flags, __pyx_v_default); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_4ares__convert_cares_flags(CYTHON_UNUSED PyObject *__pyx_self, int __pyx_v_flags, int __pyx_v_default) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + struct __pyx_opt_args_6gevent_4ares__convert_cares_flags __pyx_t_2; + __Pyx_RefNannySetupContext("_convert_cares_flags", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_2.__pyx_n = 1; + __pyx_t_2.__pyx_default = __pyx_v_default; + __pyx_t_1 = __pyx_f_6gevent_4ares__convert_cares_flags(__pyx_v_flags, 0, &__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 137, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.ares._convert_cares_flags", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "gevent/ares.pyx":149 + * + * + * cpdef strerror(code): # <<<<<<<<<<<<<< + * return '%s: %s' % (_ares_errors.get(code) or code, cares.ares_strerror(code)) + * + */ + +static PyObject *__pyx_pw_6gevent_4ares_3strerror(PyObject *__pyx_self, PyObject *__pyx_v_code); /*proto*/ +static PyObject *__pyx_f_6gevent_4ares_strerror(PyObject *__pyx_v_code, CYTHON_UNUSED int __pyx_skip_dispatch) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + int __pyx_t_7; + __Pyx_RefNannySetupContext("strerror", 0); + + /* "gevent/ares.pyx":150 + * + * cpdef strerror(code): + * return '%s: %s' % (_ares_errors.get(code) or code, cares.ares_strerror(code)) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_ares_errors); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 150, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_get); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 150, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_3) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_code); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 150, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_code}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 150, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_code}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 150, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + { + __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 150, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = NULL; + __Pyx_INCREF(__pyx_v_code); + __Pyx_GIVEREF(__pyx_v_code); + PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_v_code); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 150, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 150, __pyx_L1_error) + if (!__pyx_t_6) { + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + __Pyx_INCREF(__pyx_t_2); + __pyx_t_1 = __pyx_t_2; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + goto __pyx_L3_bool_binop_done; + } + __Pyx_INCREF(__pyx_v_code); + __pyx_t_1 = __pyx_v_code; + __pyx_L3_bool_binop_done:; + __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_v_code); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 150, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyBytes_FromString(ares_strerror(__pyx_t_7)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 150, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 150, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_s_s, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 150, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "gevent/ares.pyx":149 + * + * + * cpdef strerror(code): # <<<<<<<<<<<<<< + * return '%s: %s' % (_ares_errors.get(code) or code, cares.ares_strerror(code)) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("gevent.ares.strerror", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_4ares_3strerror(PyObject *__pyx_self, PyObject *__pyx_v_code); /*proto*/ +static PyObject *__pyx_pw_6gevent_4ares_3strerror(PyObject *__pyx_self, PyObject *__pyx_v_code) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("strerror (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_4ares_2strerror(__pyx_self, ((PyObject *)__pyx_v_code)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_4ares_2strerror(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_code) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("strerror", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_6gevent_4ares_strerror(__pyx_v_code, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.ares.strerror", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "gevent/ares.pyx":157 + * + * + * cdef void gevent_sock_state_callback(void *data, int s, int read, int write): # <<<<<<<<<<<<<< + * if not data: + * return + */ + +static void __pyx_f_6gevent_4ares_gevent_sock_state_callback(void *__pyx_v_data, int __pyx_v_s, int __pyx_v_read, int __pyx_v_write) { + struct PyGeventAresChannelObject *__pyx_v_ch = 0; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("gevent_sock_state_callback", 0); + + /* "gevent/ares.pyx":158 + * + * cdef void gevent_sock_state_callback(void *data, int s, int read, int write): + * if not data: # <<<<<<<<<<<<<< + * return + * cdef channel ch = data + */ + __pyx_t_1 = ((!(__pyx_v_data != 0)) != 0); + if (__pyx_t_1) { + + /* "gevent/ares.pyx":159 + * cdef void gevent_sock_state_callback(void *data, int s, int read, int write): + * if not data: + * return # <<<<<<<<<<<<<< + * cdef channel ch = data + * ch._sock_state_callback(s, read, write) + */ + goto __pyx_L0; + + /* "gevent/ares.pyx":158 + * + * cdef void gevent_sock_state_callback(void *data, int s, int read, int write): + * if not data: # <<<<<<<<<<<<<< + * return + * cdef channel ch = data + */ + } + + /* "gevent/ares.pyx":160 + * if not data: + * return + * cdef channel ch = data # <<<<<<<<<<<<<< + * ch._sock_state_callback(s, read, write) + * + */ + __pyx_t_2 = ((PyObject *)__pyx_v_data); + __Pyx_INCREF(__pyx_t_2); + __pyx_v_ch = ((struct PyGeventAresChannelObject *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "gevent/ares.pyx":161 + * return + * cdef channel ch = data + * ch._sock_state_callback(s, read, write) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_2 = ((struct __pyx_vtabstruct_6gevent_4ares_channel *)__pyx_v_ch->__pyx_vtab)->_sock_state_callback(__pyx_v_ch, __pyx_v_s, __pyx_v_read, __pyx_v_write); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 161, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "gevent/ares.pyx":157 + * + * + * cdef void gevent_sock_state_callback(void *data, int s, int read, int write): # <<<<<<<<<<<<<< + * if not data: + * return + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_WriteUnraisable("gevent.ares.gevent_sock_state_callback", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0); + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_ch); + __Pyx_RefNannyFinishContext(); +} + +/* "gevent/ares.pyx":168 + * cdef public object exception + * + * def __init__(self, object value=None, object exception=None): # <<<<<<<<<<<<<< + * self.value = value + * self.exception = exception + */ + +/* Python wrapper */ +static int __pyx_pw_6gevent_4ares_6result_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_6gevent_4ares_6result_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_value = 0; + PyObject *__pyx_v_exception = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_value,&__pyx_n_s_exception,0}; + PyObject* values[2] = {0,0}; + values[0] = ((PyObject *)Py_None); + values[1] = ((PyObject *)Py_None); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_value); + if (value) { values[0] = value; kw_args--; } + } + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_exception); + if (value) { values[1] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 168, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_value = values[0]; + __pyx_v_exception = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 168, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.ares.result.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_4ares_6result___init__(((struct __pyx_obj_6gevent_4ares_result *)__pyx_v_self), __pyx_v_value, __pyx_v_exception); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_4ares_6result___init__(struct __pyx_obj_6gevent_4ares_result *__pyx_v_self, PyObject *__pyx_v_value, PyObject *__pyx_v_exception) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__", 0); + + /* "gevent/ares.pyx":169 + * + * def __init__(self, object value=None, object exception=None): + * self.value = value # <<<<<<<<<<<<<< + * self.exception = exception + * + */ + __Pyx_INCREF(__pyx_v_value); + __Pyx_GIVEREF(__pyx_v_value); + __Pyx_GOTREF(__pyx_v_self->value); + __Pyx_DECREF(__pyx_v_self->value); + __pyx_v_self->value = __pyx_v_value; + + /* "gevent/ares.pyx":170 + * def __init__(self, object value=None, object exception=None): + * self.value = value + * self.exception = exception # <<<<<<<<<<<<<< + * + * def __repr__(self): + */ + __Pyx_INCREF(__pyx_v_exception); + __Pyx_GIVEREF(__pyx_v_exception); + __Pyx_GOTREF(__pyx_v_self->exception); + __Pyx_DECREF(__pyx_v_self->exception); + __pyx_v_self->exception = __pyx_v_exception; + + /* "gevent/ares.pyx":168 + * cdef public object exception + * + * def __init__(self, object value=None, object exception=None): # <<<<<<<<<<<<<< + * self.value = value + * self.exception = exception + */ + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "gevent/ares.pyx":172 + * self.exception = exception + * + * def __repr__(self): # <<<<<<<<<<<<<< + * if self.exception is None: + * return '%s(%r)' % (self.__class__.__name__, self.value) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_4ares_6result_3__repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_4ares_6result_3__repr__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_4ares_6result_2__repr__(((struct __pyx_obj_6gevent_4ares_result *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_4ares_6result_2__repr__(struct __pyx_obj_6gevent_4ares_result *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + __Pyx_RefNannySetupContext("__repr__", 0); + + /* "gevent/ares.pyx":173 + * + * def __repr__(self): + * if self.exception is None: # <<<<<<<<<<<<<< + * return '%s(%r)' % (self.__class__.__name__, self.value) + * elif self.value is None: + */ + __pyx_t_1 = (__pyx_v_self->exception == Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "gevent/ares.pyx":174 + * def __repr__(self): + * if self.exception is None: + * return '%s(%r)' % (self.__class__.__name__, self.value) # <<<<<<<<<<<<<< + * elif self.value is None: + * return '%s(exception=%r)' % (self.__class__.__name__, self.exception) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 174, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_name); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 174, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 174, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); + __Pyx_INCREF(__pyx_v_self->value); + __Pyx_GIVEREF(__pyx_v_self->value); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_self->value); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_s_r, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 174, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "gevent/ares.pyx":173 + * + * def __repr__(self): + * if self.exception is None: # <<<<<<<<<<<<<< + * return '%s(%r)' % (self.__class__.__name__, self.value) + * elif self.value is None: + */ + } + + /* "gevent/ares.pyx":175 + * if self.exception is None: + * return '%s(%r)' % (self.__class__.__name__, self.value) + * elif self.value is None: # <<<<<<<<<<<<<< + * return '%s(exception=%r)' % (self.__class__.__name__, self.exception) + * else: + */ + __pyx_t_2 = (__pyx_v_self->value == Py_None); + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { + + /* "gevent/ares.pyx":176 + * return '%s(%r)' % (self.__class__.__name__, self.value) + * elif self.value is None: + * return '%s(exception=%r)' % (self.__class__.__name__, self.exception) # <<<<<<<<<<<<<< + * else: + * return '%s(value=%r, exception=%r)' % (self.__class__.__name__, self.value, self.exception) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 176, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 176, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 176, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); + __Pyx_INCREF(__pyx_v_self->exception); + __Pyx_GIVEREF(__pyx_v_self->exception); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_v_self->exception); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_s_exception_r, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 176, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "gevent/ares.pyx":175 + * if self.exception is None: + * return '%s(%r)' % (self.__class__.__name__, self.value) + * elif self.value is None: # <<<<<<<<<<<<<< + * return '%s(exception=%r)' % (self.__class__.__name__, self.exception) + * else: + */ + } + + /* "gevent/ares.pyx":178 + * return '%s(exception=%r)' % (self.__class__.__name__, self.exception) + * else: + * return '%s(value=%r, exception=%r)' % (self.__class__.__name__, self.value, self.exception) # <<<<<<<<<<<<<< + * # add repr_recursive precaution + * + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 178, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_name); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 178, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 178, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); + __Pyx_INCREF(__pyx_v_self->value); + __Pyx_GIVEREF(__pyx_v_self->value); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_self->value); + __Pyx_INCREF(__pyx_v_self->exception); + __Pyx_GIVEREF(__pyx_v_self->exception); + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_v_self->exception); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_s_value_r_exception_r, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 178, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + } + + /* "gevent/ares.pyx":172 + * self.exception = exception + * + * def __repr__(self): # <<<<<<<<<<<<<< + * if self.exception is None: + * return '%s(%r)' % (self.__class__.__name__, self.value) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("gevent.ares.result.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "gevent/ares.pyx":181 + * # add repr_recursive precaution + * + * def successful(self): # <<<<<<<<<<<<<< + * return self.exception is None + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_4ares_6result_5successful(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_6gevent_4ares_6result_5successful(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("successful (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_4ares_6result_4successful(((struct __pyx_obj_6gevent_4ares_result *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_4ares_6result_4successful(struct __pyx_obj_6gevent_4ares_result *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("successful", 0); + + /* "gevent/ares.pyx":182 + * + * def successful(self): + * return self.exception is None # <<<<<<<<<<<<<< + * + * def get(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = (__pyx_v_self->exception == Py_None); + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 182, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "gevent/ares.pyx":181 + * # add repr_recursive precaution + * + * def successful(self): # <<<<<<<<<<<<<< + * return self.exception is None + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.ares.result.successful", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "gevent/ares.pyx":184 + * return self.exception is None + * + * def get(self): # <<<<<<<<<<<<<< + * if self.exception is not None: + * raise self.exception + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_4ares_6result_7get(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_6gevent_4ares_6result_7get(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("get (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_4ares_6result_6get(((struct __pyx_obj_6gevent_4ares_result *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_4ares_6result_6get(struct __pyx_obj_6gevent_4ares_result *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + __Pyx_RefNannySetupContext("get", 0); + + /* "gevent/ares.pyx":185 + * + * def get(self): + * if self.exception is not None: # <<<<<<<<<<<<<< + * raise self.exception + * return self.value + */ + __pyx_t_1 = (__pyx_v_self->exception != Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "gevent/ares.pyx":186 + * def get(self): + * if self.exception is not None: + * raise self.exception # <<<<<<<<<<<<<< + * return self.value + * + */ + __Pyx_Raise(__pyx_v_self->exception, 0, 0, 0); + __PYX_ERR(0, 186, __pyx_L1_error) + + /* "gevent/ares.pyx":185 + * + * def get(self): + * if self.exception is not None: # <<<<<<<<<<<<<< + * raise self.exception + * return self.value + */ + } + + /* "gevent/ares.pyx":187 + * if self.exception is not None: + * raise self.exception + * return self.value # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->value); + __pyx_r = __pyx_v_self->value; + goto __pyx_L0; + + /* "gevent/ares.pyx":184 + * return self.exception is None + * + * def get(self): # <<<<<<<<<<<<<< + * if self.exception is not None: + * raise self.exception + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("gevent.ares.result.get", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "gevent/ares.pyx":165 + * + * cdef class result: + * cdef public object value # <<<<<<<<<<<<<< + * cdef public object exception + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_4ares_6result_5value_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_4ares_6result_5value_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_4ares_6result_5value___get__(((struct __pyx_obj_6gevent_4ares_result *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_4ares_6result_5value___get__(struct __pyx_obj_6gevent_4ares_result *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->value); + __pyx_r = __pyx_v_self->value; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_4ares_6result_5value_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_6gevent_4ares_6result_5value_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_4ares_6result_5value_2__set__(((struct __pyx_obj_6gevent_4ares_result *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_4ares_6result_5value_2__set__(struct __pyx_obj_6gevent_4ares_result *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __Pyx_INCREF(__pyx_v_value); + __Pyx_GIVEREF(__pyx_v_value); + __Pyx_GOTREF(__pyx_v_self->value); + __Pyx_DECREF(__pyx_v_self->value); + __pyx_v_self->value = __pyx_v_value; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_4ares_6result_5value_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_6gevent_4ares_6result_5value_5__del__(PyObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_4ares_6result_5value_4__del__(((struct __pyx_obj_6gevent_4ares_result *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_4ares_6result_5value_4__del__(struct __pyx_obj_6gevent_4ares_result *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 0); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->value); + __Pyx_DECREF(__pyx_v_self->value); + __pyx_v_self->value = Py_None; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "gevent/ares.pyx":166 + * cdef class result: + * cdef public object value + * cdef public object exception # <<<<<<<<<<<<<< + * + * def __init__(self, object value=None, object exception=None): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_4ares_6result_9exception_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_4ares_6result_9exception_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_4ares_6result_9exception___get__(((struct __pyx_obj_6gevent_4ares_result *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_4ares_6result_9exception___get__(struct __pyx_obj_6gevent_4ares_result *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->exception); + __pyx_r = __pyx_v_self->exception; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_4ares_6result_9exception_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_6gevent_4ares_6result_9exception_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_4ares_6result_9exception_2__set__(((struct __pyx_obj_6gevent_4ares_result *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_4ares_6result_9exception_2__set__(struct __pyx_obj_6gevent_4ares_result *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __Pyx_INCREF(__pyx_v_value); + __Pyx_GIVEREF(__pyx_v_value); + __Pyx_GOTREF(__pyx_v_self->exception); + __Pyx_DECREF(__pyx_v_self->exception); + __pyx_v_self->exception = __pyx_v_value; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_4ares_6result_9exception_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_6gevent_4ares_6result_9exception_5__del__(PyObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_4ares_6result_9exception_4__del__(((struct __pyx_obj_6gevent_4ares_result *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_4ares_6result_9exception_4__del__(struct __pyx_obj_6gevent_4ares_result *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 0); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->exception); + __Pyx_DECREF(__pyx_v_self->exception); + __pyx_v_self->exception = Py_None; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "gevent/ares.pyx":192 + * class ares_host_result(tuple): + * + * def __new__(cls, family, iterable): # <<<<<<<<<<<<<< + * cdef object self = tuple.__new__(cls, iterable) + * self.family = family + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_4ares_16ares_host_result_1__new__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_6gevent_4ares_16ares_host_result_1__new__ = {"__new__", (PyCFunction)__pyx_pw_6gevent_4ares_16ares_host_result_1__new__, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6gevent_4ares_16ares_host_result_1__new__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_cls = 0; + PyObject *__pyx_v_family = 0; + PyObject *__pyx_v_iterable = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__new__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cls,&__pyx_n_s_family,&__pyx_n_s_iterable,0}; + PyObject* values[3] = {0,0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_cls)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_family)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__new__", 1, 3, 3, 1); __PYX_ERR(0, 192, __pyx_L3_error) + } + case 2: + if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_iterable)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__new__", 1, 3, 3, 2); __PYX_ERR(0, 192, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__new__") < 0)) __PYX_ERR(0, 192, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + } + __pyx_v_cls = values[0]; + __pyx_v_family = values[1]; + __pyx_v_iterable = values[2]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__new__", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 192, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.ares.ares_host_result.__new__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_4ares_16ares_host_result___new__(__pyx_self, __pyx_v_cls, __pyx_v_family, __pyx_v_iterable); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_4ares_16ares_host_result___new__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_cls, PyObject *__pyx_v_family, PyObject *__pyx_v_iterable) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + __Pyx_RefNannySetupContext("__new__", 0); + + /* "gevent/ares.pyx":193 + * + * def __new__(cls, family, iterable): + * cdef object self = tuple.__new__(cls, iterable) # <<<<<<<<<<<<<< + * self.family = family + * return self + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)(&PyTuple_Type)), __pyx_n_s_new); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 193, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_v_cls, __pyx_v_iterable}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 193, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_v_cls, __pyx_v_iterable}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 193, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 193, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (__pyx_t_3) { + __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = NULL; + } + __Pyx_INCREF(__pyx_v_cls); + __Pyx_GIVEREF(__pyx_v_cls); + PyTuple_SET_ITEM(__pyx_t_5, 0+__pyx_t_4, __pyx_v_cls); + __Pyx_INCREF(__pyx_v_iterable); + __Pyx_GIVEREF(__pyx_v_iterable); + PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_4, __pyx_v_iterable); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 193, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_self = __pyx_t_1; + __pyx_t_1 = 0; + + /* "gevent/ares.pyx":194 + * def __new__(cls, family, iterable): + * cdef object self = tuple.__new__(cls, iterable) + * self.family = family # <<<<<<<<<<<<<< + * return self + * + */ + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_family, __pyx_v_family) < 0) __PYX_ERR(0, 194, __pyx_L1_error) + + /* "gevent/ares.pyx":195 + * cdef object self = tuple.__new__(cls, iterable) + * self.family = family + * return self # <<<<<<<<<<<<<< + * + * def __getnewargs__(self): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self); + __pyx_r = __pyx_v_self; + goto __pyx_L0; + + /* "gevent/ares.pyx":192 + * class ares_host_result(tuple): + * + * def __new__(cls, family, iterable): # <<<<<<<<<<<<<< + * cdef object self = tuple.__new__(cls, iterable) + * self.family = family + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("gevent.ares.ares_host_result.__new__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_self); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "gevent/ares.pyx":197 + * return self + * + * def __getnewargs__(self): # <<<<<<<<<<<<<< + * return (self.family, tuple(self)) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_4ares_16ares_host_result_3__getnewargs__(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/ +static PyMethodDef __pyx_mdef_6gevent_4ares_16ares_host_result_3__getnewargs__ = {"__getnewargs__", (PyCFunction)__pyx_pw_6gevent_4ares_16ares_host_result_3__getnewargs__, METH_O, 0}; +static PyObject *__pyx_pw_6gevent_4ares_16ares_host_result_3__getnewargs__(PyObject *__pyx_self, PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getnewargs__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_4ares_16ares_host_result_2__getnewargs__(__pyx_self, ((PyObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_4ares_16ares_host_result_2__getnewargs__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("__getnewargs__", 0); + + /* "gevent/ares.pyx":198 + * + * def __getnewargs__(self): + * return (self.family, tuple(self)) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_family); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 198, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PySequence_Tuple(__pyx_v_self); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 198, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 198, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "gevent/ares.pyx":197 + * return self + * + * def __getnewargs__(self): # <<<<<<<<<<<<<< + * return (self.family, tuple(self)) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("gevent.ares.ares_host_result.__getnewargs__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "gevent/ares.pyx":201 + * + * + * cdef void gevent_ares_host_callback(void *arg, int status, int timeouts, hostent* host): # <<<<<<<<<<<<<< + * cdef channel channel + * cdef object callback + */ + +static void __pyx_f_6gevent_4ares_gevent_ares_host_callback(void *__pyx_v_arg, int __pyx_v_status, CYTHON_UNUSED int __pyx_v_timeouts, struct hostent *__pyx_v_host) { + struct PyGeventAresChannelObject *__pyx_v_channel = 0; + PyObject *__pyx_v_callback = 0; + PyObject *__pyx_v_host_result = 0; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + int __pyx_t_8; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11 = NULL; + int __pyx_t_12; + PyObject *__pyx_t_13 = NULL; + PyObject *__pyx_t_14 = NULL; + PyObject *__pyx_t_15 = NULL; + PyObject *__pyx_t_16 = NULL; + PyObject *__pyx_t_17 = NULL; + __Pyx_RefNannySetupContext("gevent_ares_host_callback", 0); + + /* "gevent/ares.pyx":204 + * cdef channel channel + * cdef object callback + * channel, callback = arg # <<<<<<<<<<<<<< + * Py_DECREF(arg) + * cdef object host_result + */ + __pyx_t_1 = ((PyObject *)__pyx_v_arg); + __Pyx_INCREF(__pyx_t_1); + if (likely(__pyx_t_1 != Py_None)) { + PyObject* sequence = __pyx_t_1; + #if !CYTHON_COMPILING_IN_PYPY + Py_ssize_t size = Py_SIZE(sequence); + #else + Py_ssize_t size = PySequence_Size(sequence); + #endif + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 204, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_3 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + #else + __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 204, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 204, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else { + __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(0, 204, __pyx_L1_error) + } + if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_6gevent_4ares_channel))))) __PYX_ERR(0, 204, __pyx_L1_error) + __pyx_v_channel = ((struct PyGeventAresChannelObject *)__pyx_t_2); + __pyx_t_2 = 0; + __pyx_v_callback = __pyx_t_3; + __pyx_t_3 = 0; + + /* "gevent/ares.pyx":205 + * cdef object callback + * channel, callback = arg + * Py_DECREF(arg) # <<<<<<<<<<<<<< + * cdef object host_result + * try: + */ + Py_DECREF(((PyObject*)__pyx_v_arg)); + + /* "gevent/ares.pyx":207 + * Py_DECREF(arg) + * cdef object host_result + * try: # <<<<<<<<<<<<<< + * if status or not host: + * callback(result(None, gaierror(status, strerror(status)))) + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_4, &__pyx_t_5, &__pyx_t_6); + __Pyx_XGOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_t_5); + __Pyx_XGOTREF(__pyx_t_6); + /*try:*/ { + + /* "gevent/ares.pyx":208 + * cdef object host_result + * try: + * if status or not host: # <<<<<<<<<<<<<< + * callback(result(None, gaierror(status, strerror(status)))) + * else: + */ + __pyx_t_8 = (__pyx_v_status != 0); + if (!__pyx_t_8) { + } else { + __pyx_t_7 = __pyx_t_8; + goto __pyx_L12_bool_binop_done; + } + __pyx_t_8 = ((!(__pyx_v_host != 0)) != 0); + __pyx_t_7 = __pyx_t_8; + __pyx_L12_bool_binop_done:; + if (__pyx_t_7) { + + /* "gevent/ares.pyx":209 + * try: + * if status or not host: + * callback(result(None, gaierror(status, strerror(status)))) # <<<<<<<<<<<<<< + * else: + * try: + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_gaierror); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 209, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_9 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 209, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 209, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_11 = __pyx_f_6gevent_4ares_strerror(__pyx_t_10, 0); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 209, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_10 = NULL; + __pyx_t_12 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_10)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_10); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_12 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[3] = {__pyx_t_10, __pyx_t_9, __pyx_t_11}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_12, 2+__pyx_t_12); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 209, __pyx_L3_error) + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[3] = {__pyx_t_10, __pyx_t_9, __pyx_t_11}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_12, 2+__pyx_t_12); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 209, __pyx_L3_error) + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + } else + #endif + { + __pyx_t_13 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 209, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_13); + if (__pyx_t_10) { + __Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_10); __pyx_t_10 = NULL; + } + __Pyx_GIVEREF(__pyx_t_9); + PyTuple_SET_ITEM(__pyx_t_13, 0+__pyx_t_12, __pyx_t_9); + __Pyx_GIVEREF(__pyx_t_11); + PyTuple_SET_ITEM(__pyx_t_13, 1+__pyx_t_12, __pyx_t_11); + __pyx_t_9 = 0; + __pyx_t_11 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_13, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 209, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 209, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + PyTuple_SET_ITEM(__pyx_t_2, 0, Py_None); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6gevent_4ares_result), __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 209, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_INCREF(__pyx_v_callback); + __pyx_t_2 = __pyx_v_callback; __pyx_t_13 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_13)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_13); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (!__pyx_t_13) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 209, __pyx_L3_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_13, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 209, __pyx_L3_error) + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_13, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 209, __pyx_L3_error) + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + { + __pyx_t_11 = PyTuple_New(1+1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 209, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_GIVEREF(__pyx_t_13); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_13); __pyx_t_13 = NULL; + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_11, 0+1, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_11, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 209, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "gevent/ares.pyx":208 + * cdef object host_result + * try: + * if status or not host: # <<<<<<<<<<<<<< + * callback(result(None, gaierror(status, strerror(status)))) + * else: + */ + goto __pyx_L11; + } + + /* "gevent/ares.pyx":211 + * callback(result(None, gaierror(status, strerror(status)))) + * else: + * try: # <<<<<<<<<<<<<< + * host_result = ares_host_result(host.h_addrtype, (parse_h_name(host), parse_h_aliases(host), parse_h_addr_list(host))) + * except: + */ + /*else*/ { + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16); + __Pyx_XGOTREF(__pyx_t_14); + __Pyx_XGOTREF(__pyx_t_15); + __Pyx_XGOTREF(__pyx_t_16); + /*try:*/ { + + /* "gevent/ares.pyx":212 + * else: + * try: + * host_result = ares_host_result(host.h_addrtype, (parse_h_name(host), parse_h_aliases(host), parse_h_addr_list(host))) # <<<<<<<<<<<<<< + * except: + * callback(result(None, sys.exc_info()[1])) + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_ares_host_result); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 212, __pyx_L14_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_11 = __Pyx_PyInt_From_int(__pyx_v_host->h_addrtype); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 212, __pyx_L14_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_3 = parse_h_name(__pyx_v_host); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 212, __pyx_L14_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_13 = parse_h_aliases(__pyx_v_host); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 212, __pyx_L14_error) + __Pyx_GOTREF(__pyx_t_13); + __pyx_t_9 = parse_h_addr_list(__pyx_v_host); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 212, __pyx_L14_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = PyTuple_New(3); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 212, __pyx_L14_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_13); + PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_t_13); + __Pyx_GIVEREF(__pyx_t_9); + PyTuple_SET_ITEM(__pyx_t_10, 2, __pyx_t_9); + __pyx_t_3 = 0; + __pyx_t_13 = 0; + __pyx_t_9 = 0; + __pyx_t_9 = NULL; + __pyx_t_12 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_12 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_t_11, __pyx_t_10}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_12, 2+__pyx_t_12); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 212, __pyx_L14_error) + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_t_11, __pyx_t_10}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_12, 2+__pyx_t_12); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 212, __pyx_L14_error) + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + } else + #endif + { + __pyx_t_13 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 212, __pyx_L14_error) + __Pyx_GOTREF(__pyx_t_13); + if (__pyx_t_9) { + __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_9); __pyx_t_9 = NULL; + } + __Pyx_GIVEREF(__pyx_t_11); + PyTuple_SET_ITEM(__pyx_t_13, 0+__pyx_t_12, __pyx_t_11); + __Pyx_GIVEREF(__pyx_t_10); + PyTuple_SET_ITEM(__pyx_t_13, 1+__pyx_t_12, __pyx_t_10); + __pyx_t_11 = 0; + __pyx_t_10 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_13, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 212, __pyx_L14_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_host_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "gevent/ares.pyx":211 + * callback(result(None, gaierror(status, strerror(status)))) + * else: + * try: # <<<<<<<<<<<<<< + * host_result = ares_host_result(host.h_addrtype, (parse_h_name(host), parse_h_aliases(host), parse_h_addr_list(host))) + * except: + */ + } + + /* "gevent/ares.pyx":216 + * callback(result(None, sys.exc_info()[1])) + * else: + * callback(result(host_result)) # <<<<<<<<<<<<<< + * except: + * channel.loop.handle_error(callback, *sys.exc_info()) + */ + /*else:*/ { + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 216, __pyx_L16_except_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_v_host_result); + __Pyx_GIVEREF(__pyx_v_host_result); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_host_result); + __pyx_t_13 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6gevent_4ares_result), __pyx_t_2, NULL); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 216, __pyx_L16_except_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_INCREF(__pyx_v_callback); + __pyx_t_2 = __pyx_v_callback; __pyx_t_10 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_10)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_10); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (!__pyx_t_10) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_13); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 216, __pyx_L16_except_error) + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_10, __pyx_t_13}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 216, __pyx_L16_except_error) + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_10, __pyx_t_13}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 216, __pyx_L16_except_error) + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + } else + #endif + { + __pyx_t_11 = PyTuple_New(1+1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 216, __pyx_L16_except_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_10); __pyx_t_10 = NULL; + __Pyx_GIVEREF(__pyx_t_13); + PyTuple_SET_ITEM(__pyx_t_11, 0+1, __pyx_t_13); + __pyx_t_13 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_11, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 216, __pyx_L16_except_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; + goto __pyx_L21_try_end; + __pyx_L14_error:; + __Pyx_PyThreadState_assign + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "gevent/ares.pyx":213 + * try: + * host_result = ares_host_result(host.h_addrtype, (parse_h_name(host), parse_h_aliases(host), parse_h_addr_list(host))) + * except: # <<<<<<<<<<<<<< + * callback(result(None, sys.exc_info()[1])) + * else: + */ + /*except:*/ { + __Pyx_AddTraceback("gevent.ares.gevent_ares_host_callback", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_2, &__pyx_t_11) < 0) __PYX_ERR(0, 213, __pyx_L16_except_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_t_11); + + /* "gevent/ares.pyx":214 + * host_result = ares_host_result(host.h_addrtype, (parse_h_name(host), parse_h_aliases(host), parse_h_addr_list(host))) + * except: + * callback(result(None, sys.exc_info()[1])) # <<<<<<<<<<<<<< + * else: + * callback(result(host_result)) + */ + __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_sys); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 214, __pyx_L16_except_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_exc_info); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 214, __pyx_L16_except_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_9) { + __pyx_t_10 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 214, __pyx_L16_except_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } else { + __pyx_t_10 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 214, __pyx_L16_except_error) + } + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_10, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 214, __pyx_L16_except_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_10 = PyTuple_New(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 214, __pyx_L16_except_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + PyTuple_SET_ITEM(__pyx_t_10, 0, Py_None); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6gevent_4ares_result), __pyx_t_10, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 214, __pyx_L16_except_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_INCREF(__pyx_v_callback); + __pyx_t_10 = __pyx_v_callback; __pyx_t_9 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_10))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_10); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_10); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_10, function); + } + } + if (!__pyx_t_9) { + __pyx_t_13 = __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_t_3); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 214, __pyx_L16_except_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_13); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_10)) { + PyObject *__pyx_temp[2] = {__pyx_t_9, __pyx_t_3}; + __pyx_t_13 = __Pyx_PyFunction_FastCall(__pyx_t_10, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 214, __pyx_L16_except_error) + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_10)) { + PyObject *__pyx_temp[2] = {__pyx_t_9, __pyx_t_3}; + __pyx_t_13 = __Pyx_PyCFunction_FastCall(__pyx_t_10, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 214, __pyx_L16_except_error) + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + { + __pyx_t_17 = PyTuple_New(1+1); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 214, __pyx_L16_except_error) + __Pyx_GOTREF(__pyx_t_17); + __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_17, 0, __pyx_t_9); __pyx_t_9 = NULL; + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_17, 0+1, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_13 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_17, NULL); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 214, __pyx_L16_except_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + } + } + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + goto __pyx_L15_exception_handled; + } + __pyx_L16_except_error:; + + /* "gevent/ares.pyx":211 + * callback(result(None, gaierror(status, strerror(status)))) + * else: + * try: # <<<<<<<<<<<<<< + * host_result = ares_host_result(host.h_addrtype, (parse_h_name(host), parse_h_aliases(host), parse_h_addr_list(host))) + * except: + */ + __Pyx_PyThreadState_assign + __Pyx_XGIVEREF(__pyx_t_14); + __Pyx_XGIVEREF(__pyx_t_15); + __Pyx_XGIVEREF(__pyx_t_16); + __Pyx_ExceptionReset(__pyx_t_14, __pyx_t_15, __pyx_t_16); + goto __pyx_L3_error; + __pyx_L15_exception_handled:; + __Pyx_PyThreadState_assign + __Pyx_XGIVEREF(__pyx_t_14); + __Pyx_XGIVEREF(__pyx_t_15); + __Pyx_XGIVEREF(__pyx_t_16); + __Pyx_ExceptionReset(__pyx_t_14, __pyx_t_15, __pyx_t_16); + __pyx_L21_try_end:; + } + } + __pyx_L11:; + + /* "gevent/ares.pyx":207 + * Py_DECREF(arg) + * cdef object host_result + * try: # <<<<<<<<<<<<<< + * if status or not host: + * callback(result(None, gaierror(status, strerror(status)))) + */ + } + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + goto __pyx_L10_try_end; + __pyx_L3_error:; + __Pyx_PyThreadState_assign + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0; + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + + /* "gevent/ares.pyx":217 + * else: + * callback(result(host_result)) + * except: # <<<<<<<<<<<<<< + * channel.loop.handle_error(callback, *sys.exc_info()) + * + */ + /*except:*/ { + __Pyx_AddTraceback("gevent.ares.gevent_ares_host_callback", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_11, &__pyx_t_2, &__pyx_t_1) < 0) __PYX_ERR(0, 217, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_t_1); + + /* "gevent/ares.pyx":218 + * callback(result(host_result)) + * except: + * channel.loop.handle_error(callback, *sys.exc_info()) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_channel->loop, __pyx_n_s_handle_error); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 218, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_13); + __pyx_t_10 = PyTuple_New(1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 218, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_INCREF(__pyx_v_callback); + __Pyx_GIVEREF(__pyx_v_callback); + PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_v_callback); + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_sys); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 218, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_exc_info); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 218, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_9); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_9, function); + } + } + if (__pyx_t_3) { + __pyx_t_17 = __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_t_3); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 218, __pyx_L5_except_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __pyx_t_17 = __Pyx_PyObject_CallNoArg(__pyx_t_9); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 218, __pyx_L5_except_error) + } + __Pyx_GOTREF(__pyx_t_17); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = PySequence_Tuple(__pyx_t_17); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 218, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + __pyx_t_17 = PyNumber_Add(__pyx_t_10, __pyx_t_9); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 218, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_17); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_13, __pyx_t_17, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 218, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L4_exception_handled; + } + __pyx_L5_except_error:; + + /* "gevent/ares.pyx":207 + * Py_DECREF(arg) + * cdef object host_result + * try: # <<<<<<<<<<<<<< + * if status or not host: + * callback(result(None, gaierror(status, strerror(status)))) + */ + __Pyx_PyThreadState_assign + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_XGIVEREF(__pyx_t_6); + __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6); + goto __pyx_L1_error; + __pyx_L4_exception_handled:; + __Pyx_PyThreadState_assign + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_XGIVEREF(__pyx_t_6); + __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6); + __pyx_L10_try_end:; + } + + /* "gevent/ares.pyx":201 + * + * + * cdef void gevent_ares_host_callback(void *arg, int status, int timeouts, hostent* host): # <<<<<<<<<<<<<< + * cdef channel channel + * cdef object callback + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_XDECREF(__pyx_t_13); + __Pyx_XDECREF(__pyx_t_17); + __Pyx_WriteUnraisable("gevent.ares.gevent_ares_host_callback", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0); + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_channel); + __Pyx_XDECREF(__pyx_v_callback); + __Pyx_XDECREF(__pyx_v_host_result); + __Pyx_RefNannyFinishContext(); +} + +/* "gevent/ares.pyx":221 + * + * + * cdef void gevent_ares_nameinfo_callback(void *arg, int status, int timeouts, char *c_node, char *c_service): # <<<<<<<<<<<<<< + * cdef channel channel + * cdef object callback + */ + +static void __pyx_f_6gevent_4ares_gevent_ares_nameinfo_callback(void *__pyx_v_arg, int __pyx_v_status, CYTHON_UNUSED int __pyx_v_timeouts, char *__pyx_v_c_node, char *__pyx_v_c_service) { + struct PyGeventAresChannelObject *__pyx_v_channel = 0; + PyObject *__pyx_v_callback = 0; + PyObject *__pyx_v_node = 0; + PyObject *__pyx_v_service = 0; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + int __pyx_t_11; + PyObject *__pyx_t_12 = NULL; + PyObject *__pyx_t_13 = NULL; + __Pyx_RefNannySetupContext("gevent_ares_nameinfo_callback", 0); + + /* "gevent/ares.pyx":224 + * cdef channel channel + * cdef object callback + * channel, callback = arg # <<<<<<<<<<<<<< + * Py_DECREF(arg) + * cdef object node + */ + __pyx_t_1 = ((PyObject *)__pyx_v_arg); + __Pyx_INCREF(__pyx_t_1); + if (likely(__pyx_t_1 != Py_None)) { + PyObject* sequence = __pyx_t_1; + #if !CYTHON_COMPILING_IN_PYPY + Py_ssize_t size = Py_SIZE(sequence); + #else + Py_ssize_t size = PySequence_Size(sequence); + #endif + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 224, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_3 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + #else + __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else { + __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(0, 224, __pyx_L1_error) + } + if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_6gevent_4ares_channel))))) __PYX_ERR(0, 224, __pyx_L1_error) + __pyx_v_channel = ((struct PyGeventAresChannelObject *)__pyx_t_2); + __pyx_t_2 = 0; + __pyx_v_callback = __pyx_t_3; + __pyx_t_3 = 0; + + /* "gevent/ares.pyx":225 + * cdef object callback + * channel, callback = arg + * Py_DECREF(arg) # <<<<<<<<<<<<<< + * cdef object node + * cdef object service + */ + Py_DECREF(((PyObject*)__pyx_v_arg)); + + /* "gevent/ares.pyx":228 + * cdef object node + * cdef object service + * try: # <<<<<<<<<<<<<< + * if status: + * callback(result(None, gaierror(status, strerror(status)))) + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_4, &__pyx_t_5, &__pyx_t_6); + __Pyx_XGOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_t_5); + __Pyx_XGOTREF(__pyx_t_6); + /*try:*/ { + + /* "gevent/ares.pyx":229 + * cdef object service + * try: + * if status: # <<<<<<<<<<<<<< + * callback(result(None, gaierror(status, strerror(status)))) + * else: + */ + __pyx_t_7 = (__pyx_v_status != 0); + if (__pyx_t_7) { + + /* "gevent/ares.pyx":230 + * try: + * if status: + * callback(result(None, gaierror(status, strerror(status)))) # <<<<<<<<<<<<<< + * else: + * if c_node: + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_gaierror); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 230, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_8 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 230, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 230, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = __pyx_f_6gevent_4ares_strerror(__pyx_t_9, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 230, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = NULL; + __pyx_t_11 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_11 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_t_8, __pyx_t_10}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 230, __pyx_L3_error) + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_t_8, __pyx_t_10}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 230, __pyx_L3_error) + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + } else + #endif + { + __pyx_t_12 = PyTuple_New(2+__pyx_t_11); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 230, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_12); + if (__pyx_t_9) { + __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_9); __pyx_t_9 = NULL; + } + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_12, 0+__pyx_t_11, __pyx_t_8); + __Pyx_GIVEREF(__pyx_t_10); + PyTuple_SET_ITEM(__pyx_t_12, 1+__pyx_t_11, __pyx_t_10); + __pyx_t_8 = 0; + __pyx_t_10 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_12, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 230, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 230, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + PyTuple_SET_ITEM(__pyx_t_2, 0, Py_None); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6gevent_4ares_result), __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 230, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_INCREF(__pyx_v_callback); + __pyx_t_2 = __pyx_v_callback; __pyx_t_12 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_12)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_12); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (!__pyx_t_12) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 230, __pyx_L3_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_12, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 230, __pyx_L3_error) + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_12, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 230, __pyx_L3_error) + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + { + __pyx_t_10 = PyTuple_New(1+1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 230, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_GIVEREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_12); __pyx_t_12 = NULL; + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_10, 0+1, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_10, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 230, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "gevent/ares.pyx":229 + * cdef object service + * try: + * if status: # <<<<<<<<<<<<<< + * callback(result(None, gaierror(status, strerror(status)))) + * else: + */ + goto __pyx_L11; + } + + /* "gevent/ares.pyx":232 + * callback(result(None, gaierror(status, strerror(status)))) + * else: + * if c_node: # <<<<<<<<<<<<<< + * node = PyUnicode_FromString(c_node) + * else: + */ + /*else*/ { + __pyx_t_7 = (__pyx_v_c_node != 0); + if (__pyx_t_7) { + + /* "gevent/ares.pyx":233 + * else: + * if c_node: + * node = PyUnicode_FromString(c_node) # <<<<<<<<<<<<<< + * else: + * node = None + */ + __pyx_t_1 = PyUnicode_FromString(__pyx_v_c_node); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 233, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_node = __pyx_t_1; + __pyx_t_1 = 0; + + /* "gevent/ares.pyx":232 + * callback(result(None, gaierror(status, strerror(status)))) + * else: + * if c_node: # <<<<<<<<<<<<<< + * node = PyUnicode_FromString(c_node) + * else: + */ + goto __pyx_L12; + } + + /* "gevent/ares.pyx":235 + * node = PyUnicode_FromString(c_node) + * else: + * node = None # <<<<<<<<<<<<<< + * if c_service: + * service = PyUnicode_FromString(c_service) + */ + /*else*/ { + __Pyx_INCREF(Py_None); + __pyx_v_node = Py_None; + } + __pyx_L12:; + + /* "gevent/ares.pyx":236 + * else: + * node = None + * if c_service: # <<<<<<<<<<<<<< + * service = PyUnicode_FromString(c_service) + * else: + */ + __pyx_t_7 = (__pyx_v_c_service != 0); + if (__pyx_t_7) { + + /* "gevent/ares.pyx":237 + * node = None + * if c_service: + * service = PyUnicode_FromString(c_service) # <<<<<<<<<<<<<< + * else: + * service = None + */ + __pyx_t_1 = PyUnicode_FromString(__pyx_v_c_service); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 237, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_service = __pyx_t_1; + __pyx_t_1 = 0; + + /* "gevent/ares.pyx":236 + * else: + * node = None + * if c_service: # <<<<<<<<<<<<<< + * service = PyUnicode_FromString(c_service) + * else: + */ + goto __pyx_L13; + } + + /* "gevent/ares.pyx":239 + * service = PyUnicode_FromString(c_service) + * else: + * service = None # <<<<<<<<<<<<<< + * callback(result((node, service))) + * except: + */ + /*else*/ { + __Pyx_INCREF(Py_None); + __pyx_v_service = Py_None; + } + __pyx_L13:; + + /* "gevent/ares.pyx":240 + * else: + * service = None + * callback(result((node, service))) # <<<<<<<<<<<<<< + * except: + * channel.loop.handle_error(callback, *sys.exc_info()) + */ + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 240, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_v_node); + __Pyx_GIVEREF(__pyx_v_node); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_node); + __Pyx_INCREF(__pyx_v_service); + __Pyx_GIVEREF(__pyx_v_service); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_service); + __pyx_t_10 = PyTuple_New(1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 240, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6gevent_4ares_result), __pyx_t_10, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 240, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_INCREF(__pyx_v_callback); + __pyx_t_10 = __pyx_v_callback; __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_10))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_10); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_10); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_10, function); + } + } + if (!__pyx_t_3) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 240, __pyx_L3_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_10)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_2}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_10, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 240, __pyx_L3_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_10)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_2}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_10, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 240, __pyx_L3_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else + #endif + { + __pyx_t_12 = PyTuple_New(1+1); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 240, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_3); __pyx_t_3 = NULL; + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_12, 0+1, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_12, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 240, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + } + } + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __pyx_L11:; + + /* "gevent/ares.pyx":228 + * cdef object node + * cdef object service + * try: # <<<<<<<<<<<<<< + * if status: + * callback(result(None, gaierror(status, strerror(status)))) + */ + } + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + goto __pyx_L10_try_end; + __pyx_L3_error:; + __Pyx_PyThreadState_assign + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "gevent/ares.pyx":241 + * service = None + * callback(result((node, service))) + * except: # <<<<<<<<<<<<<< + * channel.loop.handle_error(callback, *sys.exc_info()) + * + */ + /*except:*/ { + __Pyx_AddTraceback("gevent.ares.gevent_ares_nameinfo_callback", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_10, &__pyx_t_12) < 0) __PYX_ERR(0, 241, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_t_10); + __Pyx_GOTREF(__pyx_t_12); + + /* "gevent/ares.pyx":242 + * callback(result((node, service))) + * except: + * channel.loop.handle_error(callback, *sys.exc_info()) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_channel->loop, __pyx_n_s_handle_error); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 242, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 242, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_v_callback); + __Pyx_GIVEREF(__pyx_v_callback); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_callback); + __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_sys); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 242, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_exc_info); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 242, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_13))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_13); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_13, function); + } + } + if (__pyx_t_9) { + __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_t_9); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 242, __pyx_L5_except_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } else { + __pyx_t_8 = __Pyx_PyObject_CallNoArg(__pyx_t_13); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 242, __pyx_L5_except_error) + } + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __pyx_t_13 = PySequence_Tuple(__pyx_t_8); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 242, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = PyNumber_Add(__pyx_t_3, __pyx_t_13); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 242, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __pyx_t_13 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_8, NULL); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 242, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + goto __pyx_L4_exception_handled; + } + __pyx_L5_except_error:; + + /* "gevent/ares.pyx":228 + * cdef object node + * cdef object service + * try: # <<<<<<<<<<<<<< + * if status: + * callback(result(None, gaierror(status, strerror(status)))) + */ + __Pyx_PyThreadState_assign + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_XGIVEREF(__pyx_t_6); + __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6); + goto __pyx_L1_error; + __pyx_L4_exception_handled:; + __Pyx_PyThreadState_assign + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_XGIVEREF(__pyx_t_6); + __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6); + __pyx_L10_try_end:; + } + + /* "gevent/ares.pyx":221 + * + * + * cdef void gevent_ares_nameinfo_callback(void *arg, int status, int timeouts, char *c_node, char *c_service): # <<<<<<<<<<<<<< + * cdef channel channel + * cdef object callback + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_XDECREF(__pyx_t_13); + __Pyx_WriteUnraisable("gevent.ares.gevent_ares_nameinfo_callback", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0); + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_channel); + __Pyx_XDECREF(__pyx_v_callback); + __Pyx_XDECREF(__pyx_v_node); + __Pyx_XDECREF(__pyx_v_service); + __Pyx_RefNannyFinishContext(); +} + +/* "gevent/ares.pyx":252 + * cdef public object _timer + * + * def __init__(self, object loop, flags=None, timeout=None, tries=None, ndots=None, # <<<<<<<<<<<<<< + * udp_port=None, tcp_port=None, servers=None): + * cdef ares_channeldata* channel = NULL + */ + +/* Python wrapper */ +static int __pyx_pw_6gevent_4ares_7channel_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_6gevent_4ares_7channel_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_loop = 0; + PyObject *__pyx_v_flags = 0; + PyObject *__pyx_v_timeout = 0; + PyObject *__pyx_v_tries = 0; + PyObject *__pyx_v_ndots = 0; + PyObject *__pyx_v_udp_port = 0; + PyObject *__pyx_v_tcp_port = 0; + PyObject *__pyx_v_servers = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_loop,&__pyx_n_s_flags,&__pyx_n_s_timeout,&__pyx_n_s_tries,&__pyx_n_s_ndots,&__pyx_n_s_udp_port,&__pyx_n_s_tcp_port,&__pyx_n_s_servers,0}; + PyObject* values[8] = {0,0,0,0,0,0,0,0}; + values[1] = ((PyObject *)Py_None); + values[2] = ((PyObject *)Py_None); + values[3] = ((PyObject *)Py_None); + values[4] = ((PyObject *)Py_None); + + /* "gevent/ares.pyx":253 + * + * def __init__(self, object loop, flags=None, timeout=None, tries=None, ndots=None, + * udp_port=None, tcp_port=None, servers=None): # <<<<<<<<<<<<<< + * cdef ares_channeldata* channel = NULL + * cdef cares.ares_options options + */ + values[5] = ((PyObject *)Py_None); + values[6] = ((PyObject *)Py_None); + values[7] = ((PyObject *)Py_None); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7); + case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6); + case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_loop)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_flags); + if (value) { values[1] = value; kw_args--; } + } + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_timeout); + if (value) { values[2] = value; kw_args--; } + } + case 3: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_tries); + if (value) { values[3] = value; kw_args--; } + } + case 4: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ndots); + if (value) { values[4] = value; kw_args--; } + } + case 5: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_udp_port); + if (value) { values[5] = value; kw_args--; } + } + case 6: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_tcp_port); + if (value) { values[6] = value; kw_args--; } + } + case 7: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_servers); + if (value) { values[7] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 252, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7); + case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6); + case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_loop = values[0]; + __pyx_v_flags = values[1]; + __pyx_v_timeout = values[2]; + __pyx_v_tries = values[3]; + __pyx_v_ndots = values[4]; + __pyx_v_udp_port = values[5]; + __pyx_v_tcp_port = values[6]; + __pyx_v_servers = values[7]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 0, 1, 8, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 252, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.ares.channel.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_4ares_7channel___init__(((struct PyGeventAresChannelObject *)__pyx_v_self), __pyx_v_loop, __pyx_v_flags, __pyx_v_timeout, __pyx_v_tries, __pyx_v_ndots, __pyx_v_udp_port, __pyx_v_tcp_port, __pyx_v_servers); + + /* "gevent/ares.pyx":252 + * cdef public object _timer + * + * def __init__(self, object loop, flags=None, timeout=None, tries=None, ndots=None, # <<<<<<<<<<<<<< + * udp_port=None, tcp_port=None, servers=None): + * cdef ares_channeldata* channel = NULL + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_4ares_7channel___init__(struct PyGeventAresChannelObject *__pyx_v_self, PyObject *__pyx_v_loop, PyObject *__pyx_v_flags, PyObject *__pyx_v_timeout, PyObject *__pyx_v_tries, PyObject *__pyx_v_ndots, PyObject *__pyx_v_udp_port, PyObject *__pyx_v_tcp_port, PyObject *__pyx_v_servers) { + struct ares_channeldata *__pyx_v_channel; + struct ares_options __pyx_v_options; + int __pyx_v_optmask; + int __pyx_v_result; + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + double __pyx_t_5; + unsigned short __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11 = NULL; + PyObject *__pyx_t_12 = NULL; + PyObject *__pyx_t_13 = NULL; + PyObject *__pyx_t_14 = NULL; + __Pyx_RefNannySetupContext("__init__", 0); + + /* "gevent/ares.pyx":254 + * def __init__(self, object loop, flags=None, timeout=None, tries=None, ndots=None, + * udp_port=None, tcp_port=None, servers=None): + * cdef ares_channeldata* channel = NULL # <<<<<<<<<<<<<< + * cdef cares.ares_options options + * memset(&options, 0, sizeof(cares.ares_options)) + */ + __pyx_v_channel = NULL; + + /* "gevent/ares.pyx":256 + * cdef ares_channeldata* channel = NULL + * cdef cares.ares_options options + * memset(&options, 0, sizeof(cares.ares_options)) # <<<<<<<<<<<<<< + * cdef int optmask = cares.ARES_OPT_SOCK_STATE_CB + * options.sock_state_cb = gevent_sock_state_callback + */ + memset((&__pyx_v_options), 0, (sizeof(struct ares_options))); + + /* "gevent/ares.pyx":257 + * cdef cares.ares_options options + * memset(&options, 0, sizeof(cares.ares_options)) + * cdef int optmask = cares.ARES_OPT_SOCK_STATE_CB # <<<<<<<<<<<<<< + * options.sock_state_cb = gevent_sock_state_callback + * options.sock_state_cb_data = self + */ + __pyx_v_optmask = ARES_OPT_SOCK_STATE_CB; + + /* "gevent/ares.pyx":258 + * memset(&options, 0, sizeof(cares.ares_options)) + * cdef int optmask = cares.ARES_OPT_SOCK_STATE_CB + * options.sock_state_cb = gevent_sock_state_callback # <<<<<<<<<<<<<< + * options.sock_state_cb_data = self + * if flags is not None: + */ + __pyx_v_options.sock_state_cb = ((void *)__pyx_f_6gevent_4ares_gevent_sock_state_callback); + + /* "gevent/ares.pyx":259 + * cdef int optmask = cares.ARES_OPT_SOCK_STATE_CB + * options.sock_state_cb = gevent_sock_state_callback + * options.sock_state_cb_data = self # <<<<<<<<<<<<<< + * if flags is not None: + * options.flags = int(flags) + */ + __pyx_v_options.sock_state_cb_data = ((void *)__pyx_v_self); + + /* "gevent/ares.pyx":260 + * options.sock_state_cb = gevent_sock_state_callback + * options.sock_state_cb_data = self + * if flags is not None: # <<<<<<<<<<<<<< + * options.flags = int(flags) + * optmask |= cares.ARES_OPT_FLAGS + */ + __pyx_t_1 = (__pyx_v_flags != Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "gevent/ares.pyx":261 + * options.sock_state_cb_data = self + * if flags is not None: + * options.flags = int(flags) # <<<<<<<<<<<<<< + * optmask |= cares.ARES_OPT_FLAGS + * if timeout is not None: + */ + __pyx_t_3 = __Pyx_PyNumber_Int(__pyx_v_flags); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 261, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 261, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_options.flags = __pyx_t_4; + + /* "gevent/ares.pyx":262 + * if flags is not None: + * options.flags = int(flags) + * optmask |= cares.ARES_OPT_FLAGS # <<<<<<<<<<<<<< + * if timeout is not None: + * options.timeout = int(float(timeout) * 1000) + */ + __pyx_v_optmask = (__pyx_v_optmask | ARES_OPT_FLAGS); + + /* "gevent/ares.pyx":260 + * options.sock_state_cb = gevent_sock_state_callback + * options.sock_state_cb_data = self + * if flags is not None: # <<<<<<<<<<<<<< + * options.flags = int(flags) + * optmask |= cares.ARES_OPT_FLAGS + */ + } + + /* "gevent/ares.pyx":263 + * options.flags = int(flags) + * optmask |= cares.ARES_OPT_FLAGS + * if timeout is not None: # <<<<<<<<<<<<<< + * options.timeout = int(float(timeout) * 1000) + * optmask |= cares.ARES_OPT_TIMEOUTMS + */ + __pyx_t_2 = (__pyx_v_timeout != Py_None); + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { + + /* "gevent/ares.pyx":264 + * optmask |= cares.ARES_OPT_FLAGS + * if timeout is not None: + * options.timeout = int(float(timeout) * 1000) # <<<<<<<<<<<<<< + * optmask |= cares.ARES_OPT_TIMEOUTMS + * if tries is not None: + */ + __pyx_t_5 = __Pyx_PyObject_AsDouble(__pyx_v_timeout); if (unlikely(__pyx_t_5 == ((double)-1) && PyErr_Occurred())) __PYX_ERR(0, 264, __pyx_L1_error) + __pyx_v_options.timeout = ((int)(__pyx_t_5 * 1000.0)); + + /* "gevent/ares.pyx":265 + * if timeout is not None: + * options.timeout = int(float(timeout) * 1000) + * optmask |= cares.ARES_OPT_TIMEOUTMS # <<<<<<<<<<<<<< + * if tries is not None: + * options.tries = int(tries) + */ + __pyx_v_optmask = (__pyx_v_optmask | ARES_OPT_TIMEOUTMS); + + /* "gevent/ares.pyx":263 + * options.flags = int(flags) + * optmask |= cares.ARES_OPT_FLAGS + * if timeout is not None: # <<<<<<<<<<<<<< + * options.timeout = int(float(timeout) * 1000) + * optmask |= cares.ARES_OPT_TIMEOUTMS + */ + } + + /* "gevent/ares.pyx":266 + * options.timeout = int(float(timeout) * 1000) + * optmask |= cares.ARES_OPT_TIMEOUTMS + * if tries is not None: # <<<<<<<<<<<<<< + * options.tries = int(tries) + * optmask |= cares.ARES_OPT_TRIES + */ + __pyx_t_1 = (__pyx_v_tries != Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "gevent/ares.pyx":267 + * optmask |= cares.ARES_OPT_TIMEOUTMS + * if tries is not None: + * options.tries = int(tries) # <<<<<<<<<<<<<< + * optmask |= cares.ARES_OPT_TRIES + * if ndots is not None: + */ + __pyx_t_3 = __Pyx_PyNumber_Int(__pyx_v_tries); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 267, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 267, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_options.tries = __pyx_t_4; + + /* "gevent/ares.pyx":268 + * if tries is not None: + * options.tries = int(tries) + * optmask |= cares.ARES_OPT_TRIES # <<<<<<<<<<<<<< + * if ndots is not None: + * options.ndots = int(ndots) + */ + __pyx_v_optmask = (__pyx_v_optmask | ARES_OPT_TRIES); + + /* "gevent/ares.pyx":266 + * options.timeout = int(float(timeout) * 1000) + * optmask |= cares.ARES_OPT_TIMEOUTMS + * if tries is not None: # <<<<<<<<<<<<<< + * options.tries = int(tries) + * optmask |= cares.ARES_OPT_TRIES + */ + } + + /* "gevent/ares.pyx":269 + * options.tries = int(tries) + * optmask |= cares.ARES_OPT_TRIES + * if ndots is not None: # <<<<<<<<<<<<<< + * options.ndots = int(ndots) + * optmask |= cares.ARES_OPT_NDOTS + */ + __pyx_t_2 = (__pyx_v_ndots != Py_None); + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { + + /* "gevent/ares.pyx":270 + * optmask |= cares.ARES_OPT_TRIES + * if ndots is not None: + * options.ndots = int(ndots) # <<<<<<<<<<<<<< + * optmask |= cares.ARES_OPT_NDOTS + * if udp_port is not None: + */ + __pyx_t_3 = __Pyx_PyNumber_Int(__pyx_v_ndots); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 270, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 270, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_options.ndots = __pyx_t_4; + + /* "gevent/ares.pyx":271 + * if ndots is not None: + * options.ndots = int(ndots) + * optmask |= cares.ARES_OPT_NDOTS # <<<<<<<<<<<<<< + * if udp_port is not None: + * options.udp_port = int(udp_port) + */ + __pyx_v_optmask = (__pyx_v_optmask | ARES_OPT_NDOTS); + + /* "gevent/ares.pyx":269 + * options.tries = int(tries) + * optmask |= cares.ARES_OPT_TRIES + * if ndots is not None: # <<<<<<<<<<<<<< + * options.ndots = int(ndots) + * optmask |= cares.ARES_OPT_NDOTS + */ + } + + /* "gevent/ares.pyx":272 + * options.ndots = int(ndots) + * optmask |= cares.ARES_OPT_NDOTS + * if udp_port is not None: # <<<<<<<<<<<<<< + * options.udp_port = int(udp_port) + * optmask |= cares.ARES_OPT_UDP_PORT + */ + __pyx_t_1 = (__pyx_v_udp_port != Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "gevent/ares.pyx":273 + * optmask |= cares.ARES_OPT_NDOTS + * if udp_port is not None: + * options.udp_port = int(udp_port) # <<<<<<<<<<<<<< + * optmask |= cares.ARES_OPT_UDP_PORT + * if tcp_port is not None: + */ + __pyx_t_3 = __Pyx_PyNumber_Int(__pyx_v_udp_port); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 273, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = __Pyx_PyInt_As_unsigned_short(__pyx_t_3); if (unlikely((__pyx_t_6 == (unsigned short)-1) && PyErr_Occurred())) __PYX_ERR(0, 273, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_options.udp_port = __pyx_t_6; + + /* "gevent/ares.pyx":274 + * if udp_port is not None: + * options.udp_port = int(udp_port) + * optmask |= cares.ARES_OPT_UDP_PORT # <<<<<<<<<<<<<< + * if tcp_port is not None: + * options.tcp_port = int(tcp_port) + */ + __pyx_v_optmask = (__pyx_v_optmask | ARES_OPT_UDP_PORT); + + /* "gevent/ares.pyx":272 + * options.ndots = int(ndots) + * optmask |= cares.ARES_OPT_NDOTS + * if udp_port is not None: # <<<<<<<<<<<<<< + * options.udp_port = int(udp_port) + * optmask |= cares.ARES_OPT_UDP_PORT + */ + } + + /* "gevent/ares.pyx":275 + * options.udp_port = int(udp_port) + * optmask |= cares.ARES_OPT_UDP_PORT + * if tcp_port is not None: # <<<<<<<<<<<<<< + * options.tcp_port = int(tcp_port) + * optmask |= cares.ARES_OPT_TCP_PORT + */ + __pyx_t_2 = (__pyx_v_tcp_port != Py_None); + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { + + /* "gevent/ares.pyx":276 + * optmask |= cares.ARES_OPT_UDP_PORT + * if tcp_port is not None: + * options.tcp_port = int(tcp_port) # <<<<<<<<<<<<<< + * optmask |= cares.ARES_OPT_TCP_PORT + * cdef int result = cares.ares_library_init(cares.ARES_LIB_INIT_ALL) # ARES_LIB_INIT_WIN32 -DUSE_WINSOCK? + */ + __pyx_t_3 = __Pyx_PyNumber_Int(__pyx_v_tcp_port); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 276, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = __Pyx_PyInt_As_unsigned_short(__pyx_t_3); if (unlikely((__pyx_t_6 == (unsigned short)-1) && PyErr_Occurred())) __PYX_ERR(0, 276, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_options.tcp_port = __pyx_t_6; + + /* "gevent/ares.pyx":277 + * if tcp_port is not None: + * options.tcp_port = int(tcp_port) + * optmask |= cares.ARES_OPT_TCP_PORT # <<<<<<<<<<<<<< + * cdef int result = cares.ares_library_init(cares.ARES_LIB_INIT_ALL) # ARES_LIB_INIT_WIN32 -DUSE_WINSOCK? + * if result: + */ + __pyx_v_optmask = (__pyx_v_optmask | ARES_OPT_TCP_PORT); + + /* "gevent/ares.pyx":275 + * options.udp_port = int(udp_port) + * optmask |= cares.ARES_OPT_UDP_PORT + * if tcp_port is not None: # <<<<<<<<<<<<<< + * options.tcp_port = int(tcp_port) + * optmask |= cares.ARES_OPT_TCP_PORT + */ + } + + /* "gevent/ares.pyx":278 + * options.tcp_port = int(tcp_port) + * optmask |= cares.ARES_OPT_TCP_PORT + * cdef int result = cares.ares_library_init(cares.ARES_LIB_INIT_ALL) # ARES_LIB_INIT_WIN32 -DUSE_WINSOCK? # <<<<<<<<<<<<<< + * if result: + * raise gaierror(result, strerror(result)) + */ + __pyx_v_result = ares_library_init(ARES_LIB_INIT_ALL); + + /* "gevent/ares.pyx":279 + * optmask |= cares.ARES_OPT_TCP_PORT + * cdef int result = cares.ares_library_init(cares.ARES_LIB_INIT_ALL) # ARES_LIB_INIT_WIN32 -DUSE_WINSOCK? + * if result: # <<<<<<<<<<<<<< + * raise gaierror(result, strerror(result)) + * result = cares.ares_init_options(&channel, &options, optmask) + */ + __pyx_t_1 = (__pyx_v_result != 0); + if (__pyx_t_1) { + + /* "gevent/ares.pyx":280 + * cdef int result = cares.ares_library_init(cares.ARES_LIB_INIT_ALL) # ARES_LIB_INIT_WIN32 -DUSE_WINSOCK? + * if result: + * raise gaierror(result, strerror(result)) # <<<<<<<<<<<<<< + * result = cares.ares_init_options(&channel, &options, optmask) + * if result: + */ + __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_gaierror); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 280, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = __Pyx_PyInt_From_int(__pyx_v_result); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 280, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = __Pyx_PyInt_From_int(__pyx_v_result); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 280, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = __pyx_f_6gevent_4ares_strerror(__pyx_t_9, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 280, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = NULL; + __pyx_t_4 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + __pyx_t_4 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_7)) { + PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_t_8, __pyx_t_10}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 280, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) { + PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_t_8, __pyx_t_10}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 280, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + } else + #endif + { + __pyx_t_11 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 280, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + if (__pyx_t_9) { + __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_9); __pyx_t_9 = NULL; + } + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_11, 0+__pyx_t_4, __pyx_t_8); + __Pyx_GIVEREF(__pyx_t_10); + PyTuple_SET_ITEM(__pyx_t_11, 1+__pyx_t_4, __pyx_t_10); + __pyx_t_8 = 0; + __pyx_t_10 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_11, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 280, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + } + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 280, __pyx_L1_error) + + /* "gevent/ares.pyx":279 + * optmask |= cares.ARES_OPT_TCP_PORT + * cdef int result = cares.ares_library_init(cares.ARES_LIB_INIT_ALL) # ARES_LIB_INIT_WIN32 -DUSE_WINSOCK? + * if result: # <<<<<<<<<<<<<< + * raise gaierror(result, strerror(result)) + * result = cares.ares_init_options(&channel, &options, optmask) + */ + } + + /* "gevent/ares.pyx":281 + * if result: + * raise gaierror(result, strerror(result)) + * result = cares.ares_init_options(&channel, &options, optmask) # <<<<<<<<<<<<<< + * if result: + * raise gaierror(result, strerror(result)) + */ + __pyx_v_result = ares_init_options((&__pyx_v_channel), (&__pyx_v_options), __pyx_v_optmask); + + /* "gevent/ares.pyx":282 + * raise gaierror(result, strerror(result)) + * result = cares.ares_init_options(&channel, &options, optmask) + * if result: # <<<<<<<<<<<<<< + * raise gaierror(result, strerror(result)) + * self._timer = loop.timer(TIMEOUT, TIMEOUT) + */ + __pyx_t_1 = (__pyx_v_result != 0); + if (__pyx_t_1) { + + /* "gevent/ares.pyx":283 + * result = cares.ares_init_options(&channel, &options, optmask) + * if result: + * raise gaierror(result, strerror(result)) # <<<<<<<<<<<<<< + * self._timer = loop.timer(TIMEOUT, TIMEOUT) + * self._watchers = {} + */ + __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_gaierror); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 283, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_11 = __Pyx_PyInt_From_int(__pyx_v_result); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 283, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_10 = __Pyx_PyInt_From_int(__pyx_v_result); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 283, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_8 = __pyx_f_6gevent_4ares_strerror(__pyx_t_10, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 283, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_10 = NULL; + __pyx_t_4 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_10)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_10); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + __pyx_t_4 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_7)) { + PyObject *__pyx_temp[3] = {__pyx_t_10, __pyx_t_11, __pyx_t_8}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 283, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) { + PyObject *__pyx_temp[3] = {__pyx_t_10, __pyx_t_11, __pyx_t_8}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 283, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } else + #endif + { + __pyx_t_9 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 283, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if (__pyx_t_10) { + __Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_10); __pyx_t_10 = NULL; + } + __Pyx_GIVEREF(__pyx_t_11); + PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_4, __pyx_t_11); + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_4, __pyx_t_8); + __pyx_t_11 = 0; + __pyx_t_8 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_9, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 283, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 283, __pyx_L1_error) + + /* "gevent/ares.pyx":282 + * raise gaierror(result, strerror(result)) + * result = cares.ares_init_options(&channel, &options, optmask) + * if result: # <<<<<<<<<<<<<< + * raise gaierror(result, strerror(result)) + * self._timer = loop.timer(TIMEOUT, TIMEOUT) + */ + } + + /* "gevent/ares.pyx":284 + * if result: + * raise gaierror(result, strerror(result)) + * self._timer = loop.timer(TIMEOUT, TIMEOUT) # <<<<<<<<<<<<<< + * self._watchers = {} + * self.channel = channel + */ + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_loop, __pyx_n_s_timer); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 284, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_TIMEOUT); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 284, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_TIMEOUT); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 284, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_11 = NULL; + __pyx_t_4 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_11)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_11); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + __pyx_t_4 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_7)) { + PyObject *__pyx_temp[3] = {__pyx_t_11, __pyx_t_9, __pyx_t_8}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 284, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) { + PyObject *__pyx_temp[3] = {__pyx_t_11, __pyx_t_9, __pyx_t_8}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 284, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } else + #endif + { + __pyx_t_10 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 284, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + if (__pyx_t_11) { + __Pyx_GIVEREF(__pyx_t_11); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_11); __pyx_t_11 = NULL; + } + __Pyx_GIVEREF(__pyx_t_9); + PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_4, __pyx_t_9); + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_4, __pyx_t_8); + __pyx_t_9 = 0; + __pyx_t_8 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_10, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 284, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + } + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_v_self->_timer); + __Pyx_DECREF(__pyx_v_self->_timer); + __pyx_v_self->_timer = __pyx_t_3; + __pyx_t_3 = 0; + + /* "gevent/ares.pyx":285 + * raise gaierror(result, strerror(result)) + * self._timer = loop.timer(TIMEOUT, TIMEOUT) + * self._watchers = {} # <<<<<<<<<<<<<< + * self.channel = channel + * try: + */ + __pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 285, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_v_self->_watchers); + __Pyx_DECREF(__pyx_v_self->_watchers); + __pyx_v_self->_watchers = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "gevent/ares.pyx":286 + * self._timer = loop.timer(TIMEOUT, TIMEOUT) + * self._watchers = {} + * self.channel = channel # <<<<<<<<<<<<<< + * try: + * if servers is not None: + */ + __pyx_v_self->channel = __pyx_v_channel; + + /* "gevent/ares.pyx":287 + * self._watchers = {} + * self.channel = channel + * try: # <<<<<<<<<<<<<< + * if servers is not None: + * self.set_servers(servers) + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14); + __Pyx_XGOTREF(__pyx_t_12); + __Pyx_XGOTREF(__pyx_t_13); + __Pyx_XGOTREF(__pyx_t_14); + /*try:*/ { + + /* "gevent/ares.pyx":288 + * self.channel = channel + * try: + * if servers is not None: # <<<<<<<<<<<<<< + * self.set_servers(servers) + * self.loop = loop + */ + __pyx_t_1 = (__pyx_v_servers != Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "gevent/ares.pyx":289 + * try: + * if servers is not None: + * self.set_servers(servers) # <<<<<<<<<<<<<< + * self.loop = loop + * except: + */ + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_set_servers); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 289, __pyx_L11_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_10 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_10)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_10); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + } + } + if (!__pyx_t_10) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_servers); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 289, __pyx_L11_error) + __Pyx_GOTREF(__pyx_t_3); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_7)) { + PyObject *__pyx_temp[2] = {__pyx_t_10, __pyx_v_servers}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 289, __pyx_L11_error) + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) { + PyObject *__pyx_temp[2] = {__pyx_t_10, __pyx_v_servers}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 289, __pyx_L11_error) + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else + #endif + { + __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 289, __pyx_L11_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_10); __pyx_t_10 = NULL; + __Pyx_INCREF(__pyx_v_servers); + __Pyx_GIVEREF(__pyx_v_servers); + PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_v_servers); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 289, __pyx_L11_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + } + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "gevent/ares.pyx":288 + * self.channel = channel + * try: + * if servers is not None: # <<<<<<<<<<<<<< + * self.set_servers(servers) + * self.loop = loop + */ + } + + /* "gevent/ares.pyx":290 + * if servers is not None: + * self.set_servers(servers) + * self.loop = loop # <<<<<<<<<<<<<< + * except: + * self.destroy() + */ + __Pyx_INCREF(__pyx_v_loop); + __Pyx_GIVEREF(__pyx_v_loop); + __Pyx_GOTREF(__pyx_v_self->loop); + __Pyx_DECREF(__pyx_v_self->loop); + __pyx_v_self->loop = __pyx_v_loop; + + /* "gevent/ares.pyx":287 + * self._watchers = {} + * self.channel = channel + * try: # <<<<<<<<<<<<<< + * if servers is not None: + * self.set_servers(servers) + */ + } + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; + goto __pyx_L18_try_end; + __pyx_L11_error:; + __Pyx_PyThreadState_assign + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "gevent/ares.pyx":291 + * self.set_servers(servers) + * self.loop = loop + * except: # <<<<<<<<<<<<<< + * self.destroy() + * raise + */ + /*except:*/ { + __Pyx_AddTraceback("gevent.ares.channel.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_7, &__pyx_t_8) < 0) __PYX_ERR(0, 291, __pyx_L13_except_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GOTREF(__pyx_t_8); + + /* "gevent/ares.pyx":292 + * self.loop = loop + * except: + * self.destroy() # <<<<<<<<<<<<<< + * raise + * + */ + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_destroy); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 292, __pyx_L13_except_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_11 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_9))) { + __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_9); + if (likely(__pyx_t_11)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); + __Pyx_INCREF(__pyx_t_11); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_9, function); + } + } + if (__pyx_t_11) { + __pyx_t_10 = __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_t_11); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 292, __pyx_L13_except_error) + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + } else { + __pyx_t_10 = __Pyx_PyObject_CallNoArg(__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 292, __pyx_L13_except_error) + } + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + + /* "gevent/ares.pyx":293 + * except: + * self.destroy() + * raise # <<<<<<<<<<<<<< + * + * def __repr__(self): + */ + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_ErrRestoreWithState(__pyx_t_3, __pyx_t_7, __pyx_t_8); + __pyx_t_3 = 0; __pyx_t_7 = 0; __pyx_t_8 = 0; + __PYX_ERR(0, 293, __pyx_L13_except_error) + } + __pyx_L13_except_error:; + + /* "gevent/ares.pyx":287 + * self._watchers = {} + * self.channel = channel + * try: # <<<<<<<<<<<<<< + * if servers is not None: + * self.set_servers(servers) + */ + __Pyx_PyThreadState_assign + __Pyx_XGIVEREF(__pyx_t_12); + __Pyx_XGIVEREF(__pyx_t_13); + __Pyx_XGIVEREF(__pyx_t_14); + __Pyx_ExceptionReset(__pyx_t_12, __pyx_t_13, __pyx_t_14); + goto __pyx_L1_error; + __pyx_L18_try_end:; + } + + /* "gevent/ares.pyx":252 + * cdef public object _timer + * + * def __init__(self, object loop, flags=None, timeout=None, tries=None, ndots=None, # <<<<<<<<<<<<<< + * udp_port=None, tcp_port=None, servers=None): + * cdef ares_channeldata* channel = NULL + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_AddTraceback("gevent.ares.channel.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "gevent/ares.pyx":295 + * raise + * + * def __repr__(self): # <<<<<<<<<<<<<< + * args = (self.__class__.__name__, id(self), self._timer, len(self._watchers)) + * return '<%s at 0x%x _timer=%r _watchers[%s]>' % args + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_4ares_7channel_3__repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_4ares_7channel_3__repr__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_4ares_7channel_2__repr__(((struct PyGeventAresChannelObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_4ares_7channel_2__repr__(struct PyGeventAresChannelObject *__pyx_v_self) { + PyObject *__pyx_v_args = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + Py_ssize_t __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + __Pyx_RefNannySetupContext("__repr__", 0); + + /* "gevent/ares.pyx":296 + * + * def __repr__(self): + * args = (self.__class__.__name__, id(self), self._timer, len(self._watchers)) # <<<<<<<<<<<<<< + * return '<%s at 0x%x _timer=%r _watchers[%s]>' % args + * + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 296, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 296, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 296, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_self)); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_id, __pyx_t_1, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 296, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __pyx_v_self->_watchers; + __Pyx_INCREF(__pyx_t_1); + if (unlikely(__pyx_t_1 == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(0, 296, __pyx_L1_error) + } + __pyx_t_4 = PyDict_Size(__pyx_t_1); if (unlikely(__pyx_t_4 == -1)) __PYX_ERR(0, 296, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyInt_FromSsize_t(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 296, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = PyTuple_New(4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 296, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_3); + __Pyx_INCREF(__pyx_v_self->_timer); + __Pyx_GIVEREF(__pyx_v_self->_timer); + PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_self->_timer); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_1); + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_t_1 = 0; + __pyx_v_args = ((PyObject*)__pyx_t_5); + __pyx_t_5 = 0; + + /* "gevent/ares.pyx":297 + * def __repr__(self): + * args = (self.__class__.__name__, id(self), self._timer, len(self._watchers)) + * return '<%s at 0x%x _timer=%r _watchers[%s]>' % args # <<<<<<<<<<<<<< + * + * def destroy(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_s_at_0x_x__timer_r__watchers_s, __pyx_v_args); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 297, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "gevent/ares.pyx":295 + * raise + * + * def __repr__(self): # <<<<<<<<<<<<<< + * args = (self.__class__.__name__, id(self), self._timer, len(self._watchers)) + * return '<%s at 0x%x _timer=%r _watchers[%s]>' % args + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("gevent.ares.channel.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_args); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "gevent/ares.pyx":299 + * return '<%s at 0x%x _timer=%r _watchers[%s]>' % args + * + * def destroy(self): # <<<<<<<<<<<<<< + * if self.channel: + * # XXX ares_library_cleanup? + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_4ares_7channel_5destroy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_6gevent_4ares_7channel_5destroy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("destroy (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_4ares_7channel_4destroy(((struct PyGeventAresChannelObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_4ares_7channel_4destroy(struct PyGeventAresChannelObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + __Pyx_RefNannySetupContext("destroy", 0); + + /* "gevent/ares.pyx":300 + * + * def destroy(self): + * if self.channel: # <<<<<<<<<<<<<< + * # XXX ares_library_cleanup? + * cares.ares_destroy(self.channel) + */ + __pyx_t_1 = (__pyx_v_self->channel != 0); + if (__pyx_t_1) { + + /* "gevent/ares.pyx":302 + * if self.channel: + * # XXX ares_library_cleanup? + * cares.ares_destroy(self.channel) # <<<<<<<<<<<<<< + * self.channel = NULL + * self._watchers.clear() + */ + ares_destroy(__pyx_v_self->channel); + + /* "gevent/ares.pyx":303 + * # XXX ares_library_cleanup? + * cares.ares_destroy(self.channel) + * self.channel = NULL # <<<<<<<<<<<<<< + * self._watchers.clear() + * self._timer.stop() + */ + __pyx_v_self->channel = NULL; + + /* "gevent/ares.pyx":304 + * cares.ares_destroy(self.channel) + * self.channel = NULL + * self._watchers.clear() # <<<<<<<<<<<<<< + * self._timer.stop() + * self.loop = None + */ + if (unlikely(__pyx_v_self->_watchers == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "clear"); + __PYX_ERR(0, 304, __pyx_L1_error) + } + __pyx_t_2 = __Pyx_PyDict_Clear(__pyx_v_self->_watchers); if (unlikely(__pyx_t_2 == -1)) __PYX_ERR(0, 304, __pyx_L1_error) + + /* "gevent/ares.pyx":305 + * self.channel = NULL + * self._watchers.clear() + * self._timer.stop() # <<<<<<<<<<<<<< + * self.loop = None + * + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_timer, __pyx_n_s_stop); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 305, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (__pyx_t_5) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 305, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else { + __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 305, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "gevent/ares.pyx":306 + * self._watchers.clear() + * self._timer.stop() + * self.loop = None # <<<<<<<<<<<<<< + * + * def __dealloc__(self): + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->loop); + __Pyx_DECREF(__pyx_v_self->loop); + __pyx_v_self->loop = Py_None; + + /* "gevent/ares.pyx":300 + * + * def destroy(self): + * if self.channel: # <<<<<<<<<<<<<< + * # XXX ares_library_cleanup? + * cares.ares_destroy(self.channel) + */ + } + + /* "gevent/ares.pyx":299 + * return '<%s at 0x%x _timer=%r _watchers[%s]>' % args + * + * def destroy(self): # <<<<<<<<<<<<<< + * if self.channel: + * # XXX ares_library_cleanup? + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("gevent.ares.channel.destroy", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "gevent/ares.pyx":308 + * self.loop = None + * + * def __dealloc__(self): # <<<<<<<<<<<<<< + * if self.channel: + * # XXX ares_library_cleanup? + */ + +/* Python wrapper */ +static void __pyx_pw_6gevent_4ares_7channel_7__dealloc__(PyObject *__pyx_v_self); /*proto*/ +static void __pyx_pw_6gevent_4ares_7channel_7__dealloc__(PyObject *__pyx_v_self) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_pf_6gevent_4ares_7channel_6__dealloc__(((struct PyGeventAresChannelObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +static void __pyx_pf_6gevent_4ares_7channel_6__dealloc__(struct PyGeventAresChannelObject *__pyx_v_self) { + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("__dealloc__", 0); + + /* "gevent/ares.pyx":309 + * + * def __dealloc__(self): + * if self.channel: # <<<<<<<<<<<<<< + * # XXX ares_library_cleanup? + * cares.ares_destroy(self.channel) + */ + __pyx_t_1 = (__pyx_v_self->channel != 0); + if (__pyx_t_1) { + + /* "gevent/ares.pyx":311 + * if self.channel: + * # XXX ares_library_cleanup? + * cares.ares_destroy(self.channel) # <<<<<<<<<<<<<< + * self.channel = NULL + * + */ + ares_destroy(__pyx_v_self->channel); + + /* "gevent/ares.pyx":312 + * # XXX ares_library_cleanup? + * cares.ares_destroy(self.channel) + * self.channel = NULL # <<<<<<<<<<<<<< + * + * def set_servers(self, servers=None): + */ + __pyx_v_self->channel = NULL; + + /* "gevent/ares.pyx":309 + * + * def __dealloc__(self): + * if self.channel: # <<<<<<<<<<<<<< + * # XXX ares_library_cleanup? + * cares.ares_destroy(self.channel) + */ + } + + /* "gevent/ares.pyx":308 + * self.loop = None + * + * def __dealloc__(self): # <<<<<<<<<<<<<< + * if self.channel: + * # XXX ares_library_cleanup? + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "gevent/ares.pyx":314 + * self.channel = NULL + * + * def set_servers(self, servers=None): # <<<<<<<<<<<<<< + * if not self.channel: + * raise gaierror(cares.ARES_EDESTRUCTION, 'this ares channel has been destroyed') + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_4ares_7channel_9set_servers(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6gevent_4ares_7channel_9set_servers(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_servers = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("set_servers (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_servers,0}; + PyObject* values[1] = {0}; + values[0] = ((PyObject *)Py_None); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_servers); + if (value) { values[0] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "set_servers") < 0)) __PYX_ERR(0, 314, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_servers = values[0]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("set_servers", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 314, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.ares.channel.set_servers", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_4ares_7channel_8set_servers(((struct PyGeventAresChannelObject *)__pyx_v_self), __pyx_v_servers); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_4ares_7channel_8set_servers(struct PyGeventAresChannelObject *__pyx_v_self, PyObject *__pyx_v_servers) { + int __pyx_v_length; + CYTHON_UNUSED int __pyx_v_result; + int __pyx_v_index; + char *__pyx_v_string; + struct ares_addr_node *__pyx_v_c_servers; + PyObject *__pyx_v_server = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + Py_ssize_t __pyx_t_9; + PyObject *(*__pyx_t_10)(PyObject *); + char *__pyx_t_11; + PyObject *__pyx_t_12 = NULL; + int __pyx_t_13; + char const *__pyx_t_14; + PyObject *__pyx_t_15 = NULL; + PyObject *__pyx_t_16 = NULL; + PyObject *__pyx_t_17 = NULL; + PyObject *__pyx_t_18 = NULL; + PyObject *__pyx_t_19 = NULL; + PyObject *__pyx_t_20 = NULL; + __Pyx_RefNannySetupContext("set_servers", 0); + __Pyx_INCREF(__pyx_v_servers); + + /* "gevent/ares.pyx":315 + * + * def set_servers(self, servers=None): + * if not self.channel: # <<<<<<<<<<<<<< + * raise gaierror(cares.ARES_EDESTRUCTION, 'this ares channel has been destroyed') + * if not servers: + */ + __pyx_t_1 = ((!(__pyx_v_self->channel != 0)) != 0); + if (__pyx_t_1) { + + /* "gevent/ares.pyx":316 + * def set_servers(self, servers=None): + * if not self.channel: + * raise gaierror(cares.ARES_EDESTRUCTION, 'this ares channel has been destroyed') # <<<<<<<<<<<<<< + * if not servers: + * servers = [] + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_gaierror); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 316, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_From_int(ARES_EDESTRUCTION); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 316, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_6 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_4, __pyx_kp_s_this_ares_channel_has_been_destr}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 316, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_4, __pyx_kp_s_this_ares_channel_has_been_destr}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 316, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + { + __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 316, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__pyx_t_5) { + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL; + } + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_t_4); + __Pyx_INCREF(__pyx_kp_s_this_ares_channel_has_been_destr); + __Pyx_GIVEREF(__pyx_kp_s_this_ares_channel_has_been_destr); + PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_kp_s_this_ares_channel_has_been_destr); + __pyx_t_4 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 316, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 316, __pyx_L1_error) + + /* "gevent/ares.pyx":315 + * + * def set_servers(self, servers=None): + * if not self.channel: # <<<<<<<<<<<<<< + * raise gaierror(cares.ARES_EDESTRUCTION, 'this ares channel has been destroyed') + * if not servers: + */ + } + + /* "gevent/ares.pyx":317 + * if not self.channel: + * raise gaierror(cares.ARES_EDESTRUCTION, 'this ares channel has been destroyed') + * if not servers: # <<<<<<<<<<<<<< + * servers = [] + * if isinstance(servers, string_types): + */ + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_servers); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 317, __pyx_L1_error) + __pyx_t_8 = ((!__pyx_t_1) != 0); + if (__pyx_t_8) { + + /* "gevent/ares.pyx":318 + * raise gaierror(cares.ARES_EDESTRUCTION, 'this ares channel has been destroyed') + * if not servers: + * servers = [] # <<<<<<<<<<<<<< + * if isinstance(servers, string_types): + * servers = servers.split(',') + */ + __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 318, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF_SET(__pyx_v_servers, __pyx_t_2); + __pyx_t_2 = 0; + + /* "gevent/ares.pyx":317 + * if not self.channel: + * raise gaierror(cares.ARES_EDESTRUCTION, 'this ares channel has been destroyed') + * if not servers: # <<<<<<<<<<<<<< + * servers = [] + * if isinstance(servers, string_types): + */ + } + + /* "gevent/ares.pyx":319 + * if not servers: + * servers = [] + * if isinstance(servers, string_types): # <<<<<<<<<<<<<< + * servers = servers.split(',') + * cdef int length = len(servers) + */ + __pyx_t_2 = __pyx_v_6gevent_4ares_string_types; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_8 = PyObject_IsInstance(__pyx_v_servers, __pyx_t_2); if (unlikely(__pyx_t_8 == -1)) __PYX_ERR(0, 319, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_1 = (__pyx_t_8 != 0); + if (__pyx_t_1) { + + /* "gevent/ares.pyx":320 + * servers = [] + * if isinstance(servers, string_types): + * servers = servers.split(',') # <<<<<<<<<<<<<< + * cdef int length = len(servers) + * cdef int result, index + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_servers, __pyx_n_s_split); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 320, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 320, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF_SET(__pyx_v_servers, __pyx_t_3); + __pyx_t_3 = 0; + + /* "gevent/ares.pyx":319 + * if not servers: + * servers = [] + * if isinstance(servers, string_types): # <<<<<<<<<<<<<< + * servers = servers.split(',') + * cdef int length = len(servers) + */ + } + + /* "gevent/ares.pyx":321 + * if isinstance(servers, string_types): + * servers = servers.split(',') + * cdef int length = len(servers) # <<<<<<<<<<<<<< + * cdef int result, index + * cdef char* string + */ + __pyx_t_9 = PyObject_Length(__pyx_v_servers); if (unlikely(__pyx_t_9 == -1)) __PYX_ERR(0, 321, __pyx_L1_error) + __pyx_v_length = __pyx_t_9; + + /* "gevent/ares.pyx":325 + * cdef char* string + * cdef cares.ares_addr_node* c_servers + * if length <= 0: # <<<<<<<<<<<<<< + * result = cares.ares_set_servers(self.channel, NULL) + * else: + */ + __pyx_t_1 = ((__pyx_v_length <= 0) != 0); + if (__pyx_t_1) { + + /* "gevent/ares.pyx":326 + * cdef cares.ares_addr_node* c_servers + * if length <= 0: + * result = cares.ares_set_servers(self.channel, NULL) # <<<<<<<<<<<<<< + * else: + * c_servers = malloc(sizeof(cares.ares_addr_node) * length) + */ + __pyx_v_result = ares_set_servers(__pyx_v_self->channel, NULL); + + /* "gevent/ares.pyx":325 + * cdef char* string + * cdef cares.ares_addr_node* c_servers + * if length <= 0: # <<<<<<<<<<<<<< + * result = cares.ares_set_servers(self.channel, NULL) + * else: + */ + goto __pyx_L6; + } + + /* "gevent/ares.pyx":328 + * result = cares.ares_set_servers(self.channel, NULL) + * else: + * c_servers = malloc(sizeof(cares.ares_addr_node) * length) # <<<<<<<<<<<<<< + * if not c_servers: + * raise MemoryError + */ + /*else*/ { + __pyx_v_c_servers = ((struct ares_addr_node *)malloc(((sizeof(struct ares_addr_node)) * __pyx_v_length))); + + /* "gevent/ares.pyx":329 + * else: + * c_servers = malloc(sizeof(cares.ares_addr_node) * length) + * if not c_servers: # <<<<<<<<<<<<<< + * raise MemoryError + * try: + */ + __pyx_t_1 = ((!(__pyx_v_c_servers != 0)) != 0); + if (__pyx_t_1) { + + /* "gevent/ares.pyx":330 + * c_servers = malloc(sizeof(cares.ares_addr_node) * length) + * if not c_servers: + * raise MemoryError # <<<<<<<<<<<<<< + * try: + * index = 0 + */ + PyErr_NoMemory(); __PYX_ERR(0, 330, __pyx_L1_error) + + /* "gevent/ares.pyx":329 + * else: + * c_servers = malloc(sizeof(cares.ares_addr_node) * length) + * if not c_servers: # <<<<<<<<<<<<<< + * raise MemoryError + * try: + */ + } + + /* "gevent/ares.pyx":331 + * if not c_servers: + * raise MemoryError + * try: # <<<<<<<<<<<<<< + * index = 0 + * for server in servers: + */ + /*try:*/ { + + /* "gevent/ares.pyx":332 + * raise MemoryError + * try: + * index = 0 # <<<<<<<<<<<<<< + * for server in servers: + * if isinstance(server, unicode): + */ + __pyx_v_index = 0; + + /* "gevent/ares.pyx":333 + * try: + * index = 0 + * for server in servers: # <<<<<<<<<<<<<< + * if isinstance(server, unicode): + * server = server.encode('ascii') + */ + if (likely(PyList_CheckExact(__pyx_v_servers)) || PyTuple_CheckExact(__pyx_v_servers)) { + __pyx_t_3 = __pyx_v_servers; __Pyx_INCREF(__pyx_t_3); __pyx_t_9 = 0; + __pyx_t_10 = NULL; + } else { + __pyx_t_9 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_servers); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 333, __pyx_L9_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_10 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 333, __pyx_L9_error) + } + for (;;) { + if (likely(!__pyx_t_10)) { + if (likely(PyList_CheckExact(__pyx_t_3))) { + if (__pyx_t_9 >= PyList_GET_SIZE(__pyx_t_3)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_2 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_9); __Pyx_INCREF(__pyx_t_2); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 333, __pyx_L9_error) + #else + __pyx_t_2 = PySequence_ITEM(__pyx_t_3, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 333, __pyx_L9_error) + __Pyx_GOTREF(__pyx_t_2); + #endif + } else { + if (__pyx_t_9 >= PyTuple_GET_SIZE(__pyx_t_3)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_9); __Pyx_INCREF(__pyx_t_2); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 333, __pyx_L9_error) + #else + __pyx_t_2 = PySequence_ITEM(__pyx_t_3, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 333, __pyx_L9_error) + __Pyx_GOTREF(__pyx_t_2); + #endif + } + } else { + __pyx_t_2 = __pyx_t_10(__pyx_t_3); + if (unlikely(!__pyx_t_2)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 333, __pyx_L9_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_XDECREF_SET(__pyx_v_server, __pyx_t_2); + __pyx_t_2 = 0; + + /* "gevent/ares.pyx":334 + * index = 0 + * for server in servers: + * if isinstance(server, unicode): # <<<<<<<<<<<<<< + * server = server.encode('ascii') + * string = server + */ + __pyx_t_1 = PyUnicode_Check(__pyx_v_server); + __pyx_t_8 = (__pyx_t_1 != 0); + if (__pyx_t_8) { + + /* "gevent/ares.pyx":335 + * for server in servers: + * if isinstance(server, unicode): + * server = server.encode('ascii') # <<<<<<<<<<<<<< + * string = server + * if cares.ares_inet_pton(AF_INET, string, &c_servers[index].addr) > 0: + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_server, __pyx_n_s_encode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 335, __pyx_L9_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 335, __pyx_L9_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF_SET(__pyx_v_server, __pyx_t_7); + __pyx_t_7 = 0; + + /* "gevent/ares.pyx":334 + * index = 0 + * for server in servers: + * if isinstance(server, unicode): # <<<<<<<<<<<<<< + * server = server.encode('ascii') + * string = server + */ + } + + /* "gevent/ares.pyx":336 + * if isinstance(server, unicode): + * server = server.encode('ascii') + * string = server # <<<<<<<<<<<<<< + * if cares.ares_inet_pton(AF_INET, string, &c_servers[index].addr) > 0: + * c_servers[index].family = AF_INET + */ + __pyx_t_11 = __Pyx_PyObject_AsString(__pyx_v_server); if (unlikely((!__pyx_t_11) && PyErr_Occurred())) __PYX_ERR(0, 336, __pyx_L9_error) + __pyx_v_string = ((char *)__pyx_t_11); + + /* "gevent/ares.pyx":337 + * server = server.encode('ascii') + * string = server + * if cares.ares_inet_pton(AF_INET, string, &c_servers[index].addr) > 0: # <<<<<<<<<<<<<< + * c_servers[index].family = AF_INET + * elif cares.ares_inet_pton(AF_INET6, string, &c_servers[index].addr) > 0: + */ + __pyx_t_8 = ((ares_inet_pton(AF_INET, __pyx_v_string, (&(__pyx_v_c_servers[__pyx_v_index]).addr)) > 0) != 0); + if (__pyx_t_8) { + + /* "gevent/ares.pyx":338 + * string = server + * if cares.ares_inet_pton(AF_INET, string, &c_servers[index].addr) > 0: + * c_servers[index].family = AF_INET # <<<<<<<<<<<<<< + * elif cares.ares_inet_pton(AF_INET6, string, &c_servers[index].addr) > 0: + * c_servers[index].family = AF_INET6 + */ + (__pyx_v_c_servers[__pyx_v_index]).family = AF_INET; + + /* "gevent/ares.pyx":337 + * server = server.encode('ascii') + * string = server + * if cares.ares_inet_pton(AF_INET, string, &c_servers[index].addr) > 0: # <<<<<<<<<<<<<< + * c_servers[index].family = AF_INET + * elif cares.ares_inet_pton(AF_INET6, string, &c_servers[index].addr) > 0: + */ + goto __pyx_L14; + } + + /* "gevent/ares.pyx":339 + * if cares.ares_inet_pton(AF_INET, string, &c_servers[index].addr) > 0: + * c_servers[index].family = AF_INET + * elif cares.ares_inet_pton(AF_INET6, string, &c_servers[index].addr) > 0: # <<<<<<<<<<<<<< + * c_servers[index].family = AF_INET6 + * else: + */ + __pyx_t_8 = ((ares_inet_pton(AF_INET6, __pyx_v_string, (&(__pyx_v_c_servers[__pyx_v_index]).addr)) > 0) != 0); + if (__pyx_t_8) { + + /* "gevent/ares.pyx":340 + * c_servers[index].family = AF_INET + * elif cares.ares_inet_pton(AF_INET6, string, &c_servers[index].addr) > 0: + * c_servers[index].family = AF_INET6 # <<<<<<<<<<<<<< + * else: + * raise InvalidIP(repr(string)) + */ + (__pyx_v_c_servers[__pyx_v_index]).family = AF_INET6; + + /* "gevent/ares.pyx":339 + * if cares.ares_inet_pton(AF_INET, string, &c_servers[index].addr) > 0: + * c_servers[index].family = AF_INET + * elif cares.ares_inet_pton(AF_INET6, string, &c_servers[index].addr) > 0: # <<<<<<<<<<<<<< + * c_servers[index].family = AF_INET6 + * else: + */ + goto __pyx_L14; + } + + /* "gevent/ares.pyx":342 + * c_servers[index].family = AF_INET6 + * else: + * raise InvalidIP(repr(string)) # <<<<<<<<<<<<<< + * c_servers[index].next = &c_servers[index] + 1 + * index += 1 + */ + /*else*/ { + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_InvalidIP); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 342, __pyx_L9_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyBytes_FromString(__pyx_v_string); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 342, __pyx_L9_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyObject_Repr(__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 342, __pyx_L9_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (!__pyx_t_4) { + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_5); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 342, __pyx_L9_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_7); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_5}; + __pyx_t_7 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 342, __pyx_L9_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_5}; + __pyx_t_7 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 342, __pyx_L9_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + { + __pyx_t_12 = PyTuple_New(1+1); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 342, __pyx_L9_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_12, 0+1, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_12, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 342, __pyx_L9_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_7, 0, 0, 0); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __PYX_ERR(0, 342, __pyx_L9_error) + } + __pyx_L14:; + + /* "gevent/ares.pyx":343 + * else: + * raise InvalidIP(repr(string)) + * c_servers[index].next = &c_servers[index] + 1 # <<<<<<<<<<<<<< + * index += 1 + * if index >= length: + */ + (__pyx_v_c_servers[__pyx_v_index]).next = ((&(__pyx_v_c_servers[__pyx_v_index])) + 1); + + /* "gevent/ares.pyx":344 + * raise InvalidIP(repr(string)) + * c_servers[index].next = &c_servers[index] + 1 + * index += 1 # <<<<<<<<<<<<<< + * if index >= length: + * break + */ + __pyx_v_index = (__pyx_v_index + 1); + + /* "gevent/ares.pyx":345 + * c_servers[index].next = &c_servers[index] + 1 + * index += 1 + * if index >= length: # <<<<<<<<<<<<<< + * break + * c_servers[length - 1].next = NULL + */ + __pyx_t_8 = ((__pyx_v_index >= __pyx_v_length) != 0); + if (__pyx_t_8) { + + /* "gevent/ares.pyx":346 + * index += 1 + * if index >= length: + * break # <<<<<<<<<<<<<< + * c_servers[length - 1].next = NULL + * index = cares.ares_set_servers(self.channel, c_servers) + */ + goto __pyx_L12_break; + + /* "gevent/ares.pyx":345 + * c_servers[index].next = &c_servers[index] + 1 + * index += 1 + * if index >= length: # <<<<<<<<<<<<<< + * break + * c_servers[length - 1].next = NULL + */ + } + + /* "gevent/ares.pyx":333 + * try: + * index = 0 + * for server in servers: # <<<<<<<<<<<<<< + * if isinstance(server, unicode): + * server = server.encode('ascii') + */ + } + __pyx_L12_break:; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "gevent/ares.pyx":347 + * if index >= length: + * break + * c_servers[length - 1].next = NULL # <<<<<<<<<<<<<< + * index = cares.ares_set_servers(self.channel, c_servers) + * if index: + */ + (__pyx_v_c_servers[(__pyx_v_length - 1)]).next = NULL; + + /* "gevent/ares.pyx":348 + * break + * c_servers[length - 1].next = NULL + * index = cares.ares_set_servers(self.channel, c_servers) # <<<<<<<<<<<<<< + * if index: + * raise ValueError(strerror(index)) + */ + __pyx_v_index = ares_set_servers(__pyx_v_self->channel, __pyx_v_c_servers); + + /* "gevent/ares.pyx":349 + * c_servers[length - 1].next = NULL + * index = cares.ares_set_servers(self.channel, c_servers) + * if index: # <<<<<<<<<<<<<< + * raise ValueError(strerror(index)) + * finally: + */ + __pyx_t_8 = (__pyx_v_index != 0); + if (__pyx_t_8) { + + /* "gevent/ares.pyx":350 + * index = cares.ares_set_servers(self.channel, c_servers) + * if index: + * raise ValueError(strerror(index)) # <<<<<<<<<<<<<< + * finally: + * free(c_servers) + */ + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_index); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 350, __pyx_L9_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = __pyx_f_6gevent_4ares_strerror(__pyx_t_3, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 350, __pyx_L9_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 350, __pyx_L9_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_7); + __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 350, __pyx_L9_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_7, 0, 0, 0); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __PYX_ERR(0, 350, __pyx_L9_error) + + /* "gevent/ares.pyx":349 + * c_servers[length - 1].next = NULL + * index = cares.ares_set_servers(self.channel, c_servers) + * if index: # <<<<<<<<<<<<<< + * raise ValueError(strerror(index)) + * finally: + */ + } + } + + /* "gevent/ares.pyx":352 + * raise ValueError(strerror(index)) + * finally: + * free(c_servers) # <<<<<<<<<<<<<< + * + * # this crashes c-ares + */ + /*finally:*/ { + /*normal exit:*/{ + free(__pyx_v_c_servers); + goto __pyx_L10; + } + /*exception exit:*/{ + __Pyx_PyThreadState_declare + __pyx_L9_error:; + __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; + __Pyx_PyThreadState_assign + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_18, &__pyx_t_19, &__pyx_t_20); + if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17) < 0)) __Pyx_ErrFetch(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17); + __Pyx_XGOTREF(__pyx_t_15); + __Pyx_XGOTREF(__pyx_t_16); + __Pyx_XGOTREF(__pyx_t_17); + __Pyx_XGOTREF(__pyx_t_18); + __Pyx_XGOTREF(__pyx_t_19); + __Pyx_XGOTREF(__pyx_t_20); + __pyx_t_6 = __pyx_lineno; __pyx_t_13 = __pyx_clineno; __pyx_t_14 = __pyx_filename; + { + free(__pyx_v_c_servers); + } + __Pyx_PyThreadState_assign + if (PY_MAJOR_VERSION >= 3) { + __Pyx_XGIVEREF(__pyx_t_18); + __Pyx_XGIVEREF(__pyx_t_19); + __Pyx_XGIVEREF(__pyx_t_20); + __Pyx_ExceptionReset(__pyx_t_18, __pyx_t_19, __pyx_t_20); + } + __Pyx_XGIVEREF(__pyx_t_15); + __Pyx_XGIVEREF(__pyx_t_16); + __Pyx_XGIVEREF(__pyx_t_17); + __Pyx_ErrRestore(__pyx_t_15, __pyx_t_16, __pyx_t_17); + __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; + __pyx_lineno = __pyx_t_6; __pyx_clineno = __pyx_t_13; __pyx_filename = __pyx_t_14; + goto __pyx_L1_error; + } + __pyx_L10:; + } + } + __pyx_L6:; + + /* "gevent/ares.pyx":314 + * self.channel = NULL + * + * def set_servers(self, servers=None): # <<<<<<<<<<<<<< + * if not self.channel: + * raise gaierror(cares.ARES_EDESTRUCTION, 'this ares channel has been destroyed') + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_AddTraceback("gevent.ares.channel.set_servers", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_server); + __Pyx_XDECREF(__pyx_v_servers); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "gevent/ares.pyx":358 + * # cares.ares_cancel(self.channel) + * + * cdef _sock_state_callback(self, int socket, int read, int write): # <<<<<<<<<<<<<< + * if not self.channel: + * return + */ + +static PyObject *__pyx_f_6gevent_4ares_7channel__sock_state_callback(struct PyGeventAresChannelObject *__pyx_v_self, int __pyx_v_socket, int __pyx_v_read, int __pyx_v_write) { + PyObject *__pyx_v_watcher = 0; + int __pyx_v_events; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + PyObject *__pyx_t_9 = NULL; + __Pyx_RefNannySetupContext("_sock_state_callback", 0); + + /* "gevent/ares.pyx":359 + * + * cdef _sock_state_callback(self, int socket, int read, int write): + * if not self.channel: # <<<<<<<<<<<<<< + * return + * cdef object watcher = self._watchers.get(socket) + */ + __pyx_t_1 = ((!(__pyx_v_self->channel != 0)) != 0); + if (__pyx_t_1) { + + /* "gevent/ares.pyx":360 + * cdef _sock_state_callback(self, int socket, int read, int write): + * if not self.channel: + * return # <<<<<<<<<<<<<< + * cdef object watcher = self._watchers.get(socket) + * cdef int events = 0 + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "gevent/ares.pyx":359 + * + * cdef _sock_state_callback(self, int socket, int read, int write): + * if not self.channel: # <<<<<<<<<<<<<< + * return + * cdef object watcher = self._watchers.get(socket) + */ + } + + /* "gevent/ares.pyx":361 + * if not self.channel: + * return + * cdef object watcher = self._watchers.get(socket) # <<<<<<<<<<<<<< + * cdef int events = 0 + * if read: + */ + if (unlikely(__pyx_v_self->_watchers == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "get"); + __PYX_ERR(0, 361, __pyx_L1_error) + } + __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_socket); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 361, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyDict_GetItemDefault(__pyx_v_self->_watchers, __pyx_t_2, Py_None); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 361, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_watcher = __pyx_t_3; + __pyx_t_3 = 0; + + /* "gevent/ares.pyx":362 + * return + * cdef object watcher = self._watchers.get(socket) + * cdef int events = 0 # <<<<<<<<<<<<<< + * if read: + * events |= EV_READ + */ + __pyx_v_events = 0; + + /* "gevent/ares.pyx":363 + * cdef object watcher = self._watchers.get(socket) + * cdef int events = 0 + * if read: # <<<<<<<<<<<<<< + * events |= EV_READ + * if write: + */ + __pyx_t_1 = (__pyx_v_read != 0); + if (__pyx_t_1) { + + /* "gevent/ares.pyx":364 + * cdef int events = 0 + * if read: + * events |= EV_READ # <<<<<<<<<<<<<< + * if write: + * events |= EV_WRITE + */ + __pyx_v_events = (__pyx_v_events | 1); + + /* "gevent/ares.pyx":363 + * cdef object watcher = self._watchers.get(socket) + * cdef int events = 0 + * if read: # <<<<<<<<<<<<<< + * events |= EV_READ + * if write: + */ + } + + /* "gevent/ares.pyx":365 + * if read: + * events |= EV_READ + * if write: # <<<<<<<<<<<<<< + * events |= EV_WRITE + * if watcher is None: + */ + __pyx_t_1 = (__pyx_v_write != 0); + if (__pyx_t_1) { + + /* "gevent/ares.pyx":366 + * events |= EV_READ + * if write: + * events |= EV_WRITE # <<<<<<<<<<<<<< + * if watcher is None: + * if not events: + */ + __pyx_v_events = (__pyx_v_events | 2); + + /* "gevent/ares.pyx":365 + * if read: + * events |= EV_READ + * if write: # <<<<<<<<<<<<<< + * events |= EV_WRITE + * if watcher is None: + */ + } + + /* "gevent/ares.pyx":367 + * if write: + * events |= EV_WRITE + * if watcher is None: # <<<<<<<<<<<<<< + * if not events: + * return + */ + __pyx_t_1 = (__pyx_v_watcher == Py_None); + __pyx_t_4 = (__pyx_t_1 != 0); + if (__pyx_t_4) { + + /* "gevent/ares.pyx":368 + * events |= EV_WRITE + * if watcher is None: + * if not events: # <<<<<<<<<<<<<< + * return + * watcher = self.loop.io(socket, events) + */ + __pyx_t_4 = ((!(__pyx_v_events != 0)) != 0); + if (__pyx_t_4) { + + /* "gevent/ares.pyx":369 + * if watcher is None: + * if not events: + * return # <<<<<<<<<<<<<< + * watcher = self.loop.io(socket, events) + * self._watchers[socket] = watcher + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "gevent/ares.pyx":368 + * events |= EV_WRITE + * if watcher is None: + * if not events: # <<<<<<<<<<<<<< + * return + * watcher = self.loop.io(socket, events) + */ + } + + /* "gevent/ares.pyx":370 + * if not events: + * return + * watcher = self.loop.io(socket, events) # <<<<<<<<<<<<<< + * self._watchers[socket] = watcher + * elif events: + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->loop, __pyx_n_s_io); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 370, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_socket); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 370, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_events); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 370, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_8 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_5, __pyx_t_6}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 370, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_5, __pyx_t_6}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 370, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + { + __pyx_t_9 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 370, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if (__pyx_t_7) { + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; + } + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_t_6); + __pyx_t_5 = 0; + __pyx_t_6 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_9, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 370, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF_SET(__pyx_v_watcher, __pyx_t_3); + __pyx_t_3 = 0; + + /* "gevent/ares.pyx":371 + * return + * watcher = self.loop.io(socket, events) + * self._watchers[socket] = watcher # <<<<<<<<<<<<<< + * elif events: + * if watcher.events == events: + */ + if (unlikely(__pyx_v_self->_watchers == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(0, 371, __pyx_L1_error) + } + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_socket); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 371, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (unlikely(PyDict_SetItem(__pyx_v_self->_watchers, __pyx_t_3, __pyx_v_watcher) < 0)) __PYX_ERR(0, 371, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "gevent/ares.pyx":367 + * if write: + * events |= EV_WRITE + * if watcher is None: # <<<<<<<<<<<<<< + * if not events: + * return + */ + goto __pyx_L6; + } + + /* "gevent/ares.pyx":372 + * watcher = self.loop.io(socket, events) + * self._watchers[socket] = watcher + * elif events: # <<<<<<<<<<<<<< + * if watcher.events == events: + * return + */ + __pyx_t_4 = (__pyx_v_events != 0); + if (__pyx_t_4) { + + /* "gevent/ares.pyx":373 + * self._watchers[socket] = watcher + * elif events: + * if watcher.events == events: # <<<<<<<<<<<<<< + * return + * watcher.stop() + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_watcher, __pyx_n_s_events); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 373, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_events); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 373, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_9 = PyObject_RichCompare(__pyx_t_3, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 373, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 373, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (__pyx_t_4) { + + /* "gevent/ares.pyx":374 + * elif events: + * if watcher.events == events: + * return # <<<<<<<<<<<<<< + * watcher.stop() + * watcher.events = events + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "gevent/ares.pyx":373 + * self._watchers[socket] = watcher + * elif events: + * if watcher.events == events: # <<<<<<<<<<<<<< + * return + * watcher.stop() + */ + } + + /* "gevent/ares.pyx":375 + * if watcher.events == events: + * return + * watcher.stop() # <<<<<<<<<<<<<< + * watcher.events = events + * else: + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_watcher, __pyx_n_s_stop); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 375, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (__pyx_t_3) { + __pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 375, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __pyx_t_9 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 375, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "gevent/ares.pyx":376 + * return + * watcher.stop() + * watcher.events = events # <<<<<<<<<<<<<< + * else: + * watcher.stop() + */ + __pyx_t_9 = __Pyx_PyInt_From_int(__pyx_v_events); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 376, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if (__Pyx_PyObject_SetAttrStr(__pyx_v_watcher, __pyx_n_s_events, __pyx_t_9) < 0) __PYX_ERR(0, 376, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "gevent/ares.pyx":372 + * watcher = self.loop.io(socket, events) + * self._watchers[socket] = watcher + * elif events: # <<<<<<<<<<<<<< + * if watcher.events == events: + * return + */ + goto __pyx_L6; + } + + /* "gevent/ares.pyx":378 + * watcher.events = events + * else: + * watcher.stop() # <<<<<<<<<<<<<< + * self._watchers.pop(socket, None) + * if not self._watchers: + */ + /*else*/ { + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_watcher, __pyx_n_s_stop); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 378, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (__pyx_t_3) { + __pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 378, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __pyx_t_9 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 378, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "gevent/ares.pyx":379 + * else: + * watcher.stop() + * self._watchers.pop(socket, None) # <<<<<<<<<<<<<< + * if not self._watchers: + * self._timer.stop() + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_watchers, __pyx_n_s_pop); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 379, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_socket); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 379, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = NULL; + __pyx_t_8 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_8 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_t_3, Py_None}; + __pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 379, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_t_3, Py_None}; + __pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 379, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + { + __pyx_t_5 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 379, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (__pyx_t_6) { + __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_6); __pyx_t_6 = NULL; + } + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_5, 0+__pyx_t_8, __pyx_t_3); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_8, Py_None); + __pyx_t_3 = 0; + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 379, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "gevent/ares.pyx":380 + * watcher.stop() + * self._watchers.pop(socket, None) + * if not self._watchers: # <<<<<<<<<<<<<< + * self._timer.stop() + * return + */ + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_self->_watchers); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 380, __pyx_L1_error) + __pyx_t_1 = ((!__pyx_t_4) != 0); + if (__pyx_t_1) { + + /* "gevent/ares.pyx":381 + * self._watchers.pop(socket, None) + * if not self._watchers: + * self._timer.stop() # <<<<<<<<<<<<<< + * return + * watcher.start(self._process_fd, watcher, pass_events=True) + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_timer, __pyx_n_s_stop); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 381, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (__pyx_t_5) { + __pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_5); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 381, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else { + __pyx_t_9 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 381, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "gevent/ares.pyx":380 + * watcher.stop() + * self._watchers.pop(socket, None) + * if not self._watchers: # <<<<<<<<<<<<<< + * self._timer.stop() + * return + */ + } + + /* "gevent/ares.pyx":382 + * if not self._watchers: + * self._timer.stop() + * return # <<<<<<<<<<<<<< + * watcher.start(self._process_fd, watcher, pass_events=True) + * self._timer.again(self._on_timer) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + } + __pyx_L6:; + + /* "gevent/ares.pyx":383 + * self._timer.stop() + * return + * watcher.start(self._process_fd, watcher, pass_events=True) # <<<<<<<<<<<<<< + * self._timer.again(self._on_timer) + * + */ + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_watcher, __pyx_n_s_start); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 383, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_process_fd); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 383, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 383, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_2); + __Pyx_INCREF(__pyx_v_watcher); + __Pyx_GIVEREF(__pyx_v_watcher); + PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_v_watcher); + __pyx_t_2 = 0; + __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 383, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_pass_events, Py_True) < 0) __PYX_ERR(0, 383, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_5, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 383, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "gevent/ares.pyx":384 + * return + * watcher.start(self._process_fd, watcher, pass_events=True) + * self._timer.again(self._on_timer) # <<<<<<<<<<<<<< + * + * def _on_timer(self): + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_timer, __pyx_n_s_again); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 384, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_on_timer); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 384, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_9 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (!__pyx_t_9) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 384, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_9, __pyx_t_5}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 384, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_9, __pyx_t_5}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 384, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + { + __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 384, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_9); __pyx_t_9 = NULL; + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 384, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "gevent/ares.pyx":358 + * # cares.ares_cancel(self.channel) + * + * cdef _sock_state_callback(self, int socket, int read, int write): # <<<<<<<<<<<<<< + * if not self.channel: + * return + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("gevent.ares.channel._sock_state_callback", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_watcher); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "gevent/ares.pyx":386 + * self._timer.again(self._on_timer) + * + * def _on_timer(self): # <<<<<<<<<<<<<< + * cares.ares_process_fd(self.channel, cares.ARES_SOCKET_BAD, cares.ARES_SOCKET_BAD) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_4ares_7channel_11_on_timer(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_6gevent_4ares_7channel_11_on_timer(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_on_timer (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_4ares_7channel_10_on_timer(((struct PyGeventAresChannelObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_4ares_7channel_10_on_timer(struct PyGeventAresChannelObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_on_timer", 0); + + /* "gevent/ares.pyx":387 + * + * def _on_timer(self): + * cares.ares_process_fd(self.channel, cares.ARES_SOCKET_BAD, cares.ARES_SOCKET_BAD) # <<<<<<<<<<<<<< + * + * def _process_fd(self, int events, object watcher): + */ + ares_process_fd(__pyx_v_self->channel, ARES_SOCKET_BAD, ARES_SOCKET_BAD); + + /* "gevent/ares.pyx":386 + * self._timer.again(self._on_timer) + * + * def _on_timer(self): # <<<<<<<<<<<<<< + * cares.ares_process_fd(self.channel, cares.ARES_SOCKET_BAD, cares.ARES_SOCKET_BAD) + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "gevent/ares.pyx":389 + * cares.ares_process_fd(self.channel, cares.ARES_SOCKET_BAD, cares.ARES_SOCKET_BAD) + * + * def _process_fd(self, int events, object watcher): # <<<<<<<<<<<<<< + * if not self.channel: + * return + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_4ares_7channel_13_process_fd(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6gevent_4ares_7channel_13_process_fd(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + int __pyx_v_events; + PyObject *__pyx_v_watcher = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_process_fd (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_events,&__pyx_n_s_watcher,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_events)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_watcher)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("_process_fd", 1, 2, 2, 1); __PYX_ERR(0, 389, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_process_fd") < 0)) __PYX_ERR(0, 389, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + } + __pyx_v_events = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_events == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 389, __pyx_L3_error) + __pyx_v_watcher = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("_process_fd", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 389, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.ares.channel._process_fd", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_4ares_7channel_12_process_fd(((struct PyGeventAresChannelObject *)__pyx_v_self), __pyx_v_events, __pyx_v_watcher); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_4ares_7channel_12_process_fd(struct PyGeventAresChannelObject *__pyx_v_self, int __pyx_v_events, PyObject *__pyx_v_watcher) { + int __pyx_v_read_fd; + int __pyx_v_write_fd; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + __Pyx_RefNannySetupContext("_process_fd", 0); + + /* "gevent/ares.pyx":390 + * + * def _process_fd(self, int events, object watcher): + * if not self.channel: # <<<<<<<<<<<<<< + * return + * cdef int read_fd = watcher.fd + */ + __pyx_t_1 = ((!(__pyx_v_self->channel != 0)) != 0); + if (__pyx_t_1) { + + /* "gevent/ares.pyx":391 + * def _process_fd(self, int events, object watcher): + * if not self.channel: + * return # <<<<<<<<<<<<<< + * cdef int read_fd = watcher.fd + * cdef int write_fd = read_fd + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "gevent/ares.pyx":390 + * + * def _process_fd(self, int events, object watcher): + * if not self.channel: # <<<<<<<<<<<<<< + * return + * cdef int read_fd = watcher.fd + */ + } + + /* "gevent/ares.pyx":392 + * if not self.channel: + * return + * cdef int read_fd = watcher.fd # <<<<<<<<<<<<<< + * cdef int write_fd = read_fd + * if not (events & EV_READ): + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_watcher, __pyx_n_s_fd); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 392, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 392, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_read_fd = __pyx_t_3; + + /* "gevent/ares.pyx":393 + * return + * cdef int read_fd = watcher.fd + * cdef int write_fd = read_fd # <<<<<<<<<<<<<< + * if not (events & EV_READ): + * read_fd = cares.ARES_SOCKET_BAD + */ + __pyx_v_write_fd = __pyx_v_read_fd; + + /* "gevent/ares.pyx":394 + * cdef int read_fd = watcher.fd + * cdef int write_fd = read_fd + * if not (events & EV_READ): # <<<<<<<<<<<<<< + * read_fd = cares.ARES_SOCKET_BAD + * if not (events & EV_WRITE): + */ + __pyx_t_1 = ((!((__pyx_v_events & 1) != 0)) != 0); + if (__pyx_t_1) { + + /* "gevent/ares.pyx":395 + * cdef int write_fd = read_fd + * if not (events & EV_READ): + * read_fd = cares.ARES_SOCKET_BAD # <<<<<<<<<<<<<< + * if not (events & EV_WRITE): + * write_fd = cares.ARES_SOCKET_BAD + */ + __pyx_v_read_fd = ARES_SOCKET_BAD; + + /* "gevent/ares.pyx":394 + * cdef int read_fd = watcher.fd + * cdef int write_fd = read_fd + * if not (events & EV_READ): # <<<<<<<<<<<<<< + * read_fd = cares.ARES_SOCKET_BAD + * if not (events & EV_WRITE): + */ + } + + /* "gevent/ares.pyx":396 + * if not (events & EV_READ): + * read_fd = cares.ARES_SOCKET_BAD + * if not (events & EV_WRITE): # <<<<<<<<<<<<<< + * write_fd = cares.ARES_SOCKET_BAD + * cares.ares_process_fd(self.channel, read_fd, write_fd) + */ + __pyx_t_1 = ((!((__pyx_v_events & 2) != 0)) != 0); + if (__pyx_t_1) { + + /* "gevent/ares.pyx":397 + * read_fd = cares.ARES_SOCKET_BAD + * if not (events & EV_WRITE): + * write_fd = cares.ARES_SOCKET_BAD # <<<<<<<<<<<<<< + * cares.ares_process_fd(self.channel, read_fd, write_fd) + * + */ + __pyx_v_write_fd = ARES_SOCKET_BAD; + + /* "gevent/ares.pyx":396 + * if not (events & EV_READ): + * read_fd = cares.ARES_SOCKET_BAD + * if not (events & EV_WRITE): # <<<<<<<<<<<<<< + * write_fd = cares.ARES_SOCKET_BAD + * cares.ares_process_fd(self.channel, read_fd, write_fd) + */ + } + + /* "gevent/ares.pyx":398 + * if not (events & EV_WRITE): + * write_fd = cares.ARES_SOCKET_BAD + * cares.ares_process_fd(self.channel, read_fd, write_fd) # <<<<<<<<<<<<<< + * + * def gethostbyname(self, object callback, char* name, int family=AF_INET): + */ + ares_process_fd(__pyx_v_self->channel, __pyx_v_read_fd, __pyx_v_write_fd); + + /* "gevent/ares.pyx":389 + * cares.ares_process_fd(self.channel, cares.ARES_SOCKET_BAD, cares.ARES_SOCKET_BAD) + * + * def _process_fd(self, int events, object watcher): # <<<<<<<<<<<<<< + * if not self.channel: + * return + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.ares.channel._process_fd", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "gevent/ares.pyx":400 + * cares.ares_process_fd(self.channel, read_fd, write_fd) + * + * def gethostbyname(self, object callback, char* name, int family=AF_INET): # <<<<<<<<<<<<<< + * if not self.channel: + * raise gaierror(cares.ARES_EDESTRUCTION, 'this ares channel has been destroyed') + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_4ares_7channel_15gethostbyname(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6gevent_4ares_7channel_15gethostbyname(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_callback = 0; + char *__pyx_v_name; + int __pyx_v_family; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("gethostbyname (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_callback,&__pyx_n_s_name_2,&__pyx_n_s_family,0}; + PyObject* values[3] = {0,0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_callback)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_name_2)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("gethostbyname", 0, 2, 3, 1); __PYX_ERR(0, 400, __pyx_L3_error) + } + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_family); + if (value) { values[2] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "gethostbyname") < 0)) __PYX_ERR(0, 400, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_callback = values[0]; + __pyx_v_name = __Pyx_PyObject_AsString(values[1]); if (unlikely((!__pyx_v_name) && PyErr_Occurred())) __PYX_ERR(0, 400, __pyx_L3_error) + if (values[2]) { + __pyx_v_family = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_family == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 400, __pyx_L3_error) + } else { + __pyx_v_family = __pyx_k__5; + } + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("gethostbyname", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 400, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.ares.channel.gethostbyname", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_4ares_7channel_14gethostbyname(((struct PyGeventAresChannelObject *)__pyx_v_self), __pyx_v_callback, __pyx_v_name, __pyx_v_family); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_4ares_7channel_14gethostbyname(struct PyGeventAresChannelObject *__pyx_v_self, PyObject *__pyx_v_callback, char *__pyx_v_name, int __pyx_v_family) { + PyObject *__pyx_v_arg = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + __Pyx_RefNannySetupContext("gethostbyname", 0); + + /* "gevent/ares.pyx":401 + * + * def gethostbyname(self, object callback, char* name, int family=AF_INET): + * if not self.channel: # <<<<<<<<<<<<<< + * raise gaierror(cares.ARES_EDESTRUCTION, 'this ares channel has been destroyed') + * # note that for file lookups still AF_INET can be returned for AF_INET6 request + */ + __pyx_t_1 = ((!(__pyx_v_self->channel != 0)) != 0); + if (__pyx_t_1) { + + /* "gevent/ares.pyx":402 + * def gethostbyname(self, object callback, char* name, int family=AF_INET): + * if not self.channel: + * raise gaierror(cares.ARES_EDESTRUCTION, 'this ares channel has been destroyed') # <<<<<<<<<<<<<< + * # note that for file lookups still AF_INET can be returned for AF_INET6 request + * cdef object arg = (self, callback) + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_gaierror); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 402, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_From_int(ARES_EDESTRUCTION); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 402, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_6 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_4, __pyx_kp_s_this_ares_channel_has_been_destr}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 402, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_4, __pyx_kp_s_this_ares_channel_has_been_destr}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 402, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + { + __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 402, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__pyx_t_5) { + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL; + } + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_t_4); + __Pyx_INCREF(__pyx_kp_s_this_ares_channel_has_been_destr); + __Pyx_GIVEREF(__pyx_kp_s_this_ares_channel_has_been_destr); + PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_kp_s_this_ares_channel_has_been_destr); + __pyx_t_4 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 402, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 402, __pyx_L1_error) + + /* "gevent/ares.pyx":401 + * + * def gethostbyname(self, object callback, char* name, int family=AF_INET): + * if not self.channel: # <<<<<<<<<<<<<< + * raise gaierror(cares.ARES_EDESTRUCTION, 'this ares channel has been destroyed') + * # note that for file lookups still AF_INET can be returned for AF_INET6 request + */ + } + + /* "gevent/ares.pyx":404 + * raise gaierror(cares.ARES_EDESTRUCTION, 'this ares channel has been destroyed') + * # note that for file lookups still AF_INET can be returned for AF_INET6 request + * cdef object arg = (self, callback) # <<<<<<<<<<<<<< + * Py_INCREF(arg) + * cares.ares_gethostbyname(self.channel, name, family, gevent_ares_host_callback, arg) + */ + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 404, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + PyTuple_SET_ITEM(__pyx_t_2, 0, ((PyObject *)__pyx_v_self)); + __Pyx_INCREF(__pyx_v_callback); + __Pyx_GIVEREF(__pyx_v_callback); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_callback); + __pyx_v_arg = __pyx_t_2; + __pyx_t_2 = 0; + + /* "gevent/ares.pyx":405 + * # note that for file lookups still AF_INET can be returned for AF_INET6 request + * cdef object arg = (self, callback) + * Py_INCREF(arg) # <<<<<<<<<<<<<< + * cares.ares_gethostbyname(self.channel, name, family, gevent_ares_host_callback, arg) + * + */ + Py_INCREF(((PyObject*)__pyx_v_arg)); + + /* "gevent/ares.pyx":406 + * cdef object arg = (self, callback) + * Py_INCREF(arg) + * cares.ares_gethostbyname(self.channel, name, family, gevent_ares_host_callback, arg) # <<<<<<<<<<<<<< + * + * def gethostbyaddr(self, object callback, char* addr): + */ + ares_gethostbyname(__pyx_v_self->channel, __pyx_v_name, __pyx_v_family, ((void *)__pyx_f_6gevent_4ares_gevent_ares_host_callback), ((void *)__pyx_v_arg)); + + /* "gevent/ares.pyx":400 + * cares.ares_process_fd(self.channel, read_fd, write_fd) + * + * def gethostbyname(self, object callback, char* name, int family=AF_INET): # <<<<<<<<<<<<<< + * if not self.channel: + * raise gaierror(cares.ARES_EDESTRUCTION, 'this ares channel has been destroyed') + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("gevent.ares.channel.gethostbyname", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_arg); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "gevent/ares.pyx":408 + * cares.ares_gethostbyname(self.channel, name, family, gevent_ares_host_callback, arg) + * + * def gethostbyaddr(self, object callback, char* addr): # <<<<<<<<<<<<<< + * if not self.channel: + * raise gaierror(cares.ARES_EDESTRUCTION, 'this ares channel has been destroyed') + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_4ares_7channel_17gethostbyaddr(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6gevent_4ares_7channel_17gethostbyaddr(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_callback = 0; + char *__pyx_v_addr; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("gethostbyaddr (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_callback,&__pyx_n_s_addr,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_callback)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_addr)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("gethostbyaddr", 1, 2, 2, 1); __PYX_ERR(0, 408, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "gethostbyaddr") < 0)) __PYX_ERR(0, 408, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + } + __pyx_v_callback = values[0]; + __pyx_v_addr = __Pyx_PyObject_AsString(values[1]); if (unlikely((!__pyx_v_addr) && PyErr_Occurred())) __PYX_ERR(0, 408, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("gethostbyaddr", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 408, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.ares.channel.gethostbyaddr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_4ares_7channel_16gethostbyaddr(((struct PyGeventAresChannelObject *)__pyx_v_self), __pyx_v_callback, __pyx_v_addr); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_4ares_7channel_16gethostbyaddr(struct PyGeventAresChannelObject *__pyx_v_self, PyObject *__pyx_v_callback, char *__pyx_v_addr) { + char __pyx_v_addr_packed[16]; + int __pyx_v_family; + int __pyx_v_length; + PyObject *__pyx_v_arg = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + __Pyx_RefNannySetupContext("gethostbyaddr", 0); + + /* "gevent/ares.pyx":409 + * + * def gethostbyaddr(self, object callback, char* addr): + * if not self.channel: # <<<<<<<<<<<<<< + * raise gaierror(cares.ARES_EDESTRUCTION, 'this ares channel has been destroyed') + * # will guess the family + */ + __pyx_t_1 = ((!(__pyx_v_self->channel != 0)) != 0); + if (__pyx_t_1) { + + /* "gevent/ares.pyx":410 + * def gethostbyaddr(self, object callback, char* addr): + * if not self.channel: + * raise gaierror(cares.ARES_EDESTRUCTION, 'this ares channel has been destroyed') # <<<<<<<<<<<<<< + * # will guess the family + * cdef char addr_packed[16] + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_gaierror); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 410, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_From_int(ARES_EDESTRUCTION); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 410, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_6 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_4, __pyx_kp_s_this_ares_channel_has_been_destr}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 410, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_4, __pyx_kp_s_this_ares_channel_has_been_destr}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 410, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + { + __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 410, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__pyx_t_5) { + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL; + } + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_t_4); + __Pyx_INCREF(__pyx_kp_s_this_ares_channel_has_been_destr); + __Pyx_GIVEREF(__pyx_kp_s_this_ares_channel_has_been_destr); + PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_kp_s_this_ares_channel_has_been_destr); + __pyx_t_4 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 410, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 410, __pyx_L1_error) + + /* "gevent/ares.pyx":409 + * + * def gethostbyaddr(self, object callback, char* addr): + * if not self.channel: # <<<<<<<<<<<<<< + * raise gaierror(cares.ARES_EDESTRUCTION, 'this ares channel has been destroyed') + * # will guess the family + */ + } + + /* "gevent/ares.pyx":415 + * cdef int family + * cdef int length + * if cares.ares_inet_pton(AF_INET, addr, addr_packed) > 0: # <<<<<<<<<<<<<< + * family = AF_INET + * length = 4 + */ + __pyx_t_1 = ((ares_inet_pton(AF_INET, __pyx_v_addr, __pyx_v_addr_packed) > 0) != 0); + if (__pyx_t_1) { + + /* "gevent/ares.pyx":416 + * cdef int length + * if cares.ares_inet_pton(AF_INET, addr, addr_packed) > 0: + * family = AF_INET # <<<<<<<<<<<<<< + * length = 4 + * elif cares.ares_inet_pton(AF_INET6, addr, addr_packed) > 0: + */ + __pyx_v_family = AF_INET; + + /* "gevent/ares.pyx":417 + * if cares.ares_inet_pton(AF_INET, addr, addr_packed) > 0: + * family = AF_INET + * length = 4 # <<<<<<<<<<<<<< + * elif cares.ares_inet_pton(AF_INET6, addr, addr_packed) > 0: + * family = AF_INET6 + */ + __pyx_v_length = 4; + + /* "gevent/ares.pyx":415 + * cdef int family + * cdef int length + * if cares.ares_inet_pton(AF_INET, addr, addr_packed) > 0: # <<<<<<<<<<<<<< + * family = AF_INET + * length = 4 + */ + goto __pyx_L4; + } + + /* "gevent/ares.pyx":418 + * family = AF_INET + * length = 4 + * elif cares.ares_inet_pton(AF_INET6, addr, addr_packed) > 0: # <<<<<<<<<<<<<< + * family = AF_INET6 + * length = 16 + */ + __pyx_t_1 = ((ares_inet_pton(AF_INET6, __pyx_v_addr, __pyx_v_addr_packed) > 0) != 0); + if (__pyx_t_1) { + + /* "gevent/ares.pyx":419 + * length = 4 + * elif cares.ares_inet_pton(AF_INET6, addr, addr_packed) > 0: + * family = AF_INET6 # <<<<<<<<<<<<<< + * length = 16 + * else: + */ + __pyx_v_family = AF_INET6; + + /* "gevent/ares.pyx":420 + * elif cares.ares_inet_pton(AF_INET6, addr, addr_packed) > 0: + * family = AF_INET6 + * length = 16 # <<<<<<<<<<<<<< + * else: + * raise InvalidIP(repr(addr)) + */ + __pyx_v_length = 16; + + /* "gevent/ares.pyx":418 + * family = AF_INET + * length = 4 + * elif cares.ares_inet_pton(AF_INET6, addr, addr_packed) > 0: # <<<<<<<<<<<<<< + * family = AF_INET6 + * length = 16 + */ + goto __pyx_L4; + } + + /* "gevent/ares.pyx":422 + * length = 16 + * else: + * raise InvalidIP(repr(addr)) # <<<<<<<<<<<<<< + * cdef object arg = (self, callback) + * Py_INCREF(arg) + */ + /*else*/ { + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_InvalidIP); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 422, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = __Pyx_PyBytes_FromString(__pyx_v_addr); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 422, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_4 = PyObject_Repr(__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 422, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_7) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 422, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 422, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 422, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + { + __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 422, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_7); __pyx_t_7 = NULL; + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 422, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 422, __pyx_L1_error) + } + __pyx_L4:; + + /* "gevent/ares.pyx":423 + * else: + * raise InvalidIP(repr(addr)) + * cdef object arg = (self, callback) # <<<<<<<<<<<<<< + * Py_INCREF(arg) + * cares.ares_gethostbyaddr(self.channel, addr_packed, length, family, gevent_ares_host_callback, arg) + */ + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 423, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + PyTuple_SET_ITEM(__pyx_t_2, 0, ((PyObject *)__pyx_v_self)); + __Pyx_INCREF(__pyx_v_callback); + __Pyx_GIVEREF(__pyx_v_callback); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_callback); + __pyx_v_arg = __pyx_t_2; + __pyx_t_2 = 0; + + /* "gevent/ares.pyx":424 + * raise InvalidIP(repr(addr)) + * cdef object arg = (self, callback) + * Py_INCREF(arg) # <<<<<<<<<<<<<< + * cares.ares_gethostbyaddr(self.channel, addr_packed, length, family, gevent_ares_host_callback, arg) + * + */ + Py_INCREF(((PyObject*)__pyx_v_arg)); + + /* "gevent/ares.pyx":425 + * cdef object arg = (self, callback) + * Py_INCREF(arg) + * cares.ares_gethostbyaddr(self.channel, addr_packed, length, family, gevent_ares_host_callback, arg) # <<<<<<<<<<<<<< + * + * cpdef _getnameinfo(self, object callback, tuple sockaddr, int flags): + */ + ares_gethostbyaddr(__pyx_v_self->channel, __pyx_v_addr_packed, __pyx_v_length, __pyx_v_family, ((void *)__pyx_f_6gevent_4ares_gevent_ares_host_callback), ((void *)__pyx_v_arg)); + + /* "gevent/ares.pyx":408 + * cares.ares_gethostbyname(self.channel, name, family, gevent_ares_host_callback, arg) + * + * def gethostbyaddr(self, object callback, char* addr): # <<<<<<<<<<<<<< + * if not self.channel: + * raise gaierror(cares.ARES_EDESTRUCTION, 'this ares channel has been destroyed') + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("gevent.ares.channel.gethostbyaddr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_arg); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "gevent/ares.pyx":427 + * cares.ares_gethostbyaddr(self.channel, addr_packed, length, family, gevent_ares_host_callback, arg) + * + * cpdef _getnameinfo(self, object callback, tuple sockaddr, int flags): # <<<<<<<<<<<<<< + * if not self.channel: + * raise gaierror(cares.ARES_EDESTRUCTION, 'this ares channel has been destroyed') + */ + +static PyObject *__pyx_pw_6gevent_4ares_7channel_19_getnameinfo(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_f_6gevent_4ares_7channel__getnameinfo(struct PyGeventAresChannelObject *__pyx_v_self, PyObject *__pyx_v_callback, PyObject *__pyx_v_sockaddr, int __pyx_v_flags, int __pyx_skip_dispatch) { + char *__pyx_v_hostp; + int __pyx_v_port; + int __pyx_v_flowinfo; + int __pyx_v_scope_id; + struct sockaddr_in6 __pyx_v_sa6; + int __pyx_v_length; + PyObject *__pyx_v_arg = 0; + struct sockaddr *__pyx_v_x; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + int __pyx_t_9; + __Pyx_RefNannySetupContext("_getnameinfo", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getnameinfo); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 427, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_6gevent_4ares_7channel_19_getnameinfo)) { + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_flags); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 427, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_t_1); + __pyx_t_4 = __pyx_t_1; __pyx_t_5 = NULL; + __pyx_t_6 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_6 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[4] = {__pyx_t_5, __pyx_v_callback, __pyx_v_sockaddr, __pyx_t_3}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 3+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 427, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[4] = {__pyx_t_5, __pyx_v_callback, __pyx_v_sockaddr, __pyx_t_3}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 3+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 427, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + { + __pyx_t_7 = PyTuple_New(3+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 427, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__pyx_t_5) { + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL; + } + __Pyx_INCREF(__pyx_v_callback); + __Pyx_GIVEREF(__pyx_v_callback); + PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_v_callback); + __Pyx_INCREF(__pyx_v_sockaddr); + __Pyx_GIVEREF(__pyx_v_sockaddr); + PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_v_sockaddr); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_7, 2+__pyx_t_6, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 427, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "gevent/ares.pyx":428 + * + * cpdef _getnameinfo(self, object callback, tuple sockaddr, int flags): + * if not self.channel: # <<<<<<<<<<<<<< + * raise gaierror(cares.ARES_EDESTRUCTION, 'this ares channel has been destroyed') + * cdef char* hostp = NULL + */ + __pyx_t_8 = ((!(__pyx_v_self->channel != 0)) != 0); + if (__pyx_t_8) { + + /* "gevent/ares.pyx":429 + * cpdef _getnameinfo(self, object callback, tuple sockaddr, int flags): + * if not self.channel: + * raise gaierror(cares.ARES_EDESTRUCTION, 'this ares channel has been destroyed') # <<<<<<<<<<<<<< + * cdef char* hostp = NULL + * cdef int port = 0 + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_gaierror); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 429, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyInt_From_int(ARES_EDESTRUCTION); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 429, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = NULL; + __pyx_t_6 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_4, __pyx_kp_s_this_ares_channel_has_been_destr}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 429, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_4, __pyx_kp_s_this_ares_channel_has_been_destr}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 429, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + { + __pyx_t_3 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 429, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__pyx_t_7) { + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_7); __pyx_t_7 = NULL; + } + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_3, 0+__pyx_t_6, __pyx_t_4); + __Pyx_INCREF(__pyx_kp_s_this_ares_channel_has_been_destr); + __Pyx_GIVEREF(__pyx_kp_s_this_ares_channel_has_been_destr); + PyTuple_SET_ITEM(__pyx_t_3, 1+__pyx_t_6, __pyx_kp_s_this_ares_channel_has_been_destr); + __pyx_t_4 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 429, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 429, __pyx_L1_error) + + /* "gevent/ares.pyx":428 + * + * cpdef _getnameinfo(self, object callback, tuple sockaddr, int flags): + * if not self.channel: # <<<<<<<<<<<<<< + * raise gaierror(cares.ARES_EDESTRUCTION, 'this ares channel has been destroyed') + * cdef char* hostp = NULL + */ + } + + /* "gevent/ares.pyx":430 + * if not self.channel: + * raise gaierror(cares.ARES_EDESTRUCTION, 'this ares channel has been destroyed') + * cdef char* hostp = NULL # <<<<<<<<<<<<<< + * cdef int port = 0 + * cdef int flowinfo = 0 + */ + __pyx_v_hostp = NULL; + + /* "gevent/ares.pyx":431 + * raise gaierror(cares.ARES_EDESTRUCTION, 'this ares channel has been destroyed') + * cdef char* hostp = NULL + * cdef int port = 0 # <<<<<<<<<<<<<< + * cdef int flowinfo = 0 + * cdef int scope_id = 0 + */ + __pyx_v_port = 0; + + /* "gevent/ares.pyx":432 + * cdef char* hostp = NULL + * cdef int port = 0 + * cdef int flowinfo = 0 # <<<<<<<<<<<<<< + * cdef int scope_id = 0 + * cdef sockaddr_in6 sa6 + */ + __pyx_v_flowinfo = 0; + + /* "gevent/ares.pyx":433 + * cdef int port = 0 + * cdef int flowinfo = 0 + * cdef int scope_id = 0 # <<<<<<<<<<<<<< + * cdef sockaddr_in6 sa6 + * if not PyTuple_Check(sockaddr): + */ + __pyx_v_scope_id = 0; + + /* "gevent/ares.pyx":435 + * cdef int scope_id = 0 + * cdef sockaddr_in6 sa6 + * if not PyTuple_Check(sockaddr): # <<<<<<<<<<<<<< + * raise TypeError('expected a tuple, got %r' % (sockaddr, )) + * PyArg_ParseTuple(sockaddr, "si|ii", &hostp, &port, &flowinfo, &scope_id) + */ + __pyx_t_8 = ((!(PyTuple_Check(__pyx_v_sockaddr) != 0)) != 0); + if (__pyx_t_8) { + + /* "gevent/ares.pyx":436 + * cdef sockaddr_in6 sa6 + * if not PyTuple_Check(sockaddr): + * raise TypeError('expected a tuple, got %r' % (sockaddr, )) # <<<<<<<<<<<<<< + * PyArg_ParseTuple(sockaddr, "si|ii", &hostp, &port, &flowinfo, &scope_id) + * if port < 0 or port > 65535: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 436, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_sockaddr); + __Pyx_GIVEREF(__pyx_v_sockaddr); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_sockaddr); + __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_expected_a_tuple_got_r, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 436, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 436, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 436, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 436, __pyx_L1_error) + + /* "gevent/ares.pyx":435 + * cdef int scope_id = 0 + * cdef sockaddr_in6 sa6 + * if not PyTuple_Check(sockaddr): # <<<<<<<<<<<<<< + * raise TypeError('expected a tuple, got %r' % (sockaddr, )) + * PyArg_ParseTuple(sockaddr, "si|ii", &hostp, &port, &flowinfo, &scope_id) + */ + } + + /* "gevent/ares.pyx":437 + * if not PyTuple_Check(sockaddr): + * raise TypeError('expected a tuple, got %r' % (sockaddr, )) + * PyArg_ParseTuple(sockaddr, "si|ii", &hostp, &port, &flowinfo, &scope_id) # <<<<<<<<<<<<<< + * if port < 0 or port > 65535: + * raise gaierror(-8, 'Invalid value for port: %r' % port) + */ + __pyx_t_6 = PyArg_ParseTuple(__pyx_v_sockaddr, ((char *)"si|ii"), (&__pyx_v_hostp), (&__pyx_v_port), (&__pyx_v_flowinfo), (&__pyx_v_scope_id)); if (unlikely(__pyx_t_6 == 0)) __PYX_ERR(0, 437, __pyx_L1_error) + + /* "gevent/ares.pyx":438 + * raise TypeError('expected a tuple, got %r' % (sockaddr, )) + * PyArg_ParseTuple(sockaddr, "si|ii", &hostp, &port, &flowinfo, &scope_id) + * if port < 0 or port > 65535: # <<<<<<<<<<<<<< + * raise gaierror(-8, 'Invalid value for port: %r' % port) + * cdef int length = gevent_make_sockaddr(hostp, port, flowinfo, scope_id, &sa6) + */ + __pyx_t_9 = ((__pyx_v_port < 0) != 0); + if (!__pyx_t_9) { + } else { + __pyx_t_8 = __pyx_t_9; + goto __pyx_L6_bool_binop_done; + } + __pyx_t_9 = ((__pyx_v_port > 0xFFFF) != 0); + __pyx_t_8 = __pyx_t_9; + __pyx_L6_bool_binop_done:; + if (__pyx_t_8) { + + /* "gevent/ares.pyx":439 + * PyArg_ParseTuple(sockaddr, "si|ii", &hostp, &port, &flowinfo, &scope_id) + * if port < 0 or port > 65535: + * raise gaierror(-8, 'Invalid value for port: %r' % port) # <<<<<<<<<<<<<< + * cdef int length = gevent_make_sockaddr(hostp, port, flowinfo, scope_id, &sa6) + * if length <= 0: + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_gaierror); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 439, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_port); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 439, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Invalid_value_for_port_r, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 439, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + __pyx_t_6 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_6 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_int_neg_8, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 439, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_int_neg_8, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 439, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + { + __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 439, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__pyx_t_3) { + __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_3); __pyx_t_3 = NULL; + } + __Pyx_INCREF(__pyx_int_neg_8); + __Pyx_GIVEREF(__pyx_int_neg_8); + PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_int_neg_8); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 439, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 439, __pyx_L1_error) + + /* "gevent/ares.pyx":438 + * raise TypeError('expected a tuple, got %r' % (sockaddr, )) + * PyArg_ParseTuple(sockaddr, "si|ii", &hostp, &port, &flowinfo, &scope_id) + * if port < 0 or port > 65535: # <<<<<<<<<<<<<< + * raise gaierror(-8, 'Invalid value for port: %r' % port) + * cdef int length = gevent_make_sockaddr(hostp, port, flowinfo, scope_id, &sa6) + */ + } + + /* "gevent/ares.pyx":440 + * if port < 0 or port > 65535: + * raise gaierror(-8, 'Invalid value for port: %r' % port) + * cdef int length = gevent_make_sockaddr(hostp, port, flowinfo, scope_id, &sa6) # <<<<<<<<<<<<<< + * if length <= 0: + * raise InvalidIP(repr(hostp)) + */ + __pyx_v_length = gevent_make_sockaddr(__pyx_v_hostp, __pyx_v_port, __pyx_v_flowinfo, __pyx_v_scope_id, (&__pyx_v_sa6)); + + /* "gevent/ares.pyx":441 + * raise gaierror(-8, 'Invalid value for port: %r' % port) + * cdef int length = gevent_make_sockaddr(hostp, port, flowinfo, scope_id, &sa6) + * if length <= 0: # <<<<<<<<<<<<<< + * raise InvalidIP(repr(hostp)) + * cdef object arg = (self, callback) + */ + __pyx_t_8 = ((__pyx_v_length <= 0) != 0); + if (__pyx_t_8) { + + /* "gevent/ares.pyx":442 + * cdef int length = gevent_make_sockaddr(hostp, port, flowinfo, scope_id, &sa6) + * if length <= 0: + * raise InvalidIP(repr(hostp)) # <<<<<<<<<<<<<< + * cdef object arg = (self, callback) + * Py_INCREF(arg) + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_InvalidIP); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 442, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_7 = __Pyx_PyBytes_FromString(__pyx_v_hostp); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 442, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_4 = PyObject_Repr(__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 442, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + if (!__pyx_t_7) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 442, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 442, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 442, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + { + __pyx_t_3 = PyTuple_New(1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 442, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_7); __pyx_t_7 = NULL; + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_3, 0+1, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 442, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 442, __pyx_L1_error) + + /* "gevent/ares.pyx":441 + * raise gaierror(-8, 'Invalid value for port: %r' % port) + * cdef int length = gevent_make_sockaddr(hostp, port, flowinfo, scope_id, &sa6) + * if length <= 0: # <<<<<<<<<<<<<< + * raise InvalidIP(repr(hostp)) + * cdef object arg = (self, callback) + */ + } + + /* "gevent/ares.pyx":443 + * if length <= 0: + * raise InvalidIP(repr(hostp)) + * cdef object arg = (self, callback) # <<<<<<<<<<<<<< + * Py_INCREF(arg) + * cdef sockaddr_t* x = &sa6 + */ + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 443, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + PyTuple_SET_ITEM(__pyx_t_2, 0, ((PyObject *)__pyx_v_self)); + __Pyx_INCREF(__pyx_v_callback); + __Pyx_GIVEREF(__pyx_v_callback); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_callback); + __pyx_v_arg = __pyx_t_2; + __pyx_t_2 = 0; + + /* "gevent/ares.pyx":444 + * raise InvalidIP(repr(hostp)) + * cdef object arg = (self, callback) + * Py_INCREF(arg) # <<<<<<<<<<<<<< + * cdef sockaddr_t* x = &sa6 + * cares.ares_getnameinfo(self.channel, x, length, flags, gevent_ares_nameinfo_callback, arg) + */ + Py_INCREF(((PyObject*)__pyx_v_arg)); + + /* "gevent/ares.pyx":445 + * cdef object arg = (self, callback) + * Py_INCREF(arg) + * cdef sockaddr_t* x = &sa6 # <<<<<<<<<<<<<< + * cares.ares_getnameinfo(self.channel, x, length, flags, gevent_ares_nameinfo_callback, arg) + * + */ + __pyx_v_x = ((struct sockaddr *)(&__pyx_v_sa6)); + + /* "gevent/ares.pyx":446 + * Py_INCREF(arg) + * cdef sockaddr_t* x = &sa6 + * cares.ares_getnameinfo(self.channel, x, length, flags, gevent_ares_nameinfo_callback, arg) # <<<<<<<<<<<<<< + * + * def getnameinfo(self, object callback, tuple sockaddr, int flags): + */ + ares_getnameinfo(__pyx_v_self->channel, __pyx_v_x, __pyx_v_length, __pyx_v_flags, ((void *)__pyx_f_6gevent_4ares_gevent_ares_nameinfo_callback), ((void *)__pyx_v_arg)); + + /* "gevent/ares.pyx":427 + * cares.ares_gethostbyaddr(self.channel, addr_packed, length, family, gevent_ares_host_callback, arg) + * + * cpdef _getnameinfo(self, object callback, tuple sockaddr, int flags): # <<<<<<<<<<<<<< + * if not self.channel: + * raise gaierror(cares.ARES_EDESTRUCTION, 'this ares channel has been destroyed') + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("gevent.ares.channel._getnameinfo", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_arg); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_4ares_7channel_19_getnameinfo(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6gevent_4ares_7channel_19_getnameinfo(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_callback = 0; + PyObject *__pyx_v_sockaddr = 0; + int __pyx_v_flags; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_getnameinfo (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_callback,&__pyx_n_s_sockaddr,&__pyx_n_s_flags,0}; + PyObject* values[3] = {0,0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_callback)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_sockaddr)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("_getnameinfo", 1, 3, 3, 1); __PYX_ERR(0, 427, __pyx_L3_error) + } + case 2: + if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_flags)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("_getnameinfo", 1, 3, 3, 2); __PYX_ERR(0, 427, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_getnameinfo") < 0)) __PYX_ERR(0, 427, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + } + __pyx_v_callback = values[0]; + __pyx_v_sockaddr = ((PyObject*)values[1]); + __pyx_v_flags = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_flags == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 427, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("_getnameinfo", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 427, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.ares.channel._getnameinfo", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_sockaddr), (&PyTuple_Type), 1, "sockaddr", 1))) __PYX_ERR(0, 427, __pyx_L1_error) + __pyx_r = __pyx_pf_6gevent_4ares_7channel_18_getnameinfo(((struct PyGeventAresChannelObject *)__pyx_v_self), __pyx_v_callback, __pyx_v_sockaddr, __pyx_v_flags); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_4ares_7channel_18_getnameinfo(struct PyGeventAresChannelObject *__pyx_v_self, PyObject *__pyx_v_callback, PyObject *__pyx_v_sockaddr, int __pyx_v_flags) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("_getnameinfo", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_6gevent_4ares_7channel__getnameinfo(__pyx_v_self, __pyx_v_callback, __pyx_v_sockaddr, __pyx_v_flags, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 427, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.ares.channel._getnameinfo", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "gevent/ares.pyx":448 + * cares.ares_getnameinfo(self.channel, x, length, flags, gevent_ares_nameinfo_callback, arg) + * + * def getnameinfo(self, object callback, tuple sockaddr, int flags): # <<<<<<<<<<<<<< + * try: + * flags = _convert_cares_flags(flags) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_4ares_7channel_21getnameinfo(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6gevent_4ares_7channel_21getnameinfo(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_callback = 0; + PyObject *__pyx_v_sockaddr = 0; + int __pyx_v_flags; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getnameinfo (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_callback,&__pyx_n_s_sockaddr,&__pyx_n_s_flags,0}; + PyObject* values[3] = {0,0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_callback)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_sockaddr)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("getnameinfo", 1, 3, 3, 1); __PYX_ERR(0, 448, __pyx_L3_error) + } + case 2: + if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_flags)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("getnameinfo", 1, 3, 3, 2); __PYX_ERR(0, 448, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getnameinfo") < 0)) __PYX_ERR(0, 448, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + } + __pyx_v_callback = values[0]; + __pyx_v_sockaddr = ((PyObject*)values[1]); + __pyx_v_flags = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_flags == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 448, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("getnameinfo", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 448, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.ares.channel.getnameinfo", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_sockaddr), (&PyTuple_Type), 1, "sockaddr", 1))) __PYX_ERR(0, 448, __pyx_L1_error) + __pyx_r = __pyx_pf_6gevent_4ares_7channel_20getnameinfo(((struct PyGeventAresChannelObject *)__pyx_v_self), __pyx_v_callback, __pyx_v_sockaddr, __pyx_v_flags); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_4ares_7channel_20getnameinfo(struct PyGeventAresChannelObject *__pyx_v_self, PyObject *__pyx_v_callback, PyObject *__pyx_v_sockaddr, int __pyx_v_flags) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + __Pyx_RefNannySetupContext("getnameinfo", 0); + + /* "gevent/ares.pyx":449 + * + * def getnameinfo(self, object callback, tuple sockaddr, int flags): + * try: # <<<<<<<<<<<<<< + * flags = _convert_cares_flags(flags) + * except gaierror: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { + + /* "gevent/ares.pyx":450 + * def getnameinfo(self, object callback, tuple sockaddr, int flags): + * try: + * flags = _convert_cares_flags(flags) # <<<<<<<<<<<<<< + * except gaierror: + * # The stdlib just ignores bad flags + */ + __pyx_t_4 = __pyx_f_6gevent_4ares__convert_cares_flags(__pyx_v_flags, 0, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 450, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_4); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 450, __pyx_L3_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_flags = __pyx_t_5; + + /* "gevent/ares.pyx":449 + * + * def getnameinfo(self, object callback, tuple sockaddr, int flags): + * try: # <<<<<<<<<<<<<< + * flags = _convert_cares_flags(flags) + * except gaierror: + */ + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L10_try_end; + __pyx_L3_error:; + __Pyx_PyThreadState_assign + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "gevent/ares.pyx":451 + * try: + * flags = _convert_cares_flags(flags) + * except gaierror: # <<<<<<<<<<<<<< + * # The stdlib just ignores bad flags + * flags = 0 + */ + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_gaierror); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 451, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyErr_ExceptionMatches(__pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_5) { + __Pyx_AddTraceback("gevent.ares.channel.getnameinfo", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(0, 451, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_t_7); + + /* "gevent/ares.pyx":453 + * except gaierror: + * # The stdlib just ignores bad flags + * flags = 0 # <<<<<<<<<<<<<< + * return self._getnameinfo(callback, sockaddr, flags) + */ + __pyx_v_flags = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + goto __pyx_L4_exception_handled; + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; + + /* "gevent/ares.pyx":449 + * + * def getnameinfo(self, object callback, tuple sockaddr, int flags): + * try: # <<<<<<<<<<<<<< + * flags = _convert_cares_flags(flags) + * except gaierror: + */ + __Pyx_PyThreadState_assign + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L4_exception_handled:; + __Pyx_PyThreadState_assign + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + __pyx_L10_try_end:; + } + + /* "gevent/ares.pyx":454 + * # The stdlib just ignores bad flags + * flags = 0 + * return self._getnameinfo(callback, sockaddr, flags) # <<<<<<<<<<<<<< + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_7 = ((struct __pyx_vtabstruct_6gevent_4ares_channel *)__pyx_v_self->__pyx_vtab)->_getnameinfo(__pyx_v_self, __pyx_v_callback, __pyx_v_sockaddr, __pyx_v_flags, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 454, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_r = __pyx_t_7; + __pyx_t_7 = 0; + goto __pyx_L0; + + /* "gevent/ares.pyx":448 + * cares.ares_getnameinfo(self.channel, x, length, flags, gevent_ares_nameinfo_callback, arg) + * + * def getnameinfo(self, object callback, tuple sockaddr, int flags): # <<<<<<<<<<<<<< + * try: + * flags = _convert_cares_flags(flags) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("gevent.ares.channel.getnameinfo", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "gevent/ares.pyx":247 + * cdef public class channel [object PyGeventAresChannelObject, type PyGeventAresChannel_Type]: + * + * cdef public object loop # <<<<<<<<<<<<<< + * cdef ares_channeldata* channel + * cdef public dict _watchers + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_4ares_7channel_4loop_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_4ares_7channel_4loop_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_4ares_7channel_4loop___get__(((struct PyGeventAresChannelObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_4ares_7channel_4loop___get__(struct PyGeventAresChannelObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->loop); + __pyx_r = __pyx_v_self->loop; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_4ares_7channel_4loop_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_6gevent_4ares_7channel_4loop_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_4ares_7channel_4loop_2__set__(((struct PyGeventAresChannelObject *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_4ares_7channel_4loop_2__set__(struct PyGeventAresChannelObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __Pyx_INCREF(__pyx_v_value); + __Pyx_GIVEREF(__pyx_v_value); + __Pyx_GOTREF(__pyx_v_self->loop); + __Pyx_DECREF(__pyx_v_self->loop); + __pyx_v_self->loop = __pyx_v_value; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_4ares_7channel_4loop_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_6gevent_4ares_7channel_4loop_5__del__(PyObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_4ares_7channel_4loop_4__del__(((struct PyGeventAresChannelObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_4ares_7channel_4loop_4__del__(struct PyGeventAresChannelObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 0); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->loop); + __Pyx_DECREF(__pyx_v_self->loop); + __pyx_v_self->loop = Py_None; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "gevent/ares.pyx":249 + * cdef public object loop + * cdef ares_channeldata* channel + * cdef public dict _watchers # <<<<<<<<<<<<<< + * cdef public object _timer + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_4ares_7channel_9_watchers_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_4ares_7channel_9_watchers_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_4ares_7channel_9_watchers___get__(((struct PyGeventAresChannelObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_4ares_7channel_9_watchers___get__(struct PyGeventAresChannelObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->_watchers); + __pyx_r = __pyx_v_self->_watchers; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_4ares_7channel_9_watchers_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_6gevent_4ares_7channel_9_watchers_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_4ares_7channel_9_watchers_2__set__(((struct PyGeventAresChannelObject *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_4ares_7channel_9_watchers_2__set__(struct PyGeventAresChannelObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__set__", 0); + if (!(likely(PyDict_CheckExact(__pyx_v_value))||((__pyx_v_value) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_v_value)->tp_name), 0))) __PYX_ERR(0, 249, __pyx_L1_error) + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->_watchers); + __Pyx_DECREF(__pyx_v_self->_watchers); + __pyx_v_self->_watchers = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.ares.channel._watchers.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_4ares_7channel_9_watchers_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_6gevent_4ares_7channel_9_watchers_5__del__(PyObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_4ares_7channel_9_watchers_4__del__(((struct PyGeventAresChannelObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_4ares_7channel_9_watchers_4__del__(struct PyGeventAresChannelObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 0); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->_watchers); + __Pyx_DECREF(__pyx_v_self->_watchers); + __pyx_v_self->_watchers = ((PyObject*)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "gevent/ares.pyx":250 + * cdef ares_channeldata* channel + * cdef public dict _watchers + * cdef public object _timer # <<<<<<<<<<<<<< + * + * def __init__(self, object loop, flags=None, timeout=None, tries=None, ndots=None, + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_4ares_7channel_6_timer_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_4ares_7channel_6_timer_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_4ares_7channel_6_timer___get__(((struct PyGeventAresChannelObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_4ares_7channel_6_timer___get__(struct PyGeventAresChannelObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->_timer); + __pyx_r = __pyx_v_self->_timer; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_4ares_7channel_6_timer_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_6gevent_4ares_7channel_6_timer_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_4ares_7channel_6_timer_2__set__(((struct PyGeventAresChannelObject *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_4ares_7channel_6_timer_2__set__(struct PyGeventAresChannelObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __Pyx_INCREF(__pyx_v_value); + __Pyx_GIVEREF(__pyx_v_value); + __Pyx_GOTREF(__pyx_v_self->_timer); + __Pyx_DECREF(__pyx_v_self->_timer); + __pyx_v_self->_timer = __pyx_v_value; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_4ares_7channel_6_timer_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_6gevent_4ares_7channel_6_timer_5__del__(PyObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_4ares_7channel_6_timer_4__del__(((struct PyGeventAresChannelObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_4ares_7channel_6_timer_4__del__(struct PyGeventAresChannelObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 0); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->_timer); + __Pyx_DECREF(__pyx_v_self->_timer); + __pyx_v_self->_timer = Py_None; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_tp_new_6gevent_4ares_result(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_6gevent_4ares_result *p; + PyObject *o; + if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_6gevent_4ares_result *)o); + p->value = Py_None; Py_INCREF(Py_None); + p->exception = Py_None; Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_6gevent_4ares_result(PyObject *o) { + struct __pyx_obj_6gevent_4ares_result *p = (struct __pyx_obj_6gevent_4ares_result *)o; + #if PY_VERSION_HEX >= 0x030400a1 + if (unlikely(Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->value); + Py_CLEAR(p->exception); + (*Py_TYPE(o)->tp_free)(o); +} + +static int __pyx_tp_traverse_6gevent_4ares_result(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_6gevent_4ares_result *p = (struct __pyx_obj_6gevent_4ares_result *)o; + if (p->value) { + e = (*v)(p->value, a); if (e) return e; + } + if (p->exception) { + e = (*v)(p->exception, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_6gevent_4ares_result(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_6gevent_4ares_result *p = (struct __pyx_obj_6gevent_4ares_result *)o; + tmp = ((PyObject*)p->value); + p->value = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->exception); + p->exception = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_6gevent_4ares_6result_value(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_4ares_6result_5value_1__get__(o); +} + +static int __pyx_setprop_6gevent_4ares_6result_value(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_4ares_6result_5value_3__set__(o, v); + } + else { + return __pyx_pw_6gevent_4ares_6result_5value_5__del__(o); + } +} + +static PyObject *__pyx_getprop_6gevent_4ares_6result_exception(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_4ares_6result_9exception_1__get__(o); +} + +static int __pyx_setprop_6gevent_4ares_6result_exception(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_4ares_6result_9exception_3__set__(o, v); + } + else { + return __pyx_pw_6gevent_4ares_6result_9exception_5__del__(o); + } +} + +static PyMethodDef __pyx_methods_6gevent_4ares_result[] = { + {"successful", (PyCFunction)__pyx_pw_6gevent_4ares_6result_5successful, METH_NOARGS, 0}, + {"get", (PyCFunction)__pyx_pw_6gevent_4ares_6result_7get, METH_NOARGS, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_6gevent_4ares_result[] = { + {(char *)"value", __pyx_getprop_6gevent_4ares_6result_value, __pyx_setprop_6gevent_4ares_6result_value, (char *)0, 0}, + {(char *)"exception", __pyx_getprop_6gevent_4ares_6result_exception, __pyx_setprop_6gevent_4ares_6result_exception, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; + +static PyTypeObject __pyx_type_6gevent_4ares_result = { + PyVarObject_HEAD_INIT(0, 0) + "gevent.ares.result", /*tp_name*/ + sizeof(struct __pyx_obj_6gevent_4ares_result), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_6gevent_4ares_result, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + __pyx_pw_6gevent_4ares_6result_3__repr__, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_6gevent_4ares_result, /*tp_traverse*/ + __pyx_tp_clear_6gevent_4ares_result, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_6gevent_4ares_result, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_6gevent_4ares_result, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + __pyx_pw_6gevent_4ares_6result_1__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_6gevent_4ares_result, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; +static struct __pyx_vtabstruct_6gevent_4ares_channel __pyx_vtable_6gevent_4ares_channel; + +static PyObject *__pyx_tp_new_6gevent_4ares_channel(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct PyGeventAresChannelObject *p; + PyObject *o; + if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + p = ((struct PyGeventAresChannelObject *)o); + p->__pyx_vtab = __pyx_vtabptr_6gevent_4ares_channel; + p->loop = Py_None; Py_INCREF(Py_None); + p->_watchers = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->_timer = Py_None; Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_6gevent_4ares_channel(PyObject *o) { + struct PyGeventAresChannelObject *p = (struct PyGeventAresChannelObject *)o; + #if PY_VERSION_HEX >= 0x030400a1 + if (unlikely(Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + PyObject_GC_UnTrack(o); + { + PyObject *etype, *eval, *etb; + PyErr_Fetch(&etype, &eval, &etb); + ++Py_REFCNT(o); + __pyx_pw_6gevent_4ares_7channel_7__dealloc__(o); + --Py_REFCNT(o); + PyErr_Restore(etype, eval, etb); + } + Py_CLEAR(p->loop); + Py_CLEAR(p->_watchers); + Py_CLEAR(p->_timer); + (*Py_TYPE(o)->tp_free)(o); +} + +static int __pyx_tp_traverse_6gevent_4ares_channel(PyObject *o, visitproc v, void *a) { + int e; + struct PyGeventAresChannelObject *p = (struct PyGeventAresChannelObject *)o; + if (p->loop) { + e = (*v)(p->loop, a); if (e) return e; + } + if (p->_watchers) { + e = (*v)(p->_watchers, a); if (e) return e; + } + if (p->_timer) { + e = (*v)(p->_timer, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_6gevent_4ares_channel(PyObject *o) { + PyObject* tmp; + struct PyGeventAresChannelObject *p = (struct PyGeventAresChannelObject *)o; + tmp = ((PyObject*)p->loop); + p->loop = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_watchers); + p->_watchers = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_timer); + p->_timer = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_6gevent_4ares_7channel_loop(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_4ares_7channel_4loop_1__get__(o); +} + +static int __pyx_setprop_6gevent_4ares_7channel_loop(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_4ares_7channel_4loop_3__set__(o, v); + } + else { + return __pyx_pw_6gevent_4ares_7channel_4loop_5__del__(o); + } +} + +static PyObject *__pyx_getprop_6gevent_4ares_7channel__watchers(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_4ares_7channel_9_watchers_1__get__(o); +} + +static int __pyx_setprop_6gevent_4ares_7channel__watchers(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_4ares_7channel_9_watchers_3__set__(o, v); + } + else { + return __pyx_pw_6gevent_4ares_7channel_9_watchers_5__del__(o); + } +} + +static PyObject *__pyx_getprop_6gevent_4ares_7channel__timer(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_4ares_7channel_6_timer_1__get__(o); +} + +static int __pyx_setprop_6gevent_4ares_7channel__timer(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_4ares_7channel_6_timer_3__set__(o, v); + } + else { + return __pyx_pw_6gevent_4ares_7channel_6_timer_5__del__(o); + } +} + +static PyMethodDef __pyx_methods_6gevent_4ares_channel[] = { + {"destroy", (PyCFunction)__pyx_pw_6gevent_4ares_7channel_5destroy, METH_NOARGS, 0}, + {"set_servers", (PyCFunction)__pyx_pw_6gevent_4ares_7channel_9set_servers, METH_VARARGS|METH_KEYWORDS, 0}, + {"_on_timer", (PyCFunction)__pyx_pw_6gevent_4ares_7channel_11_on_timer, METH_NOARGS, 0}, + {"_process_fd", (PyCFunction)__pyx_pw_6gevent_4ares_7channel_13_process_fd, METH_VARARGS|METH_KEYWORDS, 0}, + {"gethostbyname", (PyCFunction)__pyx_pw_6gevent_4ares_7channel_15gethostbyname, METH_VARARGS|METH_KEYWORDS, 0}, + {"gethostbyaddr", (PyCFunction)__pyx_pw_6gevent_4ares_7channel_17gethostbyaddr, METH_VARARGS|METH_KEYWORDS, 0}, + {"_getnameinfo", (PyCFunction)__pyx_pw_6gevent_4ares_7channel_19_getnameinfo, METH_VARARGS|METH_KEYWORDS, 0}, + {"getnameinfo", (PyCFunction)__pyx_pw_6gevent_4ares_7channel_21getnameinfo, METH_VARARGS|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_6gevent_4ares_channel[] = { + {(char *)"loop", __pyx_getprop_6gevent_4ares_7channel_loop, __pyx_setprop_6gevent_4ares_7channel_loop, (char *)0, 0}, + {(char *)"_watchers", __pyx_getprop_6gevent_4ares_7channel__watchers, __pyx_setprop_6gevent_4ares_7channel__watchers, (char *)0, 0}, + {(char *)"_timer", __pyx_getprop_6gevent_4ares_7channel__timer, __pyx_setprop_6gevent_4ares_7channel__timer, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; + +DL_EXPORT(PyTypeObject) PyGeventAresChannel_Type = { + PyVarObject_HEAD_INIT(0, 0) + "gevent.ares.channel", /*tp_name*/ + sizeof(struct PyGeventAresChannelObject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_6gevent_4ares_channel, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + __pyx_pw_6gevent_4ares_7channel_3__repr__, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_6gevent_4ares_channel, /*tp_traverse*/ + __pyx_tp_clear_6gevent_4ares_channel, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_6gevent_4ares_channel, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_6gevent_4ares_channel, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + __pyx_pw_6gevent_4ares_7channel_1__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_6gevent_4ares_channel, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; + +static PyMethodDef __pyx_methods[] = { + {"_convert_cares_flags", (PyCFunction)__pyx_pw_6gevent_4ares_1_convert_cares_flags, METH_VARARGS|METH_KEYWORDS, 0}, + {"strerror", (PyCFunction)__pyx_pw_6gevent_4ares_3strerror, METH_O, 0}, + {0, 0, 0, 0} +}; + +#if PY_MAJOR_VERSION >= 3 +static struct PyModuleDef __pyx_moduledef = { + #if PY_VERSION_HEX < 0x03020000 + { PyObject_HEAD_INIT(NULL) NULL, 0, NULL }, + #else + PyModuleDef_HEAD_INIT, + #endif + "ares", + 0, /* m_doc */ + -1, /* m_size */ + __pyx_methods /* m_methods */, + NULL, /* m_reload */ + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ +}; +#endif + +static __Pyx_StringTabEntry __pyx_string_tab[] = { + {&__pyx_n_s_ARES_EADDRGETNETWORKPARAMS, __pyx_k_ARES_EADDRGETNETWORKPARAMS, sizeof(__pyx_k_ARES_EADDRGETNETWORKPARAMS), 0, 0, 1, 1}, + {&__pyx_n_s_ARES_EBADFAMILY, __pyx_k_ARES_EBADFAMILY, sizeof(__pyx_k_ARES_EBADFAMILY), 0, 0, 1, 1}, + {&__pyx_n_s_ARES_EBADFLAGS, __pyx_k_ARES_EBADFLAGS, sizeof(__pyx_k_ARES_EBADFLAGS), 0, 0, 1, 1}, + {&__pyx_n_s_ARES_EBADHINTS, __pyx_k_ARES_EBADHINTS, sizeof(__pyx_k_ARES_EBADHINTS), 0, 0, 1, 1}, + {&__pyx_n_s_ARES_EBADNAME, __pyx_k_ARES_EBADNAME, sizeof(__pyx_k_ARES_EBADNAME), 0, 0, 1, 1}, + {&__pyx_n_s_ARES_EBADQUERY, __pyx_k_ARES_EBADQUERY, sizeof(__pyx_k_ARES_EBADQUERY), 0, 0, 1, 1}, + {&__pyx_n_s_ARES_EBADRESP, __pyx_k_ARES_EBADRESP, sizeof(__pyx_k_ARES_EBADRESP), 0, 0, 1, 1}, + {&__pyx_n_s_ARES_EBADSTR, __pyx_k_ARES_EBADSTR, sizeof(__pyx_k_ARES_EBADSTR), 0, 0, 1, 1}, + {&__pyx_n_s_ARES_ECANCELLED, __pyx_k_ARES_ECANCELLED, sizeof(__pyx_k_ARES_ECANCELLED), 0, 0, 1, 1}, + {&__pyx_n_s_ARES_ECONNREFUSED, __pyx_k_ARES_ECONNREFUSED, sizeof(__pyx_k_ARES_ECONNREFUSED), 0, 0, 1, 1}, + {&__pyx_n_s_ARES_EDESTRUCTION, __pyx_k_ARES_EDESTRUCTION, sizeof(__pyx_k_ARES_EDESTRUCTION), 0, 0, 1, 1}, + {&__pyx_n_s_ARES_EFILE, __pyx_k_ARES_EFILE, sizeof(__pyx_k_ARES_EFILE), 0, 0, 1, 1}, + {&__pyx_n_s_ARES_EFORMERR, __pyx_k_ARES_EFORMERR, sizeof(__pyx_k_ARES_EFORMERR), 0, 0, 1, 1}, + {&__pyx_n_s_ARES_ELOADIPHLPAPI, __pyx_k_ARES_ELOADIPHLPAPI, sizeof(__pyx_k_ARES_ELOADIPHLPAPI), 0, 0, 1, 1}, + {&__pyx_n_s_ARES_ENODATA, __pyx_k_ARES_ENODATA, sizeof(__pyx_k_ARES_ENODATA), 0, 0, 1, 1}, + {&__pyx_n_s_ARES_ENOMEM, __pyx_k_ARES_ENOMEM, sizeof(__pyx_k_ARES_ENOMEM), 0, 0, 1, 1}, + {&__pyx_n_s_ARES_ENONAME, __pyx_k_ARES_ENONAME, sizeof(__pyx_k_ARES_ENONAME), 0, 0, 1, 1}, + {&__pyx_n_s_ARES_ENOTFOUND, __pyx_k_ARES_ENOTFOUND, sizeof(__pyx_k_ARES_ENOTFOUND), 0, 0, 1, 1}, + {&__pyx_n_s_ARES_ENOTIMP, __pyx_k_ARES_ENOTIMP, sizeof(__pyx_k_ARES_ENOTIMP), 0, 0, 1, 1}, + {&__pyx_n_s_ARES_ENOTINITIALIZED, __pyx_k_ARES_ENOTINITIALIZED, sizeof(__pyx_k_ARES_ENOTINITIALIZED), 0, 0, 1, 1}, + {&__pyx_n_s_ARES_EOF, __pyx_k_ARES_EOF, sizeof(__pyx_k_ARES_EOF), 0, 0, 1, 1}, + {&__pyx_n_s_ARES_EREFUSED, __pyx_k_ARES_EREFUSED, sizeof(__pyx_k_ARES_EREFUSED), 0, 0, 1, 1}, + {&__pyx_n_s_ARES_ESERVFAIL, __pyx_k_ARES_ESERVFAIL, sizeof(__pyx_k_ARES_ESERVFAIL), 0, 0, 1, 1}, + {&__pyx_n_s_ARES_ETIMEOUT, __pyx_k_ARES_ETIMEOUT, sizeof(__pyx_k_ARES_ETIMEOUT), 0, 0, 1, 1}, + {&__pyx_n_s_ARES_FLAG_IGNTC, __pyx_k_ARES_FLAG_IGNTC, sizeof(__pyx_k_ARES_FLAG_IGNTC), 0, 0, 1, 1}, + {&__pyx_n_s_ARES_FLAG_NOALIASES, __pyx_k_ARES_FLAG_NOALIASES, sizeof(__pyx_k_ARES_FLAG_NOALIASES), 0, 0, 1, 1}, + {&__pyx_n_s_ARES_FLAG_NOCHECKRESP, __pyx_k_ARES_FLAG_NOCHECKRESP, sizeof(__pyx_k_ARES_FLAG_NOCHECKRESP), 0, 0, 1, 1}, + {&__pyx_n_s_ARES_FLAG_NORECURSE, __pyx_k_ARES_FLAG_NORECURSE, sizeof(__pyx_k_ARES_FLAG_NORECURSE), 0, 0, 1, 1}, + {&__pyx_n_s_ARES_FLAG_NOSEARCH, __pyx_k_ARES_FLAG_NOSEARCH, sizeof(__pyx_k_ARES_FLAG_NOSEARCH), 0, 0, 1, 1}, + {&__pyx_n_s_ARES_FLAG_PRIMARY, __pyx_k_ARES_FLAG_PRIMARY, sizeof(__pyx_k_ARES_FLAG_PRIMARY), 0, 0, 1, 1}, + {&__pyx_n_s_ARES_FLAG_STAYOPEN, __pyx_k_ARES_FLAG_STAYOPEN, sizeof(__pyx_k_ARES_FLAG_STAYOPEN), 0, 0, 1, 1}, + {&__pyx_n_s_ARES_FLAG_USEVC, __pyx_k_ARES_FLAG_USEVC, sizeof(__pyx_k_ARES_FLAG_USEVC), 0, 0, 1, 1}, + {&__pyx_n_s_ARES_SUCCESS, __pyx_k_ARES_SUCCESS, sizeof(__pyx_k_ARES_SUCCESS), 0, 0, 1, 1}, + {&__pyx_kp_s_Bad_value_for_ai_flags_0x_x, __pyx_k_Bad_value_for_ai_flags_0x_x, sizeof(__pyx_k_Bad_value_for_ai_flags_0x_x), 0, 0, 1, 0}, + {&__pyx_kp_s_C_projects_gevent_src_gevent_are, __pyx_k_C_projects_gevent_src_gevent_are, sizeof(__pyx_k_C_projects_gevent_src_gevent_are), 0, 0, 1, 0}, + {&__pyx_n_s_InvalidIP, __pyx_k_InvalidIP, sizeof(__pyx_k_InvalidIP), 0, 0, 1, 1}, + {&__pyx_kp_s_Invalid_value_for_port_r, __pyx_k_Invalid_value_for_port_r, sizeof(__pyx_k_Invalid_value_for_port_r), 0, 0, 1, 0}, + {&__pyx_n_s_MemoryError, __pyx_k_MemoryError, sizeof(__pyx_k_MemoryError), 0, 0, 1, 1}, + {&__pyx_n_s_NI_DGRAM, __pyx_k_NI_DGRAM, sizeof(__pyx_k_NI_DGRAM), 0, 0, 1, 1}, + {&__pyx_n_s_NI_NAMEREQD, __pyx_k_NI_NAMEREQD, sizeof(__pyx_k_NI_NAMEREQD), 0, 0, 1, 1}, + {&__pyx_n_s_NI_NOFQDN, __pyx_k_NI_NOFQDN, sizeof(__pyx_k_NI_NOFQDN), 0, 0, 1, 1}, + {&__pyx_n_s_NI_NUMERICHOST, __pyx_k_NI_NUMERICHOST, sizeof(__pyx_k_NI_NUMERICHOST), 0, 0, 1, 1}, + {&__pyx_n_s_NI_NUMERICSERV, __pyx_k_NI_NUMERICSERV, sizeof(__pyx_k_NI_NUMERICSERV), 0, 0, 1, 1}, + {&__pyx_n_s_TIMEOUT, __pyx_k_TIMEOUT, sizeof(__pyx_k_TIMEOUT), 0, 0, 1, 1}, + {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, + {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, + {&__pyx_kp_s__2, __pyx_k__2, sizeof(__pyx_k__2), 0, 0, 1, 0}, + {&__pyx_n_s_addr, __pyx_k_addr, sizeof(__pyx_k_addr), 0, 0, 1, 1}, + {&__pyx_n_s_again, __pyx_k_again, sizeof(__pyx_k_again), 0, 0, 1, 1}, + {&__pyx_n_s_all, __pyx_k_all, sizeof(__pyx_k_all), 0, 0, 1, 1}, + {&__pyx_n_s_ares_errors, __pyx_k_ares_errors, sizeof(__pyx_k_ares_errors), 0, 0, 1, 1}, + {&__pyx_n_s_ares_host_result, __pyx_k_ares_host_result, sizeof(__pyx_k_ares_host_result), 0, 0, 1, 1}, + {&__pyx_n_s_ares_host_result___getnewargs, __pyx_k_ares_host_result___getnewargs, sizeof(__pyx_k_ares_host_result___getnewargs), 0, 0, 1, 1}, + {&__pyx_n_s_ares_host_result___new, __pyx_k_ares_host_result___new, sizeof(__pyx_k_ares_host_result___new), 0, 0, 1, 1}, + {&__pyx_n_s_ascii, __pyx_k_ascii, sizeof(__pyx_k_ascii), 0, 0, 1, 1}, + {&__pyx_n_s_basestring, __pyx_k_basestring, sizeof(__pyx_k_basestring), 0, 0, 1, 1}, + {&__pyx_n_s_builtins, __pyx_k_builtins, sizeof(__pyx_k_builtins), 0, 0, 1, 1}, + {&__pyx_n_s_callback, __pyx_k_callback, sizeof(__pyx_k_callback), 0, 0, 1, 1}, + {&__pyx_n_s_cares_flag_map, __pyx_k_cares_flag_map, sizeof(__pyx_k_cares_flag_map), 0, 0, 1, 1}, + {&__pyx_n_s_channel, __pyx_k_channel, sizeof(__pyx_k_channel), 0, 0, 1, 1}, + {&__pyx_n_s_class, __pyx_k_class, sizeof(__pyx_k_class), 0, 0, 1, 1}, + {&__pyx_n_s_cls, __pyx_k_cls, sizeof(__pyx_k_cls), 0, 0, 1, 1}, + {&__pyx_n_s_default, __pyx_k_default, sizeof(__pyx_k_default), 0, 0, 1, 1}, + {&__pyx_n_s_destroy, __pyx_k_destroy, sizeof(__pyx_k_destroy), 0, 0, 1, 1}, + {&__pyx_n_s_doc, __pyx_k_doc, sizeof(__pyx_k_doc), 0, 0, 1, 1}, + {&__pyx_n_s_encode, __pyx_k_encode, sizeof(__pyx_k_encode), 0, 0, 1, 1}, + {&__pyx_n_s_events, __pyx_k_events, sizeof(__pyx_k_events), 0, 0, 1, 1}, + {&__pyx_n_s_exc_info, __pyx_k_exc_info, sizeof(__pyx_k_exc_info), 0, 0, 1, 1}, + {&__pyx_n_s_exception, __pyx_k_exception, sizeof(__pyx_k_exception), 0, 0, 1, 1}, + {&__pyx_kp_s_expected_a_tuple_got_r, __pyx_k_expected_a_tuple_got_r, sizeof(__pyx_k_expected_a_tuple_got_r), 0, 0, 1, 0}, + {&__pyx_n_s_family, __pyx_k_family, sizeof(__pyx_k_family), 0, 0, 1, 1}, + {&__pyx_n_s_fd, __pyx_k_fd, sizeof(__pyx_k_fd), 0, 0, 1, 1}, + {&__pyx_n_s_flags, __pyx_k_flags, sizeof(__pyx_k_flags), 0, 0, 1, 1}, + {&__pyx_n_s_gaierror, __pyx_k_gaierror, sizeof(__pyx_k_gaierror), 0, 0, 1, 1}, + {&__pyx_n_s_get, __pyx_k_get, sizeof(__pyx_k_get), 0, 0, 1, 1}, + {&__pyx_n_s_getnameinfo, __pyx_k_getnameinfo, sizeof(__pyx_k_getnameinfo), 0, 0, 1, 1}, + {&__pyx_n_s_getnewargs, __pyx_k_getnewargs, sizeof(__pyx_k_getnewargs), 0, 0, 1, 1}, + {&__pyx_n_s_gevent_ares, __pyx_k_gevent_ares, sizeof(__pyx_k_gevent_ares), 0, 0, 1, 1}, + {&__pyx_n_s_handle_error, __pyx_k_handle_error, sizeof(__pyx_k_handle_error), 0, 0, 1, 1}, + {&__pyx_n_s_id, __pyx_k_id, sizeof(__pyx_k_id), 0, 0, 1, 1}, + {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, + {&__pyx_n_s_io, __pyx_k_io, sizeof(__pyx_k_io), 0, 0, 1, 1}, + {&__pyx_n_s_iterable, __pyx_k_iterable, sizeof(__pyx_k_iterable), 0, 0, 1, 1}, + {&__pyx_n_s_loop, __pyx_k_loop, sizeof(__pyx_k_loop), 0, 0, 1, 1}, + {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, + {&__pyx_n_s_metaclass, __pyx_k_metaclass, sizeof(__pyx_k_metaclass), 0, 0, 1, 1}, + {&__pyx_n_s_module, __pyx_k_module, sizeof(__pyx_k_module), 0, 0, 1, 1}, + {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, + {&__pyx_n_s_name_2, __pyx_k_name_2, sizeof(__pyx_k_name_2), 0, 0, 1, 1}, + {&__pyx_n_s_ndots, __pyx_k_ndots, sizeof(__pyx_k_ndots), 0, 0, 1, 1}, + {&__pyx_n_s_new, __pyx_k_new, sizeof(__pyx_k_new), 0, 0, 1, 1}, + {&__pyx_n_s_on_timer, __pyx_k_on_timer, sizeof(__pyx_k_on_timer), 0, 0, 1, 1}, + {&__pyx_n_s_pass_events, __pyx_k_pass_events, sizeof(__pyx_k_pass_events), 0, 0, 1, 1}, + {&__pyx_n_s_pop, __pyx_k_pop, sizeof(__pyx_k_pop), 0, 0, 1, 1}, + {&__pyx_n_s_prepare, __pyx_k_prepare, sizeof(__pyx_k_prepare), 0, 0, 1, 1}, + {&__pyx_n_s_process_fd, __pyx_k_process_fd, sizeof(__pyx_k_process_fd), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_vtable, __pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 0, 1, 1}, + {&__pyx_n_s_qualname, __pyx_k_qualname, sizeof(__pyx_k_qualname), 0, 0, 1, 1}, + {&__pyx_kp_s_s_at_0x_x__timer_r__watchers_s, __pyx_k_s_at_0x_x__timer_r__watchers_s, sizeof(__pyx_k_s_at_0x_x__timer_r__watchers_s), 0, 0, 1, 0}, + {&__pyx_kp_s_s_exception_r, __pyx_k_s_exception_r, sizeof(__pyx_k_s_exception_r), 0, 0, 1, 0}, + {&__pyx_kp_s_s_r, __pyx_k_s_r, sizeof(__pyx_k_s_r), 0, 0, 1, 0}, + {&__pyx_kp_s_s_s, __pyx_k_s_s, sizeof(__pyx_k_s_s), 0, 0, 1, 0}, + {&__pyx_kp_s_s_value_r_exception_r, __pyx_k_s_value_r_exception_r, sizeof(__pyx_k_s_value_r_exception_r), 0, 0, 1, 0}, + {&__pyx_n_s_self, __pyx_k_self, sizeof(__pyx_k_self), 0, 0, 1, 1}, + {&__pyx_n_s_servers, __pyx_k_servers, sizeof(__pyx_k_servers), 0, 0, 1, 1}, + {&__pyx_n_s_set_servers, __pyx_k_set_servers, sizeof(__pyx_k_set_servers), 0, 0, 1, 1}, + {&__pyx_n_s_sockaddr, __pyx_k_sockaddr, sizeof(__pyx_k_sockaddr), 0, 0, 1, 1}, + {&__pyx_n_s_socket, __pyx_k_socket, sizeof(__pyx_k_socket), 0, 0, 1, 1}, + {&__pyx_n_s_split, __pyx_k_split, sizeof(__pyx_k_split), 0, 0, 1, 1}, + {&__pyx_n_s_start, __pyx_k_start, sizeof(__pyx_k_start), 0, 0, 1, 1}, + {&__pyx_n_s_stop, __pyx_k_stop, sizeof(__pyx_k_stop), 0, 0, 1, 1}, + {&__pyx_n_s_sys, __pyx_k_sys, sizeof(__pyx_k_sys), 0, 0, 1, 1}, + {&__pyx_n_s_tcp_port, __pyx_k_tcp_port, sizeof(__pyx_k_tcp_port), 0, 0, 1, 1}, + {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, + {&__pyx_kp_s_this_ares_channel_has_been_destr, __pyx_k_this_ares_channel_has_been_destr, sizeof(__pyx_k_this_ares_channel_has_been_destr), 0, 0, 1, 0}, + {&__pyx_n_s_timeout, __pyx_k_timeout, sizeof(__pyx_k_timeout), 0, 0, 1, 1}, + {&__pyx_n_s_timer, __pyx_k_timer, sizeof(__pyx_k_timer), 0, 0, 1, 1}, + {&__pyx_n_s_tries, __pyx_k_tries, sizeof(__pyx_k_tries), 0, 0, 1, 1}, + {&__pyx_n_s_udp_port, __pyx_k_udp_port, sizeof(__pyx_k_udp_port), 0, 0, 1, 1}, + {&__pyx_n_s_unicode, __pyx_k_unicode, sizeof(__pyx_k_unicode), 0, 0, 1, 1}, + {&__pyx_n_s_value, __pyx_k_value, sizeof(__pyx_k_value), 0, 0, 1, 1}, + {&__pyx_n_s_version_info, __pyx_k_version_info, sizeof(__pyx_k_version_info), 0, 0, 1, 1}, + {&__pyx_n_s_watcher, __pyx_k_watcher, sizeof(__pyx_k_watcher), 0, 0, 1, 1}, + {0, 0, 0, 0, 0, 0, 0} +}; +static int __Pyx_InitCachedBuiltins(void) { + __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(0, 153, __pyx_L1_error) + __pyx_builtin_id = __Pyx_GetBuiltinName(__pyx_n_s_id); if (!__pyx_builtin_id) __PYX_ERR(0, 296, __pyx_L1_error) + __pyx_builtin_MemoryError = __Pyx_GetBuiltinName(__pyx_n_s_MemoryError); if (!__pyx_builtin_MemoryError) __PYX_ERR(0, 330, __pyx_L1_error) + __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(0, 436, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} + +static int __Pyx_InitCachedConstants(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); + + /* "gevent/ares.pyx":320 + * servers = [] + * if isinstance(servers, string_types): + * servers = servers.split(',') # <<<<<<<<<<<<<< + * cdef int length = len(servers) + * cdef int result, index + */ + __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_s__2); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 320, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__3); + __Pyx_GIVEREF(__pyx_tuple__3); + + /* "gevent/ares.pyx":335 + * for server in servers: + * if isinstance(server, unicode): + * server = server.encode('ascii') # <<<<<<<<<<<<<< + * string = server + * if cares.ares_inet_pton(AF_INET, string, &c_servers[index].addr) > 0: + */ + __pyx_tuple__4 = PyTuple_Pack(1, __pyx_n_s_ascii); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 335, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__4); + __Pyx_GIVEREF(__pyx_tuple__4); + + /* "gevent/ares.pyx":192 + * class ares_host_result(tuple): + * + * def __new__(cls, family, iterable): # <<<<<<<<<<<<<< + * cdef object self = tuple.__new__(cls, iterable) + * self.family = family + */ + __pyx_tuple__6 = PyTuple_Pack(4, __pyx_n_s_cls, __pyx_n_s_family, __pyx_n_s_iterable, __pyx_n_s_self); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 192, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__6); + __Pyx_GIVEREF(__pyx_tuple__6); + __pyx_codeobj__7 = (PyObject*)__Pyx_PyCode_New(3, 0, 4, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__6, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_projects_gevent_src_gevent_are, __pyx_n_s_new, 192, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__7)) __PYX_ERR(0, 192, __pyx_L1_error) + + /* "gevent/ares.pyx":197 + * return self + * + * def __getnewargs__(self): # <<<<<<<<<<<<<< + * return (self.family, tuple(self)) + * + */ + __pyx_tuple__8 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(0, 197, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__8); + __Pyx_GIVEREF(__pyx_tuple__8); + __pyx_codeobj__9 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__8, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_projects_gevent_src_gevent_are, __pyx_n_s_getnewargs, 197, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__9)) __PYX_ERR(0, 197, __pyx_L1_error) + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_InitGlobals(void) { + if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); + __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_2 = PyInt_FromLong(2); if (unlikely(!__pyx_int_2)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_3 = PyInt_FromLong(3); if (unlikely(!__pyx_int_3)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_4 = PyInt_FromLong(4); if (unlikely(!__pyx_int_4)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_8 = PyInt_FromLong(8); if (unlikely(!__pyx_int_8)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_16 = PyInt_FromLong(16); if (unlikely(!__pyx_int_16)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_neg_1 = PyInt_FromLong(-1); if (unlikely(!__pyx_int_neg_1)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_neg_8 = PyInt_FromLong(-8); if (unlikely(!__pyx_int_neg_8)) __PYX_ERR(0, 1, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} + +#if PY_MAJOR_VERSION < 3 +PyMODINIT_FUNC initares(void); /*proto*/ +PyMODINIT_FUNC initares(void) +#else +PyMODINIT_FUNC PyInit_ares(void); /*proto*/ +PyMODINIT_FUNC PyInit_ares(void) +#endif +{ + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11 = NULL; + PyObject *__pyx_t_12 = NULL; + PyObject *__pyx_t_13 = NULL; + PyObject *__pyx_t_14 = NULL; + PyObject *__pyx_t_15 = NULL; + PyObject *__pyx_t_16 = NULL; + PyObject *__pyx_t_17 = NULL; + PyObject *__pyx_t_18 = NULL; + PyObject *__pyx_t_19 = NULL; + PyObject *__pyx_t_20 = NULL; + PyObject *__pyx_t_21 = NULL; + PyObject *__pyx_t_22 = NULL; + PyObject *__pyx_t_23 = NULL; + PyObject *__pyx_t_24 = NULL; + PyObject *__pyx_t_25 = NULL; + PyObject *__pyx_t_26 = NULL; + PyObject *__pyx_t_27 = NULL; + __Pyx_RefNannyDeclarations + #if CYTHON_REFNANNY + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); + if (!__Pyx_RefNanny) { + PyErr_Clear(); + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); + if (!__Pyx_RefNanny) + Py_FatalError("failed to import 'refnanny' module"); + } + #endif + __Pyx_RefNannySetupContext("PyMODINIT_FUNC PyInit_ares(void)", 0); + if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) + #ifdef __Pyx_CyFunction_USED + if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_FusedFunction_USED + if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Coroutine_USED + if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Generator_USED + if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_StopAsyncIteration_USED + if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + /*--- Library function declarations ---*/ + /*--- Threads initialization code ---*/ + #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS + #ifdef WITH_THREAD /* Python build with threading support? */ + PyEval_InitThreads(); + #endif + #endif + /*--- Module creation code ---*/ + #if PY_MAJOR_VERSION < 3 + __pyx_m = Py_InitModule4("ares", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); + #else + __pyx_m = PyModule_Create(&__pyx_moduledef); + #endif + if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_d); + __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) + #if CYTHON_COMPILING_IN_PYPY + Py_INCREF(__pyx_b); + #endif + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error); + /*--- Initialize various global constants etc. ---*/ + if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) + if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + if (__pyx_module_is_main_gevent__ares) { + if (PyObject_SetAttrString(__pyx_m, "__name__", __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + } + #if PY_MAJOR_VERSION >= 3 + { + PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) + if (!PyDict_GetItemString(modules, "gevent.ares")) { + if (unlikely(PyDict_SetItemString(modules, "gevent.ares", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + } + } + #endif + /*--- Builtin init code ---*/ + if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Constants init code ---*/ + if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Global init code ---*/ + __pyx_v_6gevent_4ares_string_types = Py_None; Py_INCREF(Py_None); + __pyx_v_6gevent_4ares_text_type = Py_None; Py_INCREF(Py_None); + /*--- Variable export code ---*/ + /*--- Function export code ---*/ + /*--- Type init code ---*/ + if (PyType_Ready(&__pyx_type_6gevent_4ares_result) < 0) __PYX_ERR(0, 164, __pyx_L1_error) + __pyx_type_6gevent_4ares_result.tp_print = 0; + if (PyObject_SetAttrString(__pyx_m, "result", (PyObject *)&__pyx_type_6gevent_4ares_result) < 0) __PYX_ERR(0, 164, __pyx_L1_error) + __pyx_ptype_6gevent_4ares_result = &__pyx_type_6gevent_4ares_result; + __pyx_vtabptr_6gevent_4ares_channel = &__pyx_vtable_6gevent_4ares_channel; + __pyx_vtable_6gevent_4ares_channel._sock_state_callback = (PyObject *(*)(struct PyGeventAresChannelObject *, int, int, int))__pyx_f_6gevent_4ares_7channel__sock_state_callback; + __pyx_vtable_6gevent_4ares_channel._getnameinfo = (PyObject *(*)(struct PyGeventAresChannelObject *, PyObject *, PyObject *, int, int __pyx_skip_dispatch))__pyx_f_6gevent_4ares_7channel__getnameinfo; + if (PyType_Ready(&PyGeventAresChannel_Type) < 0) __PYX_ERR(0, 245, __pyx_L1_error) + PyGeventAresChannel_Type.tp_print = 0; + if (__Pyx_SetVtable(PyGeventAresChannel_Type.tp_dict, __pyx_vtabptr_6gevent_4ares_channel) < 0) __PYX_ERR(0, 245, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "channel", (PyObject *)&PyGeventAresChannel_Type) < 0) __PYX_ERR(0, 245, __pyx_L1_error) + __pyx_ptype_6gevent_4ares_channel = &PyGeventAresChannel_Type; + /*--- Type import code ---*/ + /*--- Variable import code ---*/ + /*--- Function import code ---*/ + /*--- Execution code ---*/ + #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) + if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + + /* "gevent/ares.pyx":3 + * # Copyright (c) 2011-2012 Denis Bilenko. See LICENSE for details. + * cimport cares + * import sys # <<<<<<<<<<<<<< + * from python cimport * + * from _socket import gaierror + */ + __pyx_t_1 = __Pyx_Import(__pyx_n_s_sys, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_sys, __pyx_t_1) < 0) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "gevent/ares.pyx":5 + * import sys + * from python cimport * + * from _socket import gaierror # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_gaierror); + __Pyx_GIVEREF(__pyx_n_s_gaierror); + PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_gaierror); + __pyx_t_2 = __Pyx_Import(__pyx_n_s_socket, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_gaierror); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_gaierror, __pyx_t_1) < 0) __PYX_ERR(0, 5, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "gevent/ares.pyx":8 + * + * + * __all__ = ['channel'] # <<<<<<<<<<<<<< + * + * cdef object string_types + */ + __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_n_s_channel); + __Pyx_GIVEREF(__pyx_n_s_channel); + PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_channel); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_all, __pyx_t_2) < 0) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "gevent/ares.pyx":13 + * cdef object text_type + * + * if sys.version_info[0] >= 3: # <<<<<<<<<<<<<< + * string_types = str, + * text_type = str + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_sys); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_version_info); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyObject_RichCompare(__pyx_t_2, __pyx_int_3, Py_GE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 13, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 13, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_3) { + + /* "gevent/ares.pyx":14 + * + * if sys.version_info[0] >= 3: + * string_types = str, # <<<<<<<<<<<<<< + * text_type = str + * else: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)(&PyString_Type))); + __Pyx_GIVEREF(((PyObject *)(&PyString_Type))); + PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)(&PyString_Type))); + __Pyx_XGOTREF(__pyx_v_6gevent_4ares_string_types); + __Pyx_DECREF_SET(__pyx_v_6gevent_4ares_string_types, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __pyx_t_1 = 0; + + /* "gevent/ares.pyx":15 + * if sys.version_info[0] >= 3: + * string_types = str, + * text_type = str # <<<<<<<<<<<<<< + * else: + * string_types = __builtins__.basestring, + */ + __Pyx_INCREF(((PyObject *)(&PyString_Type))); + __Pyx_XGOTREF(__pyx_v_6gevent_4ares_text_type); + __Pyx_DECREF_SET(__pyx_v_6gevent_4ares_text_type, ((PyObject *)(&PyString_Type))); + __Pyx_GIVEREF(((PyObject *)(&PyString_Type))); + + /* "gevent/ares.pyx":13 + * cdef object text_type + * + * if sys.version_info[0] >= 3: # <<<<<<<<<<<<<< + * string_types = str, + * text_type = str + */ + goto __pyx_L2; + } + + /* "gevent/ares.pyx":17 + * text_type = str + * else: + * string_types = __builtins__.basestring, # <<<<<<<<<<<<<< + * text_type = __builtins__.unicode + * + */ + /*else*/ { + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_builtins); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_basestring); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); + __pyx_t_2 = 0; + __Pyx_XGOTREF(__pyx_v_6gevent_4ares_string_types); + __Pyx_DECREF_SET(__pyx_v_6gevent_4ares_string_types, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __pyx_t_1 = 0; + + /* "gevent/ares.pyx":18 + * else: + * string_types = __builtins__.basestring, + * text_type = __builtins__.unicode # <<<<<<<<<<<<<< + * + * TIMEOUT = 1 + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_builtins); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 18, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 18, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XGOTREF(__pyx_v_6gevent_4ares_text_type); + __Pyx_DECREF_SET(__pyx_v_6gevent_4ares_text_type, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __pyx_t_2 = 0; + } + __pyx_L2:; + + /* "gevent/ares.pyx":20 + * text_type = __builtins__.unicode + * + * TIMEOUT = 1 # <<<<<<<<<<<<<< + * + * DEF EV_READ = 1 + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_TIMEOUT, __pyx_int_1) < 0) __PYX_ERR(0, 20, __pyx_L1_error) + + /* "gevent/ares.pyx":58 + * + * + * ARES_SUCCESS = cares.ARES_SUCCESS # <<<<<<<<<<<<<< + * ARES_ENODATA = cares.ARES_ENODATA + * ARES_EFORMERR = cares.ARES_EFORMERR + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_SUCCESS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 58, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARES_SUCCESS, __pyx_t_2) < 0) __PYX_ERR(0, 58, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "gevent/ares.pyx":59 + * + * ARES_SUCCESS = cares.ARES_SUCCESS + * ARES_ENODATA = cares.ARES_ENODATA # <<<<<<<<<<<<<< + * ARES_EFORMERR = cares.ARES_EFORMERR + * ARES_ESERVFAIL = cares.ARES_ESERVFAIL + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_ENODATA); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 59, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARES_ENODATA, __pyx_t_2) < 0) __PYX_ERR(0, 59, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "gevent/ares.pyx":60 + * ARES_SUCCESS = cares.ARES_SUCCESS + * ARES_ENODATA = cares.ARES_ENODATA + * ARES_EFORMERR = cares.ARES_EFORMERR # <<<<<<<<<<<<<< + * ARES_ESERVFAIL = cares.ARES_ESERVFAIL + * ARES_ENOTFOUND = cares.ARES_ENOTFOUND + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_EFORMERR); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 60, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARES_EFORMERR, __pyx_t_2) < 0) __PYX_ERR(0, 60, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "gevent/ares.pyx":61 + * ARES_ENODATA = cares.ARES_ENODATA + * ARES_EFORMERR = cares.ARES_EFORMERR + * ARES_ESERVFAIL = cares.ARES_ESERVFAIL # <<<<<<<<<<<<<< + * ARES_ENOTFOUND = cares.ARES_ENOTFOUND + * ARES_ENOTIMP = cares.ARES_ENOTIMP + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_ESERVFAIL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 61, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARES_ESERVFAIL, __pyx_t_2) < 0) __PYX_ERR(0, 61, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "gevent/ares.pyx":62 + * ARES_EFORMERR = cares.ARES_EFORMERR + * ARES_ESERVFAIL = cares.ARES_ESERVFAIL + * ARES_ENOTFOUND = cares.ARES_ENOTFOUND # <<<<<<<<<<<<<< + * ARES_ENOTIMP = cares.ARES_ENOTIMP + * ARES_EREFUSED = cares.ARES_EREFUSED + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_ENOTFOUND); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 62, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARES_ENOTFOUND, __pyx_t_2) < 0) __PYX_ERR(0, 62, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "gevent/ares.pyx":63 + * ARES_ESERVFAIL = cares.ARES_ESERVFAIL + * ARES_ENOTFOUND = cares.ARES_ENOTFOUND + * ARES_ENOTIMP = cares.ARES_ENOTIMP # <<<<<<<<<<<<<< + * ARES_EREFUSED = cares.ARES_EREFUSED + * ARES_EBADQUERY = cares.ARES_EBADQUERY + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_ENOTIMP); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 63, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARES_ENOTIMP, __pyx_t_2) < 0) __PYX_ERR(0, 63, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "gevent/ares.pyx":64 + * ARES_ENOTFOUND = cares.ARES_ENOTFOUND + * ARES_ENOTIMP = cares.ARES_ENOTIMP + * ARES_EREFUSED = cares.ARES_EREFUSED # <<<<<<<<<<<<<< + * ARES_EBADQUERY = cares.ARES_EBADQUERY + * ARES_EBADNAME = cares.ARES_EBADNAME + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_EREFUSED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 64, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARES_EREFUSED, __pyx_t_2) < 0) __PYX_ERR(0, 64, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "gevent/ares.pyx":65 + * ARES_ENOTIMP = cares.ARES_ENOTIMP + * ARES_EREFUSED = cares.ARES_EREFUSED + * ARES_EBADQUERY = cares.ARES_EBADQUERY # <<<<<<<<<<<<<< + * ARES_EBADNAME = cares.ARES_EBADNAME + * ARES_EBADFAMILY = cares.ARES_EBADFAMILY + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_EBADQUERY); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 65, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARES_EBADQUERY, __pyx_t_2) < 0) __PYX_ERR(0, 65, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "gevent/ares.pyx":66 + * ARES_EREFUSED = cares.ARES_EREFUSED + * ARES_EBADQUERY = cares.ARES_EBADQUERY + * ARES_EBADNAME = cares.ARES_EBADNAME # <<<<<<<<<<<<<< + * ARES_EBADFAMILY = cares.ARES_EBADFAMILY + * ARES_EBADRESP = cares.ARES_EBADRESP + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_EBADNAME); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 66, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARES_EBADNAME, __pyx_t_2) < 0) __PYX_ERR(0, 66, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "gevent/ares.pyx":67 + * ARES_EBADQUERY = cares.ARES_EBADQUERY + * ARES_EBADNAME = cares.ARES_EBADNAME + * ARES_EBADFAMILY = cares.ARES_EBADFAMILY # <<<<<<<<<<<<<< + * ARES_EBADRESP = cares.ARES_EBADRESP + * ARES_ECONNREFUSED = cares.ARES_ECONNREFUSED + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_EBADFAMILY); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 67, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARES_EBADFAMILY, __pyx_t_2) < 0) __PYX_ERR(0, 67, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "gevent/ares.pyx":68 + * ARES_EBADNAME = cares.ARES_EBADNAME + * ARES_EBADFAMILY = cares.ARES_EBADFAMILY + * ARES_EBADRESP = cares.ARES_EBADRESP # <<<<<<<<<<<<<< + * ARES_ECONNREFUSED = cares.ARES_ECONNREFUSED + * ARES_ETIMEOUT = cares.ARES_ETIMEOUT + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_EBADRESP); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 68, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARES_EBADRESP, __pyx_t_2) < 0) __PYX_ERR(0, 68, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "gevent/ares.pyx":69 + * ARES_EBADFAMILY = cares.ARES_EBADFAMILY + * ARES_EBADRESP = cares.ARES_EBADRESP + * ARES_ECONNREFUSED = cares.ARES_ECONNREFUSED # <<<<<<<<<<<<<< + * ARES_ETIMEOUT = cares.ARES_ETIMEOUT + * ARES_EOF = cares.ARES_EOF + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_ECONNREFUSED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 69, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARES_ECONNREFUSED, __pyx_t_2) < 0) __PYX_ERR(0, 69, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "gevent/ares.pyx":70 + * ARES_EBADRESP = cares.ARES_EBADRESP + * ARES_ECONNREFUSED = cares.ARES_ECONNREFUSED + * ARES_ETIMEOUT = cares.ARES_ETIMEOUT # <<<<<<<<<<<<<< + * ARES_EOF = cares.ARES_EOF + * ARES_EFILE = cares.ARES_EFILE + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_ETIMEOUT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 70, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARES_ETIMEOUT, __pyx_t_2) < 0) __PYX_ERR(0, 70, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "gevent/ares.pyx":71 + * ARES_ECONNREFUSED = cares.ARES_ECONNREFUSED + * ARES_ETIMEOUT = cares.ARES_ETIMEOUT + * ARES_EOF = cares.ARES_EOF # <<<<<<<<<<<<<< + * ARES_EFILE = cares.ARES_EFILE + * ARES_ENOMEM = cares.ARES_ENOMEM + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_EOF); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 71, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARES_EOF, __pyx_t_2) < 0) __PYX_ERR(0, 71, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "gevent/ares.pyx":72 + * ARES_ETIMEOUT = cares.ARES_ETIMEOUT + * ARES_EOF = cares.ARES_EOF + * ARES_EFILE = cares.ARES_EFILE # <<<<<<<<<<<<<< + * ARES_ENOMEM = cares.ARES_ENOMEM + * ARES_EDESTRUCTION = cares.ARES_EDESTRUCTION + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_EFILE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 72, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARES_EFILE, __pyx_t_2) < 0) __PYX_ERR(0, 72, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "gevent/ares.pyx":73 + * ARES_EOF = cares.ARES_EOF + * ARES_EFILE = cares.ARES_EFILE + * ARES_ENOMEM = cares.ARES_ENOMEM # <<<<<<<<<<<<<< + * ARES_EDESTRUCTION = cares.ARES_EDESTRUCTION + * ARES_EBADSTR = cares.ARES_EBADSTR + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_ENOMEM); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 73, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARES_ENOMEM, __pyx_t_2) < 0) __PYX_ERR(0, 73, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "gevent/ares.pyx":74 + * ARES_EFILE = cares.ARES_EFILE + * ARES_ENOMEM = cares.ARES_ENOMEM + * ARES_EDESTRUCTION = cares.ARES_EDESTRUCTION # <<<<<<<<<<<<<< + * ARES_EBADSTR = cares.ARES_EBADSTR + * ARES_EBADFLAGS = cares.ARES_EBADFLAGS + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_EDESTRUCTION); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 74, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARES_EDESTRUCTION, __pyx_t_2) < 0) __PYX_ERR(0, 74, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "gevent/ares.pyx":75 + * ARES_ENOMEM = cares.ARES_ENOMEM + * ARES_EDESTRUCTION = cares.ARES_EDESTRUCTION + * ARES_EBADSTR = cares.ARES_EBADSTR # <<<<<<<<<<<<<< + * ARES_EBADFLAGS = cares.ARES_EBADFLAGS + * ARES_ENONAME = cares.ARES_ENONAME + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_EBADSTR); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 75, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARES_EBADSTR, __pyx_t_2) < 0) __PYX_ERR(0, 75, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "gevent/ares.pyx":76 + * ARES_EDESTRUCTION = cares.ARES_EDESTRUCTION + * ARES_EBADSTR = cares.ARES_EBADSTR + * ARES_EBADFLAGS = cares.ARES_EBADFLAGS # <<<<<<<<<<<<<< + * ARES_ENONAME = cares.ARES_ENONAME + * ARES_EBADHINTS = cares.ARES_EBADHINTS + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_EBADFLAGS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 76, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARES_EBADFLAGS, __pyx_t_2) < 0) __PYX_ERR(0, 76, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "gevent/ares.pyx":77 + * ARES_EBADSTR = cares.ARES_EBADSTR + * ARES_EBADFLAGS = cares.ARES_EBADFLAGS + * ARES_ENONAME = cares.ARES_ENONAME # <<<<<<<<<<<<<< + * ARES_EBADHINTS = cares.ARES_EBADHINTS + * ARES_ENOTINITIALIZED = cares.ARES_ENOTINITIALIZED + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_ENONAME); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 77, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARES_ENONAME, __pyx_t_2) < 0) __PYX_ERR(0, 77, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "gevent/ares.pyx":78 + * ARES_EBADFLAGS = cares.ARES_EBADFLAGS + * ARES_ENONAME = cares.ARES_ENONAME + * ARES_EBADHINTS = cares.ARES_EBADHINTS # <<<<<<<<<<<<<< + * ARES_ENOTINITIALIZED = cares.ARES_ENOTINITIALIZED + * ARES_ELOADIPHLPAPI = cares.ARES_ELOADIPHLPAPI + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_EBADHINTS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 78, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARES_EBADHINTS, __pyx_t_2) < 0) __PYX_ERR(0, 78, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "gevent/ares.pyx":79 + * ARES_ENONAME = cares.ARES_ENONAME + * ARES_EBADHINTS = cares.ARES_EBADHINTS + * ARES_ENOTINITIALIZED = cares.ARES_ENOTINITIALIZED # <<<<<<<<<<<<<< + * ARES_ELOADIPHLPAPI = cares.ARES_ELOADIPHLPAPI + * ARES_EADDRGETNETWORKPARAMS = cares.ARES_EADDRGETNETWORKPARAMS + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_ENOTINITIALIZED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 79, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARES_ENOTINITIALIZED, __pyx_t_2) < 0) __PYX_ERR(0, 79, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "gevent/ares.pyx":80 + * ARES_EBADHINTS = cares.ARES_EBADHINTS + * ARES_ENOTINITIALIZED = cares.ARES_ENOTINITIALIZED + * ARES_ELOADIPHLPAPI = cares.ARES_ELOADIPHLPAPI # <<<<<<<<<<<<<< + * ARES_EADDRGETNETWORKPARAMS = cares.ARES_EADDRGETNETWORKPARAMS + * ARES_ECANCELLED = cares.ARES_ECANCELLED + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_ELOADIPHLPAPI); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 80, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARES_ELOADIPHLPAPI, __pyx_t_2) < 0) __PYX_ERR(0, 80, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "gevent/ares.pyx":81 + * ARES_ENOTINITIALIZED = cares.ARES_ENOTINITIALIZED + * ARES_ELOADIPHLPAPI = cares.ARES_ELOADIPHLPAPI + * ARES_EADDRGETNETWORKPARAMS = cares.ARES_EADDRGETNETWORKPARAMS # <<<<<<<<<<<<<< + * ARES_ECANCELLED = cares.ARES_ECANCELLED + * + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_EADDRGETNETWORKPARAMS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 81, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARES_EADDRGETNETWORKPARAMS, __pyx_t_2) < 0) __PYX_ERR(0, 81, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "gevent/ares.pyx":82 + * ARES_ELOADIPHLPAPI = cares.ARES_ELOADIPHLPAPI + * ARES_EADDRGETNETWORKPARAMS = cares.ARES_EADDRGETNETWORKPARAMS + * ARES_ECANCELLED = cares.ARES_ECANCELLED # <<<<<<<<<<<<<< + * + * ARES_FLAG_USEVC = cares.ARES_FLAG_USEVC + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_ECANCELLED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 82, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARES_ECANCELLED, __pyx_t_2) < 0) __PYX_ERR(0, 82, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "gevent/ares.pyx":84 + * ARES_ECANCELLED = cares.ARES_ECANCELLED + * + * ARES_FLAG_USEVC = cares.ARES_FLAG_USEVC # <<<<<<<<<<<<<< + * ARES_FLAG_PRIMARY = cares.ARES_FLAG_PRIMARY + * ARES_FLAG_IGNTC = cares.ARES_FLAG_IGNTC + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_FLAG_USEVC); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 84, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARES_FLAG_USEVC, __pyx_t_2) < 0) __PYX_ERR(0, 84, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "gevent/ares.pyx":85 + * + * ARES_FLAG_USEVC = cares.ARES_FLAG_USEVC + * ARES_FLAG_PRIMARY = cares.ARES_FLAG_PRIMARY # <<<<<<<<<<<<<< + * ARES_FLAG_IGNTC = cares.ARES_FLAG_IGNTC + * ARES_FLAG_NORECURSE = cares.ARES_FLAG_NORECURSE + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_FLAG_PRIMARY); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 85, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARES_FLAG_PRIMARY, __pyx_t_2) < 0) __PYX_ERR(0, 85, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "gevent/ares.pyx":86 + * ARES_FLAG_USEVC = cares.ARES_FLAG_USEVC + * ARES_FLAG_PRIMARY = cares.ARES_FLAG_PRIMARY + * ARES_FLAG_IGNTC = cares.ARES_FLAG_IGNTC # <<<<<<<<<<<<<< + * ARES_FLAG_NORECURSE = cares.ARES_FLAG_NORECURSE + * ARES_FLAG_STAYOPEN = cares.ARES_FLAG_STAYOPEN + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_FLAG_IGNTC); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 86, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARES_FLAG_IGNTC, __pyx_t_2) < 0) __PYX_ERR(0, 86, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "gevent/ares.pyx":87 + * ARES_FLAG_PRIMARY = cares.ARES_FLAG_PRIMARY + * ARES_FLAG_IGNTC = cares.ARES_FLAG_IGNTC + * ARES_FLAG_NORECURSE = cares.ARES_FLAG_NORECURSE # <<<<<<<<<<<<<< + * ARES_FLAG_STAYOPEN = cares.ARES_FLAG_STAYOPEN + * ARES_FLAG_NOSEARCH = cares.ARES_FLAG_NOSEARCH + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_FLAG_NORECURSE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARES_FLAG_NORECURSE, __pyx_t_2) < 0) __PYX_ERR(0, 87, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "gevent/ares.pyx":88 + * ARES_FLAG_IGNTC = cares.ARES_FLAG_IGNTC + * ARES_FLAG_NORECURSE = cares.ARES_FLAG_NORECURSE + * ARES_FLAG_STAYOPEN = cares.ARES_FLAG_STAYOPEN # <<<<<<<<<<<<<< + * ARES_FLAG_NOSEARCH = cares.ARES_FLAG_NOSEARCH + * ARES_FLAG_NOALIASES = cares.ARES_FLAG_NOALIASES + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_FLAG_STAYOPEN); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 88, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARES_FLAG_STAYOPEN, __pyx_t_2) < 0) __PYX_ERR(0, 88, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "gevent/ares.pyx":89 + * ARES_FLAG_NORECURSE = cares.ARES_FLAG_NORECURSE + * ARES_FLAG_STAYOPEN = cares.ARES_FLAG_STAYOPEN + * ARES_FLAG_NOSEARCH = cares.ARES_FLAG_NOSEARCH # <<<<<<<<<<<<<< + * ARES_FLAG_NOALIASES = cares.ARES_FLAG_NOALIASES + * ARES_FLAG_NOCHECKRESP = cares.ARES_FLAG_NOCHECKRESP + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_FLAG_NOSEARCH); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 89, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARES_FLAG_NOSEARCH, __pyx_t_2) < 0) __PYX_ERR(0, 89, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "gevent/ares.pyx":90 + * ARES_FLAG_STAYOPEN = cares.ARES_FLAG_STAYOPEN + * ARES_FLAG_NOSEARCH = cares.ARES_FLAG_NOSEARCH + * ARES_FLAG_NOALIASES = cares.ARES_FLAG_NOALIASES # <<<<<<<<<<<<<< + * ARES_FLAG_NOCHECKRESP = cares.ARES_FLAG_NOCHECKRESP + * + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_FLAG_NOALIASES); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 90, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARES_FLAG_NOALIASES, __pyx_t_2) < 0) __PYX_ERR(0, 90, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "gevent/ares.pyx":91 + * ARES_FLAG_NOSEARCH = cares.ARES_FLAG_NOSEARCH + * ARES_FLAG_NOALIASES = cares.ARES_FLAG_NOALIASES + * ARES_FLAG_NOCHECKRESP = cares.ARES_FLAG_NOCHECKRESP # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_FLAG_NOCHECKRESP); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 91, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARES_FLAG_NOCHECKRESP, __pyx_t_2) < 0) __PYX_ERR(0, 91, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "gevent/ares.pyx":95 + * + * _ares_errors = dict([ + * (cares.ARES_SUCCESS, 'ARES_SUCCESS'), # <<<<<<<<<<<<<< + * (cares.ARES_ENODATA, 'ARES_ENODATA'), + * (cares.ARES_EFORMERR, 'ARES_EFORMERR'), + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_SUCCESS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 95, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 95, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); + __Pyx_INCREF(__pyx_n_s_ARES_SUCCESS); + __Pyx_GIVEREF(__pyx_n_s_ARES_SUCCESS); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_n_s_ARES_SUCCESS); + __pyx_t_2 = 0; + + /* "gevent/ares.pyx":96 + * _ares_errors = dict([ + * (cares.ARES_SUCCESS, 'ARES_SUCCESS'), + * (cares.ARES_ENODATA, 'ARES_ENODATA'), # <<<<<<<<<<<<<< + * (cares.ARES_EFORMERR, 'ARES_EFORMERR'), + * (cares.ARES_ESERVFAIL, 'ARES_ESERVFAIL'), + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_ENODATA); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 96, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 96, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2); + __Pyx_INCREF(__pyx_n_s_ARES_ENODATA); + __Pyx_GIVEREF(__pyx_n_s_ARES_ENODATA); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_n_s_ARES_ENODATA); + __pyx_t_2 = 0; + + /* "gevent/ares.pyx":97 + * (cares.ARES_SUCCESS, 'ARES_SUCCESS'), + * (cares.ARES_ENODATA, 'ARES_ENODATA'), + * (cares.ARES_EFORMERR, 'ARES_EFORMERR'), # <<<<<<<<<<<<<< + * (cares.ARES_ESERVFAIL, 'ARES_ESERVFAIL'), + * (cares.ARES_ENOTFOUND, 'ARES_ENOTFOUND'), + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_EFORMERR); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_2); + __Pyx_INCREF(__pyx_n_s_ARES_EFORMERR); + __Pyx_GIVEREF(__pyx_n_s_ARES_EFORMERR); + PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_n_s_ARES_EFORMERR); + __pyx_t_2 = 0; + + /* "gevent/ares.pyx":98 + * (cares.ARES_ENODATA, 'ARES_ENODATA'), + * (cares.ARES_EFORMERR, 'ARES_EFORMERR'), + * (cares.ARES_ESERVFAIL, 'ARES_ESERVFAIL'), # <<<<<<<<<<<<<< + * (cares.ARES_ENOTFOUND, 'ARES_ENOTFOUND'), + * (cares.ARES_ENOTIMP, 'ARES_ENOTIMP'), + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_ESERVFAIL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 98, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 98, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_2); + __Pyx_INCREF(__pyx_n_s_ARES_ESERVFAIL); + __Pyx_GIVEREF(__pyx_n_s_ARES_ESERVFAIL); + PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_n_s_ARES_ESERVFAIL); + __pyx_t_2 = 0; + + /* "gevent/ares.pyx":99 + * (cares.ARES_EFORMERR, 'ARES_EFORMERR'), + * (cares.ARES_ESERVFAIL, 'ARES_ESERVFAIL'), + * (cares.ARES_ENOTFOUND, 'ARES_ENOTFOUND'), # <<<<<<<<<<<<<< + * (cares.ARES_ENOTIMP, 'ARES_ENOTIMP'), + * (cares.ARES_EREFUSED, 'ARES_EREFUSED'), + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_ENOTFOUND); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 99, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 99, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_2); + __Pyx_INCREF(__pyx_n_s_ARES_ENOTFOUND); + __Pyx_GIVEREF(__pyx_n_s_ARES_ENOTFOUND); + PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_n_s_ARES_ENOTFOUND); + __pyx_t_2 = 0; + + /* "gevent/ares.pyx":100 + * (cares.ARES_ESERVFAIL, 'ARES_ESERVFAIL'), + * (cares.ARES_ENOTFOUND, 'ARES_ENOTFOUND'), + * (cares.ARES_ENOTIMP, 'ARES_ENOTIMP'), # <<<<<<<<<<<<<< + * (cares.ARES_EREFUSED, 'ARES_EREFUSED'), + * (cares.ARES_EBADQUERY, 'ARES_EBADQUERY'), + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_ENOTIMP); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 100, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 100, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_2); + __Pyx_INCREF(__pyx_n_s_ARES_ENOTIMP); + __Pyx_GIVEREF(__pyx_n_s_ARES_ENOTIMP); + PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_n_s_ARES_ENOTIMP); + __pyx_t_2 = 0; + + /* "gevent/ares.pyx":101 + * (cares.ARES_ENOTFOUND, 'ARES_ENOTFOUND'), + * (cares.ARES_ENOTIMP, 'ARES_ENOTIMP'), + * (cares.ARES_EREFUSED, 'ARES_EREFUSED'), # <<<<<<<<<<<<<< + * (cares.ARES_EBADQUERY, 'ARES_EBADQUERY'), + * (cares.ARES_EBADNAME, 'ARES_EBADNAME'), + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_EREFUSED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 101, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_9 = PyTuple_New(2); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 101, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_2); + __Pyx_INCREF(__pyx_n_s_ARES_EREFUSED); + __Pyx_GIVEREF(__pyx_n_s_ARES_EREFUSED); + PyTuple_SET_ITEM(__pyx_t_9, 1, __pyx_n_s_ARES_EREFUSED); + __pyx_t_2 = 0; + + /* "gevent/ares.pyx":102 + * (cares.ARES_ENOTIMP, 'ARES_ENOTIMP'), + * (cares.ARES_EREFUSED, 'ARES_EREFUSED'), + * (cares.ARES_EBADQUERY, 'ARES_EBADQUERY'), # <<<<<<<<<<<<<< + * (cares.ARES_EBADNAME, 'ARES_EBADNAME'), + * (cares.ARES_EBADFAMILY, 'ARES_EBADFAMILY'), + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_EBADQUERY); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 102, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = PyTuple_New(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 102, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_2); + __Pyx_INCREF(__pyx_n_s_ARES_EBADQUERY); + __Pyx_GIVEREF(__pyx_n_s_ARES_EBADQUERY); + PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_n_s_ARES_EBADQUERY); + __pyx_t_2 = 0; + + /* "gevent/ares.pyx":103 + * (cares.ARES_EREFUSED, 'ARES_EREFUSED'), + * (cares.ARES_EBADQUERY, 'ARES_EBADQUERY'), + * (cares.ARES_EBADNAME, 'ARES_EBADNAME'), # <<<<<<<<<<<<<< + * (cares.ARES_EBADFAMILY, 'ARES_EBADFAMILY'), + * (cares.ARES_EBADRESP, 'ARES_EBADRESP'), + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_EBADNAME); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 103, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_11 = PyTuple_New(2); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 103, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_2); + __Pyx_INCREF(__pyx_n_s_ARES_EBADNAME); + __Pyx_GIVEREF(__pyx_n_s_ARES_EBADNAME); + PyTuple_SET_ITEM(__pyx_t_11, 1, __pyx_n_s_ARES_EBADNAME); + __pyx_t_2 = 0; + + /* "gevent/ares.pyx":104 + * (cares.ARES_EBADQUERY, 'ARES_EBADQUERY'), + * (cares.ARES_EBADNAME, 'ARES_EBADNAME'), + * (cares.ARES_EBADFAMILY, 'ARES_EBADFAMILY'), # <<<<<<<<<<<<<< + * (cares.ARES_EBADRESP, 'ARES_EBADRESP'), + * (cares.ARES_ECONNREFUSED, 'ARES_ECONNREFUSED'), + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_EBADFAMILY); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 104, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_12 = PyTuple_New(2); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 104, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_2); + __Pyx_INCREF(__pyx_n_s_ARES_EBADFAMILY); + __Pyx_GIVEREF(__pyx_n_s_ARES_EBADFAMILY); + PyTuple_SET_ITEM(__pyx_t_12, 1, __pyx_n_s_ARES_EBADFAMILY); + __pyx_t_2 = 0; + + /* "gevent/ares.pyx":105 + * (cares.ARES_EBADNAME, 'ARES_EBADNAME'), + * (cares.ARES_EBADFAMILY, 'ARES_EBADFAMILY'), + * (cares.ARES_EBADRESP, 'ARES_EBADRESP'), # <<<<<<<<<<<<<< + * (cares.ARES_ECONNREFUSED, 'ARES_ECONNREFUSED'), + * (cares.ARES_ETIMEOUT, 'ARES_ETIMEOUT'), + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_EBADRESP); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 105, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_13 = PyTuple_New(2); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 105, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_2); + __Pyx_INCREF(__pyx_n_s_ARES_EBADRESP); + __Pyx_GIVEREF(__pyx_n_s_ARES_EBADRESP); + PyTuple_SET_ITEM(__pyx_t_13, 1, __pyx_n_s_ARES_EBADRESP); + __pyx_t_2 = 0; + + /* "gevent/ares.pyx":106 + * (cares.ARES_EBADFAMILY, 'ARES_EBADFAMILY'), + * (cares.ARES_EBADRESP, 'ARES_EBADRESP'), + * (cares.ARES_ECONNREFUSED, 'ARES_ECONNREFUSED'), # <<<<<<<<<<<<<< + * (cares.ARES_ETIMEOUT, 'ARES_ETIMEOUT'), + * (cares.ARES_EOF, 'ARES_EOF'), + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_ECONNREFUSED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 106, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_14 = PyTuple_New(2); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 106, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_14); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_2); + __Pyx_INCREF(__pyx_n_s_ARES_ECONNREFUSED); + __Pyx_GIVEREF(__pyx_n_s_ARES_ECONNREFUSED); + PyTuple_SET_ITEM(__pyx_t_14, 1, __pyx_n_s_ARES_ECONNREFUSED); + __pyx_t_2 = 0; + + /* "gevent/ares.pyx":107 + * (cares.ARES_EBADRESP, 'ARES_EBADRESP'), + * (cares.ARES_ECONNREFUSED, 'ARES_ECONNREFUSED'), + * (cares.ARES_ETIMEOUT, 'ARES_ETIMEOUT'), # <<<<<<<<<<<<<< + * (cares.ARES_EOF, 'ARES_EOF'), + * (cares.ARES_EFILE, 'ARES_EFILE'), + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_ETIMEOUT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 107, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_15 = PyTuple_New(2); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 107, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_2); + __Pyx_INCREF(__pyx_n_s_ARES_ETIMEOUT); + __Pyx_GIVEREF(__pyx_n_s_ARES_ETIMEOUT); + PyTuple_SET_ITEM(__pyx_t_15, 1, __pyx_n_s_ARES_ETIMEOUT); + __pyx_t_2 = 0; + + /* "gevent/ares.pyx":108 + * (cares.ARES_ECONNREFUSED, 'ARES_ECONNREFUSED'), + * (cares.ARES_ETIMEOUT, 'ARES_ETIMEOUT'), + * (cares.ARES_EOF, 'ARES_EOF'), # <<<<<<<<<<<<<< + * (cares.ARES_EFILE, 'ARES_EFILE'), + * (cares.ARES_ENOMEM, 'ARES_ENOMEM'), + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_EOF); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 108, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_16 = PyTuple_New(2); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 108, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_16); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_16, 0, __pyx_t_2); + __Pyx_INCREF(__pyx_n_s_ARES_EOF); + __Pyx_GIVEREF(__pyx_n_s_ARES_EOF); + PyTuple_SET_ITEM(__pyx_t_16, 1, __pyx_n_s_ARES_EOF); + __pyx_t_2 = 0; + + /* "gevent/ares.pyx":109 + * (cares.ARES_ETIMEOUT, 'ARES_ETIMEOUT'), + * (cares.ARES_EOF, 'ARES_EOF'), + * (cares.ARES_EFILE, 'ARES_EFILE'), # <<<<<<<<<<<<<< + * (cares.ARES_ENOMEM, 'ARES_ENOMEM'), + * (cares.ARES_EDESTRUCTION, 'ARES_EDESTRUCTION'), + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_EFILE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 109, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_17 = PyTuple_New(2); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 109, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_17, 0, __pyx_t_2); + __Pyx_INCREF(__pyx_n_s_ARES_EFILE); + __Pyx_GIVEREF(__pyx_n_s_ARES_EFILE); + PyTuple_SET_ITEM(__pyx_t_17, 1, __pyx_n_s_ARES_EFILE); + __pyx_t_2 = 0; + + /* "gevent/ares.pyx":110 + * (cares.ARES_EOF, 'ARES_EOF'), + * (cares.ARES_EFILE, 'ARES_EFILE'), + * (cares.ARES_ENOMEM, 'ARES_ENOMEM'), # <<<<<<<<<<<<<< + * (cares.ARES_EDESTRUCTION, 'ARES_EDESTRUCTION'), + * (cares.ARES_EBADSTR, 'ARES_EBADSTR'), + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_ENOMEM); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 110, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_18 = PyTuple_New(2); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 110, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_18); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_18, 0, __pyx_t_2); + __Pyx_INCREF(__pyx_n_s_ARES_ENOMEM); + __Pyx_GIVEREF(__pyx_n_s_ARES_ENOMEM); + PyTuple_SET_ITEM(__pyx_t_18, 1, __pyx_n_s_ARES_ENOMEM); + __pyx_t_2 = 0; + + /* "gevent/ares.pyx":111 + * (cares.ARES_EFILE, 'ARES_EFILE'), + * (cares.ARES_ENOMEM, 'ARES_ENOMEM'), + * (cares.ARES_EDESTRUCTION, 'ARES_EDESTRUCTION'), # <<<<<<<<<<<<<< + * (cares.ARES_EBADSTR, 'ARES_EBADSTR'), + * (cares.ARES_EBADFLAGS, 'ARES_EBADFLAGS'), + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_EDESTRUCTION); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 111, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_19 = PyTuple_New(2); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 111, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_19, 0, __pyx_t_2); + __Pyx_INCREF(__pyx_n_s_ARES_EDESTRUCTION); + __Pyx_GIVEREF(__pyx_n_s_ARES_EDESTRUCTION); + PyTuple_SET_ITEM(__pyx_t_19, 1, __pyx_n_s_ARES_EDESTRUCTION); + __pyx_t_2 = 0; + + /* "gevent/ares.pyx":112 + * (cares.ARES_ENOMEM, 'ARES_ENOMEM'), + * (cares.ARES_EDESTRUCTION, 'ARES_EDESTRUCTION'), + * (cares.ARES_EBADSTR, 'ARES_EBADSTR'), # <<<<<<<<<<<<<< + * (cares.ARES_EBADFLAGS, 'ARES_EBADFLAGS'), + * (cares.ARES_ENONAME, 'ARES_ENONAME'), + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_EBADSTR); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 112, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_20 = PyTuple_New(2); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 112, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_20); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_20, 0, __pyx_t_2); + __Pyx_INCREF(__pyx_n_s_ARES_EBADSTR); + __Pyx_GIVEREF(__pyx_n_s_ARES_EBADSTR); + PyTuple_SET_ITEM(__pyx_t_20, 1, __pyx_n_s_ARES_EBADSTR); + __pyx_t_2 = 0; + + /* "gevent/ares.pyx":113 + * (cares.ARES_EDESTRUCTION, 'ARES_EDESTRUCTION'), + * (cares.ARES_EBADSTR, 'ARES_EBADSTR'), + * (cares.ARES_EBADFLAGS, 'ARES_EBADFLAGS'), # <<<<<<<<<<<<<< + * (cares.ARES_ENONAME, 'ARES_ENONAME'), + * (cares.ARES_EBADHINTS, 'ARES_EBADHINTS'), + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_EBADFLAGS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 113, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_21 = PyTuple_New(2); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 113, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_21); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_21, 0, __pyx_t_2); + __Pyx_INCREF(__pyx_n_s_ARES_EBADFLAGS); + __Pyx_GIVEREF(__pyx_n_s_ARES_EBADFLAGS); + PyTuple_SET_ITEM(__pyx_t_21, 1, __pyx_n_s_ARES_EBADFLAGS); + __pyx_t_2 = 0; + + /* "gevent/ares.pyx":114 + * (cares.ARES_EBADSTR, 'ARES_EBADSTR'), + * (cares.ARES_EBADFLAGS, 'ARES_EBADFLAGS'), + * (cares.ARES_ENONAME, 'ARES_ENONAME'), # <<<<<<<<<<<<<< + * (cares.ARES_EBADHINTS, 'ARES_EBADHINTS'), + * (cares.ARES_ENOTINITIALIZED, 'ARES_ENOTINITIALIZED'), + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_ENONAME); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 114, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_22 = PyTuple_New(2); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 114, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_22); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_2); + __Pyx_INCREF(__pyx_n_s_ARES_ENONAME); + __Pyx_GIVEREF(__pyx_n_s_ARES_ENONAME); + PyTuple_SET_ITEM(__pyx_t_22, 1, __pyx_n_s_ARES_ENONAME); + __pyx_t_2 = 0; + + /* "gevent/ares.pyx":115 + * (cares.ARES_EBADFLAGS, 'ARES_EBADFLAGS'), + * (cares.ARES_ENONAME, 'ARES_ENONAME'), + * (cares.ARES_EBADHINTS, 'ARES_EBADHINTS'), # <<<<<<<<<<<<<< + * (cares.ARES_ENOTINITIALIZED, 'ARES_ENOTINITIALIZED'), + * (cares.ARES_ELOADIPHLPAPI, 'ARES_ELOADIPHLPAPI'), + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_EBADHINTS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 115, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_23 = PyTuple_New(2); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 115, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_23); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_23, 0, __pyx_t_2); + __Pyx_INCREF(__pyx_n_s_ARES_EBADHINTS); + __Pyx_GIVEREF(__pyx_n_s_ARES_EBADHINTS); + PyTuple_SET_ITEM(__pyx_t_23, 1, __pyx_n_s_ARES_EBADHINTS); + __pyx_t_2 = 0; + + /* "gevent/ares.pyx":116 + * (cares.ARES_ENONAME, 'ARES_ENONAME'), + * (cares.ARES_EBADHINTS, 'ARES_EBADHINTS'), + * (cares.ARES_ENOTINITIALIZED, 'ARES_ENOTINITIALIZED'), # <<<<<<<<<<<<<< + * (cares.ARES_ELOADIPHLPAPI, 'ARES_ELOADIPHLPAPI'), + * (cares.ARES_EADDRGETNETWORKPARAMS, 'ARES_EADDRGETNETWORKPARAMS'), + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_ENOTINITIALIZED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 116, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_24 = PyTuple_New(2); if (unlikely(!__pyx_t_24)) __PYX_ERR(0, 116, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_24); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_24, 0, __pyx_t_2); + __Pyx_INCREF(__pyx_n_s_ARES_ENOTINITIALIZED); + __Pyx_GIVEREF(__pyx_n_s_ARES_ENOTINITIALIZED); + PyTuple_SET_ITEM(__pyx_t_24, 1, __pyx_n_s_ARES_ENOTINITIALIZED); + __pyx_t_2 = 0; + + /* "gevent/ares.pyx":117 + * (cares.ARES_EBADHINTS, 'ARES_EBADHINTS'), + * (cares.ARES_ENOTINITIALIZED, 'ARES_ENOTINITIALIZED'), + * (cares.ARES_ELOADIPHLPAPI, 'ARES_ELOADIPHLPAPI'), # <<<<<<<<<<<<<< + * (cares.ARES_EADDRGETNETWORKPARAMS, 'ARES_EADDRGETNETWORKPARAMS'), + * (cares.ARES_ECANCELLED, 'ARES_ECANCELLED')]) + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_ELOADIPHLPAPI); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 117, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_25 = PyTuple_New(2); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 117, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_25); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_25, 0, __pyx_t_2); + __Pyx_INCREF(__pyx_n_s_ARES_ELOADIPHLPAPI); + __Pyx_GIVEREF(__pyx_n_s_ARES_ELOADIPHLPAPI); + PyTuple_SET_ITEM(__pyx_t_25, 1, __pyx_n_s_ARES_ELOADIPHLPAPI); + __pyx_t_2 = 0; + + /* "gevent/ares.pyx":118 + * (cares.ARES_ENOTINITIALIZED, 'ARES_ENOTINITIALIZED'), + * (cares.ARES_ELOADIPHLPAPI, 'ARES_ELOADIPHLPAPI'), + * (cares.ARES_EADDRGETNETWORKPARAMS, 'ARES_EADDRGETNETWORKPARAMS'), # <<<<<<<<<<<<<< + * (cares.ARES_ECANCELLED, 'ARES_ECANCELLED')]) + * + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_EADDRGETNETWORKPARAMS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 118, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_26 = PyTuple_New(2); if (unlikely(!__pyx_t_26)) __PYX_ERR(0, 118, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_26); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_26, 0, __pyx_t_2); + __Pyx_INCREF(__pyx_n_s_ARES_EADDRGETNETWORKPARAMS); + __Pyx_GIVEREF(__pyx_n_s_ARES_EADDRGETNETWORKPARAMS); + PyTuple_SET_ITEM(__pyx_t_26, 1, __pyx_n_s_ARES_EADDRGETNETWORKPARAMS); + __pyx_t_2 = 0; + + /* "gevent/ares.pyx":119 + * (cares.ARES_ELOADIPHLPAPI, 'ARES_ELOADIPHLPAPI'), + * (cares.ARES_EADDRGETNETWORKPARAMS, 'ARES_EADDRGETNETWORKPARAMS'), + * (cares.ARES_ECANCELLED, 'ARES_ECANCELLED')]) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_2 = __Pyx_PyInt_From_int(ARES_ECANCELLED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 119, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_27 = PyTuple_New(2); if (unlikely(!__pyx_t_27)) __PYX_ERR(0, 119, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_27); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_27, 0, __pyx_t_2); + __Pyx_INCREF(__pyx_n_s_ARES_ECANCELLED); + __Pyx_GIVEREF(__pyx_n_s_ARES_ECANCELLED); + PyTuple_SET_ITEM(__pyx_t_27, 1, __pyx_n_s_ARES_ECANCELLED); + __pyx_t_2 = 0; + + /* "gevent/ares.pyx":94 + * + * + * _ares_errors = dict([ # <<<<<<<<<<<<<< + * (cares.ARES_SUCCESS, 'ARES_SUCCESS'), + * (cares.ARES_ENODATA, 'ARES_ENODATA'), + */ + __pyx_t_2 = PyList_New(25); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 94, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_1); + PyList_SET_ITEM(__pyx_t_2, 0, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_4); + PyList_SET_ITEM(__pyx_t_2, 1, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + PyList_SET_ITEM(__pyx_t_2, 2, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_6); + PyList_SET_ITEM(__pyx_t_2, 3, __pyx_t_6); + __Pyx_GIVEREF(__pyx_t_7); + PyList_SET_ITEM(__pyx_t_2, 4, __pyx_t_7); + __Pyx_GIVEREF(__pyx_t_8); + PyList_SET_ITEM(__pyx_t_2, 5, __pyx_t_8); + __Pyx_GIVEREF(__pyx_t_9); + PyList_SET_ITEM(__pyx_t_2, 6, __pyx_t_9); + __Pyx_GIVEREF(__pyx_t_10); + PyList_SET_ITEM(__pyx_t_2, 7, __pyx_t_10); + __Pyx_GIVEREF(__pyx_t_11); + PyList_SET_ITEM(__pyx_t_2, 8, __pyx_t_11); + __Pyx_GIVEREF(__pyx_t_12); + PyList_SET_ITEM(__pyx_t_2, 9, __pyx_t_12); + __Pyx_GIVEREF(__pyx_t_13); + PyList_SET_ITEM(__pyx_t_2, 10, __pyx_t_13); + __Pyx_GIVEREF(__pyx_t_14); + PyList_SET_ITEM(__pyx_t_2, 11, __pyx_t_14); + __Pyx_GIVEREF(__pyx_t_15); + PyList_SET_ITEM(__pyx_t_2, 12, __pyx_t_15); + __Pyx_GIVEREF(__pyx_t_16); + PyList_SET_ITEM(__pyx_t_2, 13, __pyx_t_16); + __Pyx_GIVEREF(__pyx_t_17); + PyList_SET_ITEM(__pyx_t_2, 14, __pyx_t_17); + __Pyx_GIVEREF(__pyx_t_18); + PyList_SET_ITEM(__pyx_t_2, 15, __pyx_t_18); + __Pyx_GIVEREF(__pyx_t_19); + PyList_SET_ITEM(__pyx_t_2, 16, __pyx_t_19); + __Pyx_GIVEREF(__pyx_t_20); + PyList_SET_ITEM(__pyx_t_2, 17, __pyx_t_20); + __Pyx_GIVEREF(__pyx_t_21); + PyList_SET_ITEM(__pyx_t_2, 18, __pyx_t_21); + __Pyx_GIVEREF(__pyx_t_22); + PyList_SET_ITEM(__pyx_t_2, 19, __pyx_t_22); + __Pyx_GIVEREF(__pyx_t_23); + PyList_SET_ITEM(__pyx_t_2, 20, __pyx_t_23); + __Pyx_GIVEREF(__pyx_t_24); + PyList_SET_ITEM(__pyx_t_2, 21, __pyx_t_24); + __Pyx_GIVEREF(__pyx_t_25); + PyList_SET_ITEM(__pyx_t_2, 22, __pyx_t_25); + __Pyx_GIVEREF(__pyx_t_26); + PyList_SET_ITEM(__pyx_t_2, 23, __pyx_t_26); + __Pyx_GIVEREF(__pyx_t_27); + PyList_SET_ITEM(__pyx_t_2, 24, __pyx_t_27); + __pyx_t_1 = 0; + __pyx_t_4 = 0; + __pyx_t_5 = 0; + __pyx_t_6 = 0; + __pyx_t_7 = 0; + __pyx_t_8 = 0; + __pyx_t_9 = 0; + __pyx_t_10 = 0; + __pyx_t_11 = 0; + __pyx_t_12 = 0; + __pyx_t_13 = 0; + __pyx_t_14 = 0; + __pyx_t_15 = 0; + __pyx_t_16 = 0; + __pyx_t_17 = 0; + __pyx_t_18 = 0; + __pyx_t_19 = 0; + __pyx_t_20 = 0; + __pyx_t_21 = 0; + __pyx_t_22 = 0; + __pyx_t_23 = 0; + __pyx_t_24 = 0; + __pyx_t_25 = 0; + __pyx_t_26 = 0; + __pyx_t_27 = 0; + __pyx_t_27 = PyTuple_New(1); if (unlikely(!__pyx_t_27)) __PYX_ERR(0, 94, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_27); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_27, 0, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)(&PyDict_Type)), __pyx_t_27, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 94, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_27); __pyx_t_27 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ares_errors, __pyx_t_2) < 0) __PYX_ERR(0, 94, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "gevent/ares.pyx":123 + * + * # maps c-ares flag to _socket module flag + * _cares_flag_map = None # <<<<<<<<<<<<<< + * + * + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_cares_flag_map, Py_None) < 0) __PYX_ERR(0, 123, __pyx_L1_error) + + /* "gevent/ares.pyx":137 + * + * + * cpdef _convert_cares_flags(int flags, int default=cares.ARES_NI_LOOKUPHOST|cares.ARES_NI_LOOKUPSERVICE): # <<<<<<<<<<<<<< + * if _cares_flag_map is None: + * _prepare_cares_flag_map() + */ + __pyx_k_ = (ARES_NI_LOOKUPHOST | ARES_NI_LOOKUPSERVICE); + __pyx_k_ = (ARES_NI_LOOKUPHOST | ARES_NI_LOOKUPSERVICE); + + /* "gevent/ares.pyx":153 + * + * + * class InvalidIP(ValueError): # <<<<<<<<<<<<<< + * pass + * + */ + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_builtin_ValueError); + __Pyx_GIVEREF(__pyx_builtin_ValueError); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_builtin_ValueError); + __pyx_t_27 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_27)) __PYX_ERR(0, 153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_27); + __pyx_t_26 = __Pyx_Py3MetaclassPrepare(__pyx_t_27, __pyx_t_2, __pyx_n_s_InvalidIP, __pyx_n_s_InvalidIP, (PyObject *) NULL, __pyx_n_s_gevent_ares, (PyObject *) NULL); if (unlikely(!__pyx_t_26)) __PYX_ERR(0, 153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_26); + __pyx_t_25 = __Pyx_Py3ClassCreate(__pyx_t_27, __pyx_n_s_InvalidIP, __pyx_t_2, __pyx_t_26, NULL, 0, 1); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_25); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_InvalidIP, __pyx_t_25) < 0) __PYX_ERR(0, 153, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0; + __Pyx_DECREF(__pyx_t_26); __pyx_t_26 = 0; + __Pyx_DECREF(__pyx_t_27); __pyx_t_27 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "gevent/ares.pyx":190 + * + * + * class ares_host_result(tuple): # <<<<<<<<<<<<<< + * + * def __new__(cls, family, iterable): + */ + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 190, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(((PyObject *)(&PyTuple_Type))); + __Pyx_GIVEREF(((PyObject *)(&PyTuple_Type))); + PyTuple_SET_ITEM(__pyx_t_2, 0, ((PyObject *)(&PyTuple_Type))); + __pyx_t_27 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_27)) __PYX_ERR(0, 190, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_27); + __pyx_t_26 = __Pyx_Py3MetaclassPrepare(__pyx_t_27, __pyx_t_2, __pyx_n_s_ares_host_result, __pyx_n_s_ares_host_result, (PyObject *) NULL, __pyx_n_s_gevent_ares, (PyObject *) NULL); if (unlikely(!__pyx_t_26)) __PYX_ERR(0, 190, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_26); + + /* "gevent/ares.pyx":192 + * class ares_host_result(tuple): + * + * def __new__(cls, family, iterable): # <<<<<<<<<<<<<< + * cdef object self = tuple.__new__(cls, iterable) + * self.family = family + */ + __pyx_t_25 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6gevent_4ares_16ares_host_result_1__new__, __Pyx_CYFUNCTION_STATICMETHOD, __pyx_n_s_ares_host_result___new, NULL, __pyx_n_s_gevent_ares, __pyx_d, ((PyObject *)__pyx_codeobj__7)); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 192, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_25); + if (PyObject_SetItem(__pyx_t_26, __pyx_n_s_new, __pyx_t_25) < 0) __PYX_ERR(0, 192, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0; + + /* "gevent/ares.pyx":197 + * return self + * + * def __getnewargs__(self): # <<<<<<<<<<<<<< + * return (self.family, tuple(self)) + * + */ + __pyx_t_25 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6gevent_4ares_16ares_host_result_3__getnewargs__, 0, __pyx_n_s_ares_host_result___getnewargs, NULL, __pyx_n_s_gevent_ares, __pyx_d, ((PyObject *)__pyx_codeobj__9)); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 197, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_25); + if (PyObject_SetItem(__pyx_t_26, __pyx_n_s_getnewargs, __pyx_t_25) < 0) __PYX_ERR(0, 197, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0; + + /* "gevent/ares.pyx":190 + * + * + * class ares_host_result(tuple): # <<<<<<<<<<<<<< + * + * def __new__(cls, family, iterable): + */ + __pyx_t_25 = __Pyx_Py3ClassCreate(__pyx_t_27, __pyx_n_s_ares_host_result, __pyx_t_2, __pyx_t_26, NULL, 0, 1); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 190, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_25); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ares_host_result, __pyx_t_25) < 0) __PYX_ERR(0, 190, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0; + __Pyx_DECREF(__pyx_t_26); __pyx_t_26 = 0; + __Pyx_DECREF(__pyx_t_27); __pyx_t_27 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "gevent/ares.pyx":400 + * cares.ares_process_fd(self.channel, read_fd, write_fd) + * + * def gethostbyname(self, object callback, char* name, int family=AF_INET): # <<<<<<<<<<<<<< + * if not self.channel: + * raise gaierror(cares.ARES_EDESTRUCTION, 'this ares channel has been destroyed') + */ + __pyx_k__5 = AF_INET; + + /* "gevent/ares.pyx":1 + * # Copyright (c) 2011-2012 Denis Bilenko. See LICENSE for details. # <<<<<<<<<<<<<< + * cimport cares + * import sys + */ + __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /*--- Wrapped vars code ---*/ + + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_XDECREF(__pyx_t_13); + __Pyx_XDECREF(__pyx_t_14); + __Pyx_XDECREF(__pyx_t_15); + __Pyx_XDECREF(__pyx_t_16); + __Pyx_XDECREF(__pyx_t_17); + __Pyx_XDECREF(__pyx_t_18); + __Pyx_XDECREF(__pyx_t_19); + __Pyx_XDECREF(__pyx_t_20); + __Pyx_XDECREF(__pyx_t_21); + __Pyx_XDECREF(__pyx_t_22); + __Pyx_XDECREF(__pyx_t_23); + __Pyx_XDECREF(__pyx_t_24); + __Pyx_XDECREF(__pyx_t_25); + __Pyx_XDECREF(__pyx_t_26); + __Pyx_XDECREF(__pyx_t_27); + if (__pyx_m) { + if (__pyx_d) { + __Pyx_AddTraceback("init gevent.ares", __pyx_clineno, __pyx_lineno, __pyx_filename); + } + Py_DECREF(__pyx_m); __pyx_m = 0; + } else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_ImportError, "init gevent.ares"); + } + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + #if PY_MAJOR_VERSION < 3 + return; + #else + return __pyx_m; + #endif +} + +/* --- Runtime support code --- */ +/* Refnanny */ +#if CYTHON_REFNANNY +static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { + PyObject *m = NULL, *p = NULL; + void *r = NULL; + m = PyImport_ImportModule((char *)modname); + if (!m) goto end; + p = PyObject_GetAttrString(m, (char *)"RefNannyAPI"); + if (!p) goto end; + r = PyLong_AsVoidPtr(p); +end: + Py_XDECREF(p); + Py_XDECREF(m); + return (__Pyx_RefNannyAPIStruct *)r; +} +#endif + +/* GetBuiltinName */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name) { + PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); + if (unlikely(!result)) { + PyErr_Format(PyExc_NameError, +#if PY_MAJOR_VERSION >= 3 + "name '%U' is not defined", name); +#else + "name '%.200s' is not defined", PyString_AS_STRING(name)); +#endif + } + return result; +} + +/* Import */ +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { + PyObject *empty_list = 0; + PyObject *module = 0; + PyObject *global_dict = 0; + PyObject *empty_dict = 0; + PyObject *list; + #if PY_VERSION_HEX < 0x03030000 + PyObject *py_import; + py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); + if (!py_import) + goto bad; + #endif + if (from_list) + list = from_list; + else { + empty_list = PyList_New(0); + if (!empty_list) + goto bad; + list = empty_list; + } + global_dict = PyModule_GetDict(__pyx_m); + if (!global_dict) + goto bad; + empty_dict = PyDict_New(); + if (!empty_dict) + goto bad; + { + #if PY_MAJOR_VERSION >= 3 + if (level == -1) { + if (strchr(__Pyx_MODULE_NAME, '.')) { + #if PY_VERSION_HEX < 0x03030000 + PyObject *py_level = PyInt_FromLong(1); + if (!py_level) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, global_dict, empty_dict, list, py_level, NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, 1); + #endif + if (!module) { + if (!PyErr_ExceptionMatches(PyExc_ImportError)) + goto bad; + PyErr_Clear(); + } + } + level = 0; + } + #endif + if (!module) { + #if PY_VERSION_HEX < 0x03030000 + PyObject *py_level = PyInt_FromLong(level); + if (!py_level) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, global_dict, empty_dict, list, py_level, NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, level); + #endif + } + } +bad: + #if PY_VERSION_HEX < 0x03030000 + Py_XDECREF(py_import); + #endif + Py_XDECREF(empty_list); + Py_XDECREF(empty_dict); + return module; +} + +/* GetAttr */ +static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *o, PyObject *n) { +#if CYTHON_COMPILING_IN_CPYTHON +#if PY_MAJOR_VERSION >= 3 + if (likely(PyUnicode_Check(n))) +#else + if (likely(PyString_Check(n))) +#endif + return __Pyx_PyObject_GetAttrStr(o, n); +#endif + return PyObject_GetAttr(o, n); +} + +/* GetAttr3 */ +static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *o, PyObject *n, PyObject *d) { + PyObject *r = __Pyx_GetAttr(o, n); + if (unlikely(!r)) { + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) + goto bad; + PyErr_Clear(); + r = d; + Py_INCREF(d); + } + return r; +bad: + return NULL; +} + +/* GetModuleGlobalName */ +static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name) { + PyObject *result; +#if !CYTHON_AVOID_BORROWED_REFS + result = PyDict_GetItem(__pyx_d, name); + if (likely(result)) { + Py_INCREF(result); + } else { +#else + result = PyObject_GetItem(__pyx_d, name); + if (!result) { + PyErr_Clear(); +#endif + result = __Pyx_GetBuiltinName(name); + } + return result; +} + +/* RaiseTooManyValuesToUnpack */ + static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { + PyErr_Format(PyExc_ValueError, + "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); +} + +/* RaiseNeedMoreValuesToUnpack */ + static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { + PyErr_Format(PyExc_ValueError, + "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", + index, (index == 1) ? "" : "s"); +} + +/* IterFinish */ + static CYTHON_INLINE int __Pyx_IterFinish(void) { +#if CYTHON_FAST_THREAD_STATE + PyThreadState *tstate = PyThreadState_GET(); + PyObject* exc_type = tstate->curexc_type; + if (unlikely(exc_type)) { + if (likely(exc_type == PyExc_StopIteration) || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)) { + PyObject *exc_value, *exc_tb; + exc_value = tstate->curexc_value; + exc_tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; + Py_DECREF(exc_type); + Py_XDECREF(exc_value); + Py_XDECREF(exc_tb); + return 0; + } else { + return -1; + } + } + return 0; +#else + if (unlikely(PyErr_Occurred())) { + if (likely(PyErr_ExceptionMatches(PyExc_StopIteration))) { + PyErr_Clear(); + return 0; + } else { + return -1; + } + } + return 0; +#endif +} + +/* UnpackItemEndCheck */ + static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) { + if (unlikely(retval)) { + Py_DECREF(retval); + __Pyx_RaiseTooManyValuesError(expected); + return -1; + } else { + return __Pyx_IterFinish(); + } + return 0; +} + +/* PyFunctionFastCall */ + #if CYTHON_FAST_PYCALL +#include "frameobject.h" +static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, + PyObject *globals) { + PyFrameObject *f; + PyThreadState *tstate = PyThreadState_GET(); + PyObject **fastlocals; + Py_ssize_t i; + PyObject *result; + assert(globals != NULL); + /* XXX Perhaps we should create a specialized + PyFrame_New() that doesn't take locals, but does + take builtins without sanity checking them. + */ + assert(tstate != NULL); + f = PyFrame_New(tstate, co, globals, NULL); + if (f == NULL) { + return NULL; + } + fastlocals = f->f_localsplus; + for (i = 0; i < na; i++) { + Py_INCREF(*args); + fastlocals[i] = *args++; + } + result = PyEval_EvalFrameEx(f,0); + ++tstate->recursion_depth; + Py_DECREF(f); + --tstate->recursion_depth; + return result; +} +#if 1 || PY_VERSION_HEX < 0x030600B1 +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, int nargs, PyObject *kwargs) { + PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); + PyObject *globals = PyFunction_GET_GLOBALS(func); + PyObject *argdefs = PyFunction_GET_DEFAULTS(func); + PyObject *closure; +#if PY_MAJOR_VERSION >= 3 + PyObject *kwdefs; +#endif + PyObject *kwtuple, **k; + PyObject **d; + Py_ssize_t nd; + Py_ssize_t nk; + PyObject *result; + assert(kwargs == NULL || PyDict_Check(kwargs)); + nk = kwargs ? PyDict_Size(kwargs) : 0; + if (Py_EnterRecursiveCall((char*)" while calling a Python object")) { + return NULL; + } + if ( +#if PY_MAJOR_VERSION >= 3 + co->co_kwonlyargcount == 0 && +#endif + likely(kwargs == NULL || nk == 0) && + co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { + if (argdefs == NULL && co->co_argcount == nargs) { + result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); + goto done; + } + else if (nargs == 0 && argdefs != NULL + && co->co_argcount == Py_SIZE(argdefs)) { + /* function called with no arguments, but all parameters have + a default value: use default values as arguments .*/ + args = &PyTuple_GET_ITEM(argdefs, 0); + result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); + goto done; + } + } + if (kwargs != NULL) { + Py_ssize_t pos, i; + kwtuple = PyTuple_New(2 * nk); + if (kwtuple == NULL) { + result = NULL; + goto done; + } + k = &PyTuple_GET_ITEM(kwtuple, 0); + pos = i = 0; + while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { + Py_INCREF(k[i]); + Py_INCREF(k[i+1]); + i += 2; + } + nk = i / 2; + } + else { + kwtuple = NULL; + k = NULL; + } + closure = PyFunction_GET_CLOSURE(func); +#if PY_MAJOR_VERSION >= 3 + kwdefs = PyFunction_GET_KW_DEFAULTS(func); +#endif + if (argdefs != NULL) { + d = &PyTuple_GET_ITEM(argdefs, 0); + nd = Py_SIZE(argdefs); + } + else { + d = NULL; + nd = 0; + } +#if PY_MAJOR_VERSION >= 3 + result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, + args, nargs, + k, (int)nk, + d, (int)nd, kwdefs, closure); +#else + result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, + args, nargs, + k, (int)nk, + d, (int)nd, closure); +#endif + Py_XDECREF(kwtuple); +done: + Py_LeaveRecursiveCall(); + return result; +} +#endif // CPython < 3.6 +#endif // CYTHON_FAST_PYCALL + +/* PyCFunctionFastCall */ + #if CYTHON_FAST_PYCCALL +static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) { + PyCFunctionObject *func = (PyCFunctionObject*)func_obj; + PyCFunction meth = PyCFunction_GET_FUNCTION(func); + PyObject *self = PyCFunction_GET_SELF(func); + assert(PyCFunction_Check(func)); + assert(METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST))); + assert(nargs >= 0); + assert(nargs == 0 || args != NULL); + /* _PyCFunction_FastCallDict() must not be called with an exception set, + because it may clear it (directly or indirectly) and so the + caller loses its exception */ + assert(!PyErr_Occurred()); + return (*((__Pyx_PyCFunctionFast)meth)) (self, args, nargs, NULL); +} +#endif // CYTHON_FAST_PYCCALL + +/* PyObjectCall */ + #if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *result; + ternaryfunc call = func->ob_type->tp_call; + if (unlikely(!call)) + return PyObject_Call(func, arg, kw); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = (*call)(func, arg, kw); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* PyErrFetchRestore */ + #if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + tmp_type = tstate->curexc_type; + tmp_value = tstate->curexc_value; + tmp_tb = tstate->curexc_traceback; + tstate->curexc_type = type; + tstate->curexc_value = value; + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +} +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + *type = tstate->curexc_type; + *value = tstate->curexc_value; + *tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +} +#endif + +/* RaiseException */ + #if PY_MAJOR_VERSION < 3 +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, + CYTHON_UNUSED PyObject *cause) { + __Pyx_PyThreadState_declare + Py_XINCREF(type); + if (!value || value == Py_None) + value = NULL; + else + Py_INCREF(value); + if (!tb || tb == Py_None) + tb = NULL; + else { + Py_INCREF(tb); + if (!PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto raise_error; + } + } + if (PyType_Check(type)) { +#if CYTHON_COMPILING_IN_PYPY + if (!value) { + Py_INCREF(Py_None); + value = Py_None; + } +#endif + PyErr_NormalizeException(&type, &value, &tb); + } else { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto raise_error; + } + value = type; + type = (PyObject*) Py_TYPE(type); + Py_INCREF(type); + if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto raise_error; + } + } + __Pyx_PyThreadState_assign + __Pyx_ErrRestore(type, value, tb); + return; +raise_error: + Py_XDECREF(value); + Py_XDECREF(type); + Py_XDECREF(tb); + return; +} +#else +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { + PyObject* owned_instance = NULL; + if (tb == Py_None) { + tb = 0; + } else if (tb && !PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto bad; + } + if (value == Py_None) + value = 0; + if (PyExceptionInstance_Check(type)) { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto bad; + } + value = type; + type = (PyObject*) Py_TYPE(value); + } else if (PyExceptionClass_Check(type)) { + PyObject *instance_class = NULL; + if (value && PyExceptionInstance_Check(value)) { + instance_class = (PyObject*) Py_TYPE(value); + if (instance_class != type) { + int is_subclass = PyObject_IsSubclass(instance_class, type); + if (!is_subclass) { + instance_class = NULL; + } else if (unlikely(is_subclass == -1)) { + goto bad; + } else { + type = instance_class; + } + } + } + if (!instance_class) { + PyObject *args; + if (!value) + args = PyTuple_New(0); + else if (PyTuple_Check(value)) { + Py_INCREF(value); + args = value; + } else + args = PyTuple_Pack(1, value); + if (!args) + goto bad; + owned_instance = PyObject_Call(type, args, NULL); + Py_DECREF(args); + if (!owned_instance) + goto bad; + value = owned_instance; + if (!PyExceptionInstance_Check(value)) { + PyErr_Format(PyExc_TypeError, + "calling %R should have returned an instance of " + "BaseException, not %R", + type, Py_TYPE(value)); + goto bad; + } + } + } else { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto bad; + } +#if PY_VERSION_HEX >= 0x03030000 + if (cause) { +#else + if (cause && cause != Py_None) { +#endif + PyObject *fixed_cause; + if (cause == Py_None) { + fixed_cause = NULL; + } else if (PyExceptionClass_Check(cause)) { + fixed_cause = PyObject_CallObject(cause, NULL); + if (fixed_cause == NULL) + goto bad; + } else if (PyExceptionInstance_Check(cause)) { + fixed_cause = cause; + Py_INCREF(fixed_cause); + } else { + PyErr_SetString(PyExc_TypeError, + "exception causes must derive from " + "BaseException"); + goto bad; + } + PyException_SetCause(value, fixed_cause); + } + PyErr_SetObject(type, value); + if (tb) { +#if CYTHON_COMPILING_IN_PYPY + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); + Py_INCREF(tb); + PyErr_Restore(tmp_type, tmp_value, tb); + Py_XDECREF(tmp_tb); +#else + PyThreadState *tstate = PyThreadState_GET(); + PyObject* tmp_tb = tstate->curexc_traceback; + if (tb != tmp_tb) { + Py_INCREF(tb); + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_tb); + } +#endif + } +bad: + Py_XDECREF(owned_instance); + return; +} +#endif + +/* RaiseDoubleKeywords */ + static void __Pyx_RaiseDoubleKeywordsError( + const char* func_name, + PyObject* kw_name) +{ + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION >= 3 + "%s() got multiple values for keyword argument '%U'", func_name, kw_name); + #else + "%s() got multiple values for keyword argument '%s'", func_name, + PyString_AsString(kw_name)); + #endif +} + +/* ParseKeywords */ + static int __Pyx_ParseOptionalKeywords( + PyObject *kwds, + PyObject **argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + const char* function_name) +{ + PyObject *key = 0, *value = 0; + Py_ssize_t pos = 0; + PyObject*** name; + PyObject*** first_kw_arg = argnames + num_pos_args; + while (PyDict_Next(kwds, &pos, &key, &value)) { + name = first_kw_arg; + while (*name && (**name != key)) name++; + if (*name) { + values[name-argnames] = value; + continue; + } + name = first_kw_arg; + #if PY_MAJOR_VERSION < 3 + if (likely(PyString_CheckExact(key)) || likely(PyString_Check(key))) { + while (*name) { + if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) + && _PyString_Eq(**name, key)) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + if ((**argname == key) || ( + (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) + && _PyString_Eq(**argname, key))) { + goto arg_passed_twice; + } + argname++; + } + } + } else + #endif + if (likely(PyUnicode_Check(key))) { + while (*name) { + int cmp = (**name == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (PyUnicode_GET_SIZE(**name) != PyUnicode_GET_SIZE(key)) ? 1 : + #endif + PyUnicode_Compare(**name, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + int cmp = (**argname == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (PyUnicode_GET_SIZE(**argname) != PyUnicode_GET_SIZE(key)) ? 1 : + #endif + PyUnicode_Compare(**argname, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) goto arg_passed_twice; + argname++; + } + } + } else + goto invalid_keyword_type; + if (kwds2) { + if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; + } else { + goto invalid_keyword; + } + } + return 0; +arg_passed_twice: + __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; +invalid_keyword_type: + PyErr_Format(PyExc_TypeError, + "%.200s() keywords must be strings", function_name); + goto bad; +invalid_keyword: + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION < 3 + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif +bad: + return -1; +} + +/* RaiseArgTupleInvalid */ + static void __Pyx_RaiseArgtupleInvalid( + const char* func_name, + int exact, + Py_ssize_t num_min, + Py_ssize_t num_max, + Py_ssize_t num_found) +{ + Py_ssize_t num_expected; + const char *more_or_less; + if (num_found < num_min) { + num_expected = num_min; + more_or_less = "at least"; + } else { + num_expected = num_max; + more_or_less = "at most"; + } + if (exact) { + more_or_less = "exactly"; + } + PyErr_Format(PyExc_TypeError, + "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", + func_name, more_or_less, num_expected, + (num_expected == 1) ? "" : "s", num_found); +} + +/* PyObjectCallMethO */ + #if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { + PyObject *self, *result; + PyCFunction cfunc; + cfunc = PyCFunction_GET_FUNCTION(func); + self = PyCFunction_GET_SELF(func); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = cfunc(self, arg); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* PyObjectCallOneArg */ + #if CYTHON_COMPILING_IN_CPYTHON +static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_New(1); + if (unlikely(!args)) return NULL; + Py_INCREF(arg); + PyTuple_SET_ITEM(args, 0, arg); + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { +#if CYTHON_FAST_PYCALL + if (PyFunction_Check(func)) { + return __Pyx_PyFunction_FastCall(func, &arg, 1); + } +#endif +#ifdef __Pyx_CyFunction_USED + if (likely(PyCFunction_Check(func) || PyObject_TypeCheck(func, __pyx_CyFunctionType))) { +#else + if (likely(PyCFunction_Check(func))) { +#endif + if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { + return __Pyx_PyObject_CallMethO(func, arg); +#if CYTHON_FAST_PYCCALL + } else if (PyCFunction_GET_FLAGS(func) & METH_FASTCALL) { + return __Pyx_PyCFunction_FastCall(func, &arg, 1); +#endif + } + } + return __Pyx__PyObject_CallOneArg(func, arg); +} +#else +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_Pack(1, arg); + if (unlikely(!args)) return NULL; + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +#endif + +/* WriteUnraisableException */ + static void __Pyx_WriteUnraisable(const char *name, CYTHON_UNUSED int clineno, + CYTHON_UNUSED int lineno, CYTHON_UNUSED const char *filename, + int full_traceback, CYTHON_UNUSED int nogil) { + PyObject *old_exc, *old_val, *old_tb; + PyObject *ctx; + __Pyx_PyThreadState_declare +#ifdef WITH_THREAD + PyGILState_STATE state; + if (nogil) + state = PyGILState_Ensure(); +#ifdef _MSC_VER + else state = (PyGILState_STATE)-1; +#endif +#endif + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&old_exc, &old_val, &old_tb); + if (full_traceback) { + Py_XINCREF(old_exc); + Py_XINCREF(old_val); + Py_XINCREF(old_tb); + __Pyx_ErrRestore(old_exc, old_val, old_tb); + PyErr_PrintEx(1); + } + #if PY_MAJOR_VERSION < 3 + ctx = PyString_FromString(name); + #else + ctx = PyUnicode_FromString(name); + #endif + __Pyx_ErrRestore(old_exc, old_val, old_tb); + if (!ctx) { + PyErr_WriteUnraisable(Py_None); + } else { + PyErr_WriteUnraisable(ctx); + Py_DECREF(ctx); + } +#ifdef WITH_THREAD + if (nogil) + PyGILState_Release(state); +#endif +} + +/* RaiseNoneIterError */ + static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); +} + +/* ExtTypeTest */ + static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + if (likely(PyObject_TypeCheck(obj, type))) + return 1; + PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s", + Py_TYPE(obj)->tp_name, type->tp_name); + return 0; +} + +/* SaveResetException */ + #if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + *type = tstate->exc_type; + *value = tstate->exc_value; + *tb = tstate->exc_traceback; + Py_XINCREF(*type); + Py_XINCREF(*value); + Py_XINCREF(*tb); +} +static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = type; + tstate->exc_value = value; + tstate->exc_traceback = tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +} +#endif + +/* GetException */ + #if CYTHON_FAST_THREAD_STATE +static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { +#else +static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) { +#endif + PyObject *local_type, *local_value, *local_tb; +#if CYTHON_FAST_THREAD_STATE + PyObject *tmp_type, *tmp_value, *tmp_tb; + local_type = tstate->curexc_type; + local_value = tstate->curexc_value; + local_tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +#else + PyErr_Fetch(&local_type, &local_value, &local_tb); +#endif + PyErr_NormalizeException(&local_type, &local_value, &local_tb); +#if CYTHON_FAST_THREAD_STATE + if (unlikely(tstate->curexc_type)) +#else + if (unlikely(PyErr_Occurred())) +#endif + goto bad; + #if PY_MAJOR_VERSION >= 3 + if (local_tb) { + if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) + goto bad; + } + #endif + Py_XINCREF(local_tb); + Py_XINCREF(local_type); + Py_XINCREF(local_value); + *type = local_type; + *value = local_value; + *tb = local_tb; +#if CYTHON_FAST_THREAD_STATE + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = local_type; + tstate->exc_value = local_value; + tstate->exc_traceback = local_tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +#else + PyErr_SetExcInfo(local_type, local_value, local_tb); +#endif + return 0; +bad: + *type = 0; + *value = 0; + *tb = 0; + Py_XDECREF(local_type); + Py_XDECREF(local_value); + Py_XDECREF(local_tb); + return -1; +} + +/* PyObjectCallNoArg */ + #if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { +#if CYTHON_FAST_PYCALL + if (PyFunction_Check(func)) { + return __Pyx_PyFunction_FastCall(func, NULL, 0); + } +#endif +#ifdef __Pyx_CyFunction_USED + if (likely(PyCFunction_Check(func) || PyObject_TypeCheck(func, __pyx_CyFunctionType))) { +#else + if (likely(PyCFunction_Check(func))) { +#endif + if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) { + return __Pyx_PyObject_CallMethO(func, NULL); + } + } + return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL); +} +#endif + +/* GetItemInt */ + static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { + PyObject *r; + if (!j) return NULL; + r = PyObject_GetItem(o, j); + Py_DECREF(j); + return r; +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (wraparound & unlikely(i < 0)) i += PyList_GET_SIZE(o); + if ((!boundscheck) || likely((0 <= i) & (i < PyList_GET_SIZE(o)))) { + PyObject *r = PyList_GET_ITEM(o, i); + Py_INCREF(r); + return r; + } + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +#else + return PySequence_GetItem(o, i); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (wraparound & unlikely(i < 0)) i += PyTuple_GET_SIZE(o); + if ((!boundscheck) || likely((0 <= i) & (i < PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, i); + Py_INCREF(r); + return r; + } + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +#else + return PySequence_GetItem(o, i); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS + if (is_list || PyList_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); + if ((!boundscheck) || (likely((n >= 0) & (n < PyList_GET_SIZE(o))))) { + PyObject *r = PyList_GET_ITEM(o, n); + Py_INCREF(r); + return r; + } + } + else if (PyTuple_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); + if ((!boundscheck) || likely((n >= 0) & (n < PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, n); + Py_INCREF(r); + return r; + } + } else { + PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; + if (likely(m && m->sq_item)) { + if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { + Py_ssize_t l = m->sq_length(o); + if (likely(l >= 0)) { + i += l; + } else { + if (!PyErr_ExceptionMatches(PyExc_OverflowError)) + return NULL; + PyErr_Clear(); + } + } + return m->sq_item(o, i); + } + } +#else + if (is_list || PySequence_Check(o)) { + return PySequence_GetItem(o, i); + } +#endif + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +} + +/* pyobject_as_double */ + static double __Pyx__PyObject_AsDouble(PyObject* obj) { + PyObject* float_value; +#if !CYTHON_USE_TYPE_SLOTS + float_value = PyNumber_Float(obj); if (0) goto bad; +#else + PyNumberMethods *nb = Py_TYPE(obj)->tp_as_number; + if (likely(nb) && likely(nb->nb_float)) { + float_value = nb->nb_float(obj); + if (likely(float_value) && unlikely(!PyFloat_Check(float_value))) { + PyErr_Format(PyExc_TypeError, + "__float__ returned non-float (type %.200s)", + Py_TYPE(float_value)->tp_name); + Py_DECREF(float_value); + goto bad; + } + } else if (PyUnicode_CheckExact(obj) || PyBytes_CheckExact(obj)) { +#if PY_MAJOR_VERSION >= 3 + float_value = PyFloat_FromString(obj); +#else + float_value = PyFloat_FromString(obj, 0); +#endif + } else { + PyObject* args = PyTuple_New(1); + if (unlikely(!args)) goto bad; + PyTuple_SET_ITEM(args, 0, obj); + float_value = PyObject_Call((PyObject*)&PyFloat_Type, args, 0); + PyTuple_SET_ITEM(args, 0, 0); + Py_DECREF(args); + } +#endif + if (likely(float_value)) { + double value = PyFloat_AS_DOUBLE(float_value); + Py_DECREF(float_value); + return value; + } +bad: + return (double)-1; +} + +/* SwapException */ + #if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = *type; + tstate->exc_value = *value; + tstate->exc_traceback = *tb; + *type = tmp_type; + *value = tmp_value; + *tb = tmp_tb; +} +#else +static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_GetExcInfo(&tmp_type, &tmp_value, &tmp_tb); + PyErr_SetExcInfo(*type, *value, *tb); + *type = tmp_type; + *value = tmp_value; + *tb = tmp_tb; +} +#endif + +/* dict_getitem_default */ + static PyObject* __Pyx_PyDict_GetItemDefault(PyObject* d, PyObject* key, PyObject* default_value) { + PyObject* value; +#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY + value = PyDict_GetItemWithError(d, key); + if (unlikely(!value)) { + if (unlikely(PyErr_Occurred())) + return NULL; + value = default_value; + } + Py_INCREF(value); +#else + if (PyString_CheckExact(key) || PyUnicode_CheckExact(key) || PyInt_CheckExact(key)) { + value = PyDict_GetItem(d, key); + if (unlikely(!value)) { + value = default_value; + } + Py_INCREF(value); + } else { + if (default_value == Py_None) + default_value = NULL; + value = PyObject_CallMethodObjArgs( + d, __pyx_n_s_get, key, default_value, NULL); + } +#endif + return value; +} + +/* ArgTypeTest */ + static void __Pyx_RaiseArgumentTypeInvalid(const char* name, PyObject *obj, PyTypeObject *type) { + PyErr_Format(PyExc_TypeError, + "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", + name, type->tp_name, Py_TYPE(obj)->tp_name); +} +static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed, + const char *name, int exact) +{ + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + if (none_allowed && obj == Py_None) return 1; + else if (exact) { + if (likely(Py_TYPE(obj) == type)) return 1; + #if PY_MAJOR_VERSION == 2 + else if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1; + #endif + } + else { + if (likely(PyObject_TypeCheck(obj, type))) return 1; + } + __Pyx_RaiseArgumentTypeInvalid(name, obj, type); + return 0; +} + +/* PyErrExceptionMatches */ + #if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) { + PyObject *exc_type = tstate->curexc_type; + if (exc_type == err) return 1; + if (unlikely(!exc_type)) return 0; + return PyErr_GivenExceptionMatches(exc_type, err); +} +#endif + +/* SetVTable */ + static int __Pyx_SetVtable(PyObject *dict, void *vtable) { +#if PY_VERSION_HEX >= 0x02070000 + PyObject *ob = PyCapsule_New(vtable, 0, 0); +#else + PyObject *ob = PyCObject_FromVoidPtr(vtable, 0); +#endif + if (!ob) + goto bad; + if (PyDict_SetItem(dict, __pyx_n_s_pyx_vtable, ob) < 0) + goto bad; + Py_DECREF(ob); + return 0; +bad: + Py_XDECREF(ob); + return -1; +} + +/* ImportFrom */ + static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { + PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); + if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Format(PyExc_ImportError, + #if PY_MAJOR_VERSION < 3 + "cannot import name %.230s", PyString_AS_STRING(name)); + #else + "cannot import name %S", name); + #endif + } + return value; +} + +/* CalculateMetaclass */ + static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases) { + Py_ssize_t i, nbases = PyTuple_GET_SIZE(bases); + for (i=0; i < nbases; i++) { + PyTypeObject *tmptype; + PyObject *tmp = PyTuple_GET_ITEM(bases, i); + tmptype = Py_TYPE(tmp); +#if PY_MAJOR_VERSION < 3 + if (tmptype == &PyClass_Type) + continue; +#endif + if (!metaclass) { + metaclass = tmptype; + continue; + } + if (PyType_IsSubtype(metaclass, tmptype)) + continue; + if (PyType_IsSubtype(tmptype, metaclass)) { + metaclass = tmptype; + continue; + } + PyErr_SetString(PyExc_TypeError, + "metaclass conflict: " + "the metaclass of a derived class " + "must be a (non-strict) subclass " + "of the metaclasses of all its bases"); + return NULL; + } + if (!metaclass) { +#if PY_MAJOR_VERSION < 3 + metaclass = &PyClass_Type; +#else + metaclass = &PyType_Type; +#endif + } + Py_INCREF((PyObject*) metaclass); + return (PyObject*) metaclass; +} + +/* Py3ClassCreate */ + static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name, + PyObject *qualname, PyObject *mkw, PyObject *modname, PyObject *doc) { + PyObject *ns; + if (metaclass) { + PyObject *prep = __Pyx_PyObject_GetAttrStr(metaclass, __pyx_n_s_prepare); + if (prep) { + PyObject *pargs = PyTuple_Pack(2, name, bases); + if (unlikely(!pargs)) { + Py_DECREF(prep); + return NULL; + } + ns = PyObject_Call(prep, pargs, mkw); + Py_DECREF(prep); + Py_DECREF(pargs); + } else { + if (unlikely(!PyErr_ExceptionMatches(PyExc_AttributeError))) + return NULL; + PyErr_Clear(); + ns = PyDict_New(); + } + } else { + ns = PyDict_New(); + } + if (unlikely(!ns)) + return NULL; + if (unlikely(PyObject_SetItem(ns, __pyx_n_s_module, modname) < 0)) goto bad; + if (unlikely(PyObject_SetItem(ns, __pyx_n_s_qualname, qualname) < 0)) goto bad; + if (unlikely(doc && PyObject_SetItem(ns, __pyx_n_s_doc, doc) < 0)) goto bad; + return ns; +bad: + Py_DECREF(ns); + return NULL; +} +static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases, + PyObject *dict, PyObject *mkw, + int calculate_metaclass, int allow_py2_metaclass) { + PyObject *result, *margs; + PyObject *owned_metaclass = NULL; + if (allow_py2_metaclass) { + owned_metaclass = PyObject_GetItem(dict, __pyx_n_s_metaclass); + if (owned_metaclass) { + metaclass = owned_metaclass; + } else if (likely(PyErr_ExceptionMatches(PyExc_KeyError))) { + PyErr_Clear(); + } else { + return NULL; + } + } + if (calculate_metaclass && (!metaclass || PyType_Check(metaclass))) { + metaclass = __Pyx_CalculateMetaclass((PyTypeObject*) metaclass, bases); + Py_XDECREF(owned_metaclass); + if (unlikely(!metaclass)) + return NULL; + owned_metaclass = metaclass; + } + margs = PyTuple_Pack(3, name, bases, dict); + if (unlikely(!margs)) { + result = NULL; + } else { + result = PyObject_Call(metaclass, margs, mkw); + Py_DECREF(margs); + } + Py_XDECREF(owned_metaclass); + return result; +} + +/* FetchCommonType */ + static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) { + PyObject* fake_module; + PyTypeObject* cached_type = NULL; + fake_module = PyImport_AddModule((char*) "_cython_" CYTHON_ABI); + if (!fake_module) return NULL; + Py_INCREF(fake_module); + cached_type = (PyTypeObject*) PyObject_GetAttrString(fake_module, type->tp_name); + if (cached_type) { + if (!PyType_Check((PyObject*)cached_type)) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s is not a type object", + type->tp_name); + goto bad; + } + if (cached_type->tp_basicsize != type->tp_basicsize) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s has the wrong size, try recompiling", + type->tp_name); + goto bad; + } + } else { + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; + PyErr_Clear(); + if (PyType_Ready(type) < 0) goto bad; + if (PyObject_SetAttrString(fake_module, type->tp_name, (PyObject*) type) < 0) + goto bad; + Py_INCREF(type); + cached_type = type; + } +done: + Py_DECREF(fake_module); + return cached_type; +bad: + Py_XDECREF(cached_type); + cached_type = NULL; + goto done; +} + +/* CythonFunction */ + static PyObject * +__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *closure) +{ + if (unlikely(op->func_doc == NULL)) { + if (op->func.m_ml->ml_doc) { +#if PY_MAJOR_VERSION >= 3 + op->func_doc = PyUnicode_FromString(op->func.m_ml->ml_doc); +#else + op->func_doc = PyString_FromString(op->func.m_ml->ml_doc); +#endif + if (unlikely(op->func_doc == NULL)) + return NULL; + } else { + Py_INCREF(Py_None); + return Py_None; + } + } + Py_INCREF(op->func_doc); + return op->func_doc; +} +static int +__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value) +{ + PyObject *tmp = op->func_doc; + if (value == NULL) { + value = Py_None; + } + Py_INCREF(value); + op->func_doc = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op) +{ + if (unlikely(op->func_name == NULL)) { +#if PY_MAJOR_VERSION >= 3 + op->func_name = PyUnicode_InternFromString(op->func.m_ml->ml_name); +#else + op->func_name = PyString_InternFromString(op->func.m_ml->ml_name); +#endif + if (unlikely(op->func_name == NULL)) + return NULL; + } + Py_INCREF(op->func_name); + return op->func_name; +} +static int +__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value) +{ + PyObject *tmp; +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) { +#else + if (unlikely(value == NULL || !PyString_Check(value))) { +#endif + PyErr_SetString(PyExc_TypeError, + "__name__ must be set to a string object"); + return -1; + } + tmp = op->func_name; + Py_INCREF(value); + op->func_name = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op) +{ + Py_INCREF(op->func_qualname); + return op->func_qualname; +} +static int +__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value) +{ + PyObject *tmp; +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) { +#else + if (unlikely(value == NULL || !PyString_Check(value))) { +#endif + PyErr_SetString(PyExc_TypeError, + "__qualname__ must be set to a string object"); + return -1; + } + tmp = op->func_qualname; + Py_INCREF(value); + op->func_qualname = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_self(__pyx_CyFunctionObject *m, CYTHON_UNUSED void *closure) +{ + PyObject *self; + self = m->func_closure; + if (self == NULL) + self = Py_None; + Py_INCREF(self); + return self; +} +static PyObject * +__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op) +{ + if (unlikely(op->func_dict == NULL)) { + op->func_dict = PyDict_New(); + if (unlikely(op->func_dict == NULL)) + return NULL; + } + Py_INCREF(op->func_dict); + return op->func_dict; +} +static int +__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value) +{ + PyObject *tmp; + if (unlikely(value == NULL)) { + PyErr_SetString(PyExc_TypeError, + "function's dictionary may not be deleted"); + return -1; + } + if (unlikely(!PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "setting function's dictionary to a non-dict"); + return -1; + } + tmp = op->func_dict; + Py_INCREF(value); + op->func_dict = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op) +{ + Py_INCREF(op->func_globals); + return op->func_globals; +} +static PyObject * +__Pyx_CyFunction_get_closure(CYTHON_UNUSED __pyx_CyFunctionObject *op) +{ + Py_INCREF(Py_None); + return Py_None; +} +static PyObject * +__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op) +{ + PyObject* result = (op->func_code) ? op->func_code : Py_None; + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) { + int result = 0; + PyObject *res = op->defaults_getter((PyObject *) op); + if (unlikely(!res)) + return -1; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + op->defaults_tuple = PyTuple_GET_ITEM(res, 0); + Py_INCREF(op->defaults_tuple); + op->defaults_kwdict = PyTuple_GET_ITEM(res, 1); + Py_INCREF(op->defaults_kwdict); + #else + op->defaults_tuple = PySequence_ITEM(res, 0); + if (unlikely(!op->defaults_tuple)) result = -1; + else { + op->defaults_kwdict = PySequence_ITEM(res, 1); + if (unlikely(!op->defaults_kwdict)) result = -1; + } + #endif + Py_DECREF(res); + return result; +} +static int +__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value) { + PyObject* tmp; + if (!value) { + value = Py_None; + } else if (value != Py_None && !PyTuple_Check(value)) { + PyErr_SetString(PyExc_TypeError, + "__defaults__ must be set to a tuple object"); + return -1; + } + Py_INCREF(value); + tmp = op->defaults_tuple; + op->defaults_tuple = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op) { + PyObject* result = op->defaults_tuple; + if (unlikely(!result)) { + if (op->defaults_getter) { + if (__Pyx_CyFunction_init_defaults(op) < 0) return NULL; + result = op->defaults_tuple; + } else { + result = Py_None; + } + } + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value) { + PyObject* tmp; + if (!value) { + value = Py_None; + } else if (value != Py_None && !PyDict_Check(value)) { + PyErr_SetString(PyExc_TypeError, + "__kwdefaults__ must be set to a dict object"); + return -1; + } + Py_INCREF(value); + tmp = op->defaults_kwdict; + op->defaults_kwdict = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op) { + PyObject* result = op->defaults_kwdict; + if (unlikely(!result)) { + if (op->defaults_getter) { + if (__Pyx_CyFunction_init_defaults(op) < 0) return NULL; + result = op->defaults_kwdict; + } else { + result = Py_None; + } + } + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value) { + PyObject* tmp; + if (!value || value == Py_None) { + value = NULL; + } else if (!PyDict_Check(value)) { + PyErr_SetString(PyExc_TypeError, + "__annotations__ must be set to a dict object"); + return -1; + } + Py_XINCREF(value); + tmp = op->func_annotations; + op->func_annotations = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op) { + PyObject* result = op->func_annotations; + if (unlikely(!result)) { + result = PyDict_New(); + if (unlikely(!result)) return NULL; + op->func_annotations = result; + } + Py_INCREF(result); + return result; +} +static PyGetSetDef __pyx_CyFunction_getsets[] = { + {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {(char *) "__doc__", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0}, + {(char *) "__self__", (getter)__Pyx_CyFunction_get_self, 0, 0, 0}, + {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0}, + {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0}, + {0, 0, 0, 0, 0} +}; +static PyMemberDef __pyx_CyFunction_members[] = { + {(char *) "__module__", T_OBJECT, offsetof(__pyx_CyFunctionObject, func.m_module), PY_WRITE_RESTRICTED, 0}, + {0, 0, 0, 0, 0} +}; +static PyObject * +__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, CYTHON_UNUSED PyObject *args) +{ +#if PY_MAJOR_VERSION >= 3 + return PyUnicode_FromString(m->func.m_ml->ml_name); +#else + return PyString_FromString(m->func.m_ml->ml_name); +#endif +} +static PyMethodDef __pyx_CyFunction_methods[] = { + {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0}, + {0, 0, 0, 0} +}; +#if PY_VERSION_HEX < 0x030500A0 +#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist) +#else +#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func.m_weakreflist) +#endif +static PyObject *__Pyx_CyFunction_New(PyTypeObject *type, PyMethodDef *ml, int flags, PyObject* qualname, + PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { + __pyx_CyFunctionObject *op = PyObject_GC_New(__pyx_CyFunctionObject, type); + if (op == NULL) + return NULL; + op->flags = flags; + __Pyx_CyFunction_weakreflist(op) = NULL; + op->func.m_ml = ml; + op->func.m_self = (PyObject *) op; + Py_XINCREF(closure); + op->func_closure = closure; + Py_XINCREF(module); + op->func.m_module = module; + op->func_dict = NULL; + op->func_name = NULL; + Py_INCREF(qualname); + op->func_qualname = qualname; + op->func_doc = NULL; + op->func_classobj = NULL; + op->func_globals = globals; + Py_INCREF(op->func_globals); + Py_XINCREF(code); + op->func_code = code; + op->defaults_pyobjects = 0; + op->defaults = NULL; + op->defaults_tuple = NULL; + op->defaults_kwdict = NULL; + op->defaults_getter = NULL; + op->func_annotations = NULL; + PyObject_GC_Track(op); + return (PyObject *) op; +} +static int +__Pyx_CyFunction_clear(__pyx_CyFunctionObject *m) +{ + Py_CLEAR(m->func_closure); + Py_CLEAR(m->func.m_module); + Py_CLEAR(m->func_dict); + Py_CLEAR(m->func_name); + Py_CLEAR(m->func_qualname); + Py_CLEAR(m->func_doc); + Py_CLEAR(m->func_globals); + Py_CLEAR(m->func_code); + Py_CLEAR(m->func_classobj); + Py_CLEAR(m->defaults_tuple); + Py_CLEAR(m->defaults_kwdict); + Py_CLEAR(m->func_annotations); + if (m->defaults) { + PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); + int i; + for (i = 0; i < m->defaults_pyobjects; i++) + Py_XDECREF(pydefaults[i]); + PyObject_Free(m->defaults); + m->defaults = NULL; + } + return 0; +} +static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m) +{ + PyObject_GC_UnTrack(m); + if (__Pyx_CyFunction_weakreflist(m) != NULL) + PyObject_ClearWeakRefs((PyObject *) m); + __Pyx_CyFunction_clear(m); + PyObject_GC_Del(m); +} +static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg) +{ + Py_VISIT(m->func_closure); + Py_VISIT(m->func.m_module); + Py_VISIT(m->func_dict); + Py_VISIT(m->func_name); + Py_VISIT(m->func_qualname); + Py_VISIT(m->func_doc); + Py_VISIT(m->func_globals); + Py_VISIT(m->func_code); + Py_VISIT(m->func_classobj); + Py_VISIT(m->defaults_tuple); + Py_VISIT(m->defaults_kwdict); + if (m->defaults) { + PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); + int i; + for (i = 0; i < m->defaults_pyobjects; i++) + Py_VISIT(pydefaults[i]); + } + return 0; +} +static PyObject *__Pyx_CyFunction_descr_get(PyObject *func, PyObject *obj, PyObject *type) +{ + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + if (m->flags & __Pyx_CYFUNCTION_STATICMETHOD) { + Py_INCREF(func); + return func; + } + if (m->flags & __Pyx_CYFUNCTION_CLASSMETHOD) { + if (type == NULL) + type = (PyObject *)(Py_TYPE(obj)); + return __Pyx_PyMethod_New(func, type, (PyObject *)(Py_TYPE(type))); + } + if (obj == Py_None) + obj = NULL; + return __Pyx_PyMethod_New(func, obj, type); +} +static PyObject* +__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op) +{ +#if PY_MAJOR_VERSION >= 3 + return PyUnicode_FromFormat("", + op->func_qualname, (void *)op); +#else + return PyString_FromFormat("", + PyString_AsString(op->func_qualname), (void *)op); +#endif +} +static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) { + PyCFunctionObject* f = (PyCFunctionObject*)func; + PyCFunction meth = f->m_ml->ml_meth; + Py_ssize_t size; + switch (f->m_ml->ml_flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) { + case METH_VARARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) + return (*meth)(self, arg); + break; + case METH_VARARGS | METH_KEYWORDS: + return (*(PyCFunctionWithKeywords)meth)(self, arg, kw); + case METH_NOARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { + size = PyTuple_GET_SIZE(arg); + if (likely(size == 0)) + return (*meth)(self, NULL); + PyErr_Format(PyExc_TypeError, + "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", + f->m_ml->ml_name, size); + return NULL; + } + break; + case METH_O: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { + size = PyTuple_GET_SIZE(arg); + if (likely(size == 1)) { + PyObject *result, *arg0 = PySequence_ITEM(arg, 0); + if (unlikely(!arg0)) return NULL; + result = (*meth)(self, arg0); + Py_DECREF(arg0); + return result; + } + PyErr_Format(PyExc_TypeError, + "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", + f->m_ml->ml_name, size); + return NULL; + } + break; + default: + PyErr_SetString(PyExc_SystemError, "Bad call flags in " + "__Pyx_CyFunction_Call. METH_OLDARGS is no " + "longer supported!"); + return NULL; + } + PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments", + f->m_ml->ml_name); + return NULL; +} +static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) { + return __Pyx_CyFunction_CallMethod(func, ((PyCFunctionObject*)func)->m_self, arg, kw); +} +static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) { + PyObject *result; + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func; + if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { + Py_ssize_t argc; + PyObject *new_args; + PyObject *self; + argc = PyTuple_GET_SIZE(args); + new_args = PyTuple_GetSlice(args, 1, argc); + if (unlikely(!new_args)) + return NULL; + self = PyTuple_GetItem(args, 0); + if (unlikely(!self)) { + Py_DECREF(new_args); + return NULL; + } + result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw); + Py_DECREF(new_args); + } else { + result = __Pyx_CyFunction_Call(func, args, kw); + } + return result; +} +static PyTypeObject __pyx_CyFunctionType_type = { + PyVarObject_HEAD_INIT(0, 0) + "cython_function_or_method", + sizeof(__pyx_CyFunctionObject), + 0, + (destructor) __Pyx_CyFunction_dealloc, + 0, + 0, + 0, +#if PY_MAJOR_VERSION < 3 + 0, +#else + 0, +#endif + (reprfunc) __Pyx_CyFunction_repr, + 0, + 0, + 0, + 0, + __Pyx_CyFunction_CallAsMethod, + 0, + 0, + 0, + 0, + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, + 0, + (traverseproc) __Pyx_CyFunction_traverse, + (inquiry) __Pyx_CyFunction_clear, + 0, +#if PY_VERSION_HEX < 0x030500A0 + offsetof(__pyx_CyFunctionObject, func_weakreflist), +#else + offsetof(PyCFunctionObject, m_weakreflist), +#endif + 0, + 0, + __pyx_CyFunction_methods, + __pyx_CyFunction_members, + __pyx_CyFunction_getsets, + 0, + 0, + __Pyx_CyFunction_descr_get, + 0, + offsetof(__pyx_CyFunctionObject, func_dict), + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, +#if PY_VERSION_HEX >= 0x030400a1 + 0, +#endif +}; +static int __pyx_CyFunction_init(void) { + __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type); + if (__pyx_CyFunctionType == NULL) { + return -1; + } + return 0; +} +static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults = PyObject_Malloc(size); + if (!m->defaults) + return PyErr_NoMemory(); + memset(m->defaults, 0, size); + m->defaults_pyobjects = pyobjects; + return m->defaults; +} +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults_tuple = tuple; + Py_INCREF(tuple); +} +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults_kwdict = dict; + Py_INCREF(dict); +} +static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->func_annotations = dict; + Py_INCREF(dict); +} + +/* CodeObjectCache */ + static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { + int start = 0, mid = 0, end = count - 1; + if (end >= 0 && code_line > entries[end].code_line) { + return count; + } + while (start < end) { + mid = start + (end - start) / 2; + if (code_line < entries[mid].code_line) { + end = mid; + } else if (code_line > entries[mid].code_line) { + start = mid + 1; + } else { + return mid; + } + } + if (code_line <= entries[mid].code_line) { + return mid; + } else { + return mid + 1; + } +} +static PyCodeObject *__pyx_find_code_object(int code_line) { + PyCodeObject* code_object; + int pos; + if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { + return NULL; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { + return NULL; + } + code_object = __pyx_code_cache.entries[pos].code_object; + Py_INCREF(code_object); + return code_object; +} +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { + int pos, i; + __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; + if (unlikely(!code_line)) { + return; + } + if (unlikely(!entries)) { + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); + if (likely(entries)) { + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = 64; + __pyx_code_cache.count = 1; + entries[0].code_line = code_line; + entries[0].code_object = code_object; + Py_INCREF(code_object); + } + return; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { + PyCodeObject* tmp = entries[pos].code_object; + entries[pos].code_object = code_object; + Py_DECREF(tmp); + return; + } + if (__pyx_code_cache.count == __pyx_code_cache.max_count) { + int new_max = __pyx_code_cache.max_count + 64; + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( + __pyx_code_cache.entries, (size_t)new_max*sizeof(__Pyx_CodeObjectCacheEntry)); + if (unlikely(!entries)) { + return; + } + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = new_max; + } + for (i=__pyx_code_cache.count; i>pos; i--) { + entries[i] = entries[i-1]; + } + entries[pos].code_line = code_line; + entries[pos].code_object = code_object; + __pyx_code_cache.count++; + Py_INCREF(code_object); +} + +/* AddTraceback */ + #include "compile.h" +#include "frameobject.h" +#include "traceback.h" +static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( + const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyObject *py_srcfile = 0; + PyObject *py_funcname = 0; + #if PY_MAJOR_VERSION < 3 + py_srcfile = PyString_FromString(filename); + #else + py_srcfile = PyUnicode_FromString(filename); + #endif + if (!py_srcfile) goto bad; + if (c_line) { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #else + py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #endif + } + else { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromString(funcname); + #else + py_funcname = PyUnicode_FromString(funcname); + #endif + } + if (!py_funcname) goto bad; + py_code = __Pyx_PyCode_New( + 0, + 0, + 0, + 0, + 0, + __pyx_empty_bytes, /*PyObject *code,*/ + __pyx_empty_tuple, /*PyObject *consts,*/ + __pyx_empty_tuple, /*PyObject *names,*/ + __pyx_empty_tuple, /*PyObject *varnames,*/ + __pyx_empty_tuple, /*PyObject *freevars,*/ + __pyx_empty_tuple, /*PyObject *cellvars,*/ + py_srcfile, /*PyObject *filename,*/ + py_funcname, /*PyObject *name,*/ + py_line, + __pyx_empty_bytes /*PyObject *lnotab*/ + ); + Py_DECREF(py_srcfile); + Py_DECREF(py_funcname); + return py_code; +bad: + Py_XDECREF(py_srcfile); + Py_XDECREF(py_funcname); + return NULL; +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyFrameObject *py_frame = 0; + py_code = __pyx_find_code_object(c_line ? c_line : py_line); + if (!py_code) { + py_code = __Pyx_CreateCodeObjectForTraceback( + funcname, c_line, py_line, filename); + if (!py_code) goto bad; + __pyx_insert_code_object(c_line ? c_line : py_line, py_code); + } + py_frame = PyFrame_New( + PyThreadState_GET(), /*PyThreadState *tstate,*/ + py_code, /*PyCodeObject *code,*/ + __pyx_d, /*PyObject *globals,*/ + 0 /*PyObject *locals*/ + ); + if (!py_frame) goto bad; + __Pyx_PyFrame_SetLineNumber(py_frame, py_line); + PyTraceBack_Here(py_frame); +bad: + Py_XDECREF(py_code); + Py_XDECREF(py_frame); +} + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { + const long neg_one = (long) -1, const_zero = (long) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(long) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(long) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(long) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(long), + little, !is_unsigned); + } +} + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { + const int neg_one = (int) -1, const_zero = (int) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(int) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(int) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(int) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(int), + little, !is_unsigned); + } +} + +/* CIntFromPyVerify */ + #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) +#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) +#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ + {\ + func_type value = func_value;\ + if (sizeof(target_type) < sizeof(func_type)) {\ + if (unlikely(value != (func_type) (target_type) value)) {\ + func_type zero = 0;\ + if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ + return (target_type) -1;\ + if (is_unsigned && unlikely(value < zero))\ + goto raise_neg_overflow;\ + else\ + goto raise_overflow;\ + }\ + }\ + return (target_type) value;\ + } + +/* CIntFromPy */ + static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { + const int neg_one = (int) -1, const_zero = (int) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(int) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (int) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { + return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { + return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { + return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(int) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) + case -2: + if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + } +#endif + if (sizeof(int) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + int val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (int) -1; + } + } else { + int val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (int) -1; + val = __Pyx_PyInt_As_int(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to int"); + return (int) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to int"); + return (int) -1; +} + +/* CIntFromPy */ + static CYTHON_INLINE unsigned short __Pyx_PyInt_As_unsigned_short(PyObject *x) { + const unsigned short neg_one = (unsigned short) -1, const_zero = (unsigned short) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(unsigned short) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(unsigned short, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (unsigned short) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (unsigned short) 0; + case 1: __PYX_VERIFY_RETURN_INT(unsigned short, digit, digits[0]) + case 2: + if (8 * sizeof(unsigned short) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(unsigned short, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(unsigned short) >= 2 * PyLong_SHIFT) { + return (unsigned short) (((((unsigned short)digits[1]) << PyLong_SHIFT) | (unsigned short)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(unsigned short) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(unsigned short, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(unsigned short) >= 3 * PyLong_SHIFT) { + return (unsigned short) (((((((unsigned short)digits[2]) << PyLong_SHIFT) | (unsigned short)digits[1]) << PyLong_SHIFT) | (unsigned short)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(unsigned short) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(unsigned short, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(unsigned short) >= 4 * PyLong_SHIFT) { + return (unsigned short) (((((((((unsigned short)digits[3]) << PyLong_SHIFT) | (unsigned short)digits[2]) << PyLong_SHIFT) | (unsigned short)digits[1]) << PyLong_SHIFT) | (unsigned short)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (unsigned short) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(unsigned short) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(unsigned short, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(unsigned short) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(unsigned short, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (unsigned short) 0; + case -1: __PYX_VERIFY_RETURN_INT(unsigned short, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(unsigned short, digit, +digits[0]) + case -2: + if (8 * sizeof(unsigned short) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(unsigned short, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(unsigned short) - 1 > 2 * PyLong_SHIFT) { + return (unsigned short) (((unsigned short)-1)*(((((unsigned short)digits[1]) << PyLong_SHIFT) | (unsigned short)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(unsigned short) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(unsigned short, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(unsigned short) - 1 > 2 * PyLong_SHIFT) { + return (unsigned short) ((((((unsigned short)digits[1]) << PyLong_SHIFT) | (unsigned short)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(unsigned short) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(unsigned short, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(unsigned short) - 1 > 3 * PyLong_SHIFT) { + return (unsigned short) (((unsigned short)-1)*(((((((unsigned short)digits[2]) << PyLong_SHIFT) | (unsigned short)digits[1]) << PyLong_SHIFT) | (unsigned short)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(unsigned short) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(unsigned short, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(unsigned short) - 1 > 3 * PyLong_SHIFT) { + return (unsigned short) ((((((((unsigned short)digits[2]) << PyLong_SHIFT) | (unsigned short)digits[1]) << PyLong_SHIFT) | (unsigned short)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(unsigned short) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(unsigned short, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(unsigned short) - 1 > 4 * PyLong_SHIFT) { + return (unsigned short) (((unsigned short)-1)*(((((((((unsigned short)digits[3]) << PyLong_SHIFT) | (unsigned short)digits[2]) << PyLong_SHIFT) | (unsigned short)digits[1]) << PyLong_SHIFT) | (unsigned short)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(unsigned short) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(unsigned short, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(unsigned short) - 1 > 4 * PyLong_SHIFT) { + return (unsigned short) ((((((((((unsigned short)digits[3]) << PyLong_SHIFT) | (unsigned short)digits[2]) << PyLong_SHIFT) | (unsigned short)digits[1]) << PyLong_SHIFT) | (unsigned short)digits[0]))); + } + } + break; + } +#endif + if (sizeof(unsigned short) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(unsigned short, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(unsigned short) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(unsigned short, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + unsigned short val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (unsigned short) -1; + } + } else { + unsigned short val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (unsigned short) -1; + val = __Pyx_PyInt_As_unsigned_short(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to unsigned short"); + return (unsigned short) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to unsigned short"); + return (unsigned short) -1; +} + +/* CIntFromPy */ + static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { + const long neg_one = (long) -1, const_zero = (long) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(long) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (long) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { + return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { + return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { + return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (long) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(long) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) + case -2: + if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + } +#endif + if (sizeof(long) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + long val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (long) -1; + } + } else { + long val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (long) -1; + val = __Pyx_PyInt_As_long(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to long"); + return (long) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to long"); + return (long) -1; +} + +/* CheckBinaryVersion */ + static int __Pyx_check_binary_version(void) { + char ctversion[4], rtversion[4]; + PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); + PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion()); + if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) { + char message[200]; + PyOS_snprintf(message, sizeof(message), + "compiletime version %s of module '%.100s' " + "does not match runtime version %s", + ctversion, __Pyx_MODULE_NAME, rtversion); + return PyErr_WarnEx(NULL, message, 1); + } + return 0; +} + +/* InitStrings */ + static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { + while (t->p) { + #if PY_MAJOR_VERSION < 3 + if (t->is_unicode) { + *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); + } else if (t->intern) { + *t->p = PyString_InternFromString(t->s); + } else { + *t->p = PyString_FromStringAndSize(t->s, t->n - 1); + } + #else + if (t->is_unicode | t->is_str) { + if (t->intern) { + *t->p = PyUnicode_InternFromString(t->s); + } else if (t->encoding) { + *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); + } else { + *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); + } + } else { + *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); + } + #endif + if (!*t->p) + return -1; + ++t; + } + return 0; +} + +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { + return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); +} +static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject* o) { + Py_ssize_t ignore; + return __Pyx_PyObject_AsStringAndSize(o, &ignore); +} +static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { +#if CYTHON_COMPILING_IN_CPYTHON && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) + if ( +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + __Pyx_sys_getdefaultencoding_not_ascii && +#endif + PyUnicode_Check(o)) { +#if PY_VERSION_HEX < 0x03030000 + char* defenc_c; + PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); + if (!defenc) return NULL; + defenc_c = PyBytes_AS_STRING(defenc); +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + { + char* end = defenc_c + PyBytes_GET_SIZE(defenc); + char* c; + for (c = defenc_c; c < end; c++) { + if ((unsigned char) (*c) >= 128) { + PyUnicode_AsASCIIString(o); + return NULL; + } + } + } +#endif + *length = PyBytes_GET_SIZE(defenc); + return defenc_c; +#else + if (__Pyx_PyUnicode_READY(o) == -1) return NULL; +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + if (PyUnicode_IS_ASCII(o)) { + *length = PyUnicode_GET_LENGTH(o); + return PyUnicode_AsUTF8(o); + } else { + PyUnicode_AsASCIIString(o); + return NULL; + } +#else + return PyUnicode_AsUTF8AndSize(o, length); +#endif +#endif + } else +#endif +#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) + if (PyByteArray_Check(o)) { + *length = PyByteArray_GET_SIZE(o); + return PyByteArray_AS_STRING(o); + } else +#endif + { + char* result; + int r = PyBytes_AsStringAndSize(o, &result, length); + if (unlikely(r < 0)) { + return NULL; + } else { + return result; + } + } +} +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { + int is_true = x == Py_True; + if (is_true | (x == Py_False) | (x == Py_None)) return is_true; + else return PyObject_IsTrue(x); +} +static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { +#if CYTHON_USE_TYPE_SLOTS + PyNumberMethods *m; +#endif + const char *name = NULL; + PyObject *res = NULL; +#if PY_MAJOR_VERSION < 3 + if (PyInt_Check(x) || PyLong_Check(x)) +#else + if (PyLong_Check(x)) +#endif + return __Pyx_NewRef(x); +#if CYTHON_USE_TYPE_SLOTS + m = Py_TYPE(x)->tp_as_number; + #if PY_MAJOR_VERSION < 3 + if (m && m->nb_int) { + name = "int"; + res = PyNumber_Int(x); + } + else if (m && m->nb_long) { + name = "long"; + res = PyNumber_Long(x); + } + #else + if (m && m->nb_int) { + name = "int"; + res = PyNumber_Long(x); + } + #endif +#else + res = PyNumber_Int(x); +#endif + if (res) { +#if PY_MAJOR_VERSION < 3 + if (!PyInt_Check(res) && !PyLong_Check(res)) { +#else + if (!PyLong_Check(res)) { +#endif + PyErr_Format(PyExc_TypeError, + "__%.4s__ returned non-%.4s (type %.200s)", + name, name, Py_TYPE(res)->tp_name); + Py_DECREF(res); + return NULL; + } + } + else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, + "an integer is required"); + } + return res; +} +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { + Py_ssize_t ival; + PyObject *x; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(b))) { + if (sizeof(Py_ssize_t) >= sizeof(long)) + return PyInt_AS_LONG(b); + else + return PyInt_AsSsize_t(x); + } +#endif + if (likely(PyLong_CheckExact(b))) { + #if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)b)->ob_digit; + const Py_ssize_t size = Py_SIZE(b); + if (likely(__Pyx_sst_abs(size) <= 1)) { + ival = likely(size) ? digits[0] : 0; + if (size == -1) ival = -ival; + return ival; + } else { + switch (size) { + case 2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + } + } + #endif + return PyLong_AsSsize_t(b); + } + x = PyNumber_Index(b); + if (!x) return -1; + ival = PyInt_AsSsize_t(x); + Py_DECREF(x); + return ival; +} +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { + return PyInt_FromSize_t(ival); +} + + +#endif /* Py_PYTHON_H */ diff --git a/python/gevent/gevent.ares.h b/python/gevent/gevent.ares.h new file mode 100644 index 0000000..25ba041 --- /dev/null +++ b/python/gevent/gevent.ares.h @@ -0,0 +1,48 @@ +/* Generated by Cython 0.25.2 */ + +#ifndef __PYX_HAVE__gevent__ares +#define __PYX_HAVE__gevent__ares + +struct PyGeventAresChannelObject; + +/* "gevent/ares.pyx":245 + * + * + * cdef public class channel [object PyGeventAresChannelObject, type PyGeventAresChannel_Type]: # <<<<<<<<<<<<<< + * + * cdef public object loop + */ +struct PyGeventAresChannelObject { + PyObject_HEAD + struct __pyx_vtabstruct_6gevent_4ares_channel *__pyx_vtab; + PyObject *loop; + struct ares_channeldata *channel; + PyObject *_watchers; + PyObject *_timer; +}; + +#ifndef __PYX_HAVE_API__gevent__ares + +#ifndef __PYX_EXTERN_C + #ifdef __cplusplus + #define __PYX_EXTERN_C extern "C" + #else + #define __PYX_EXTERN_C extern + #endif +#endif + +#ifndef DL_IMPORT + #define DL_IMPORT(_T) _T +#endif + +__PYX_EXTERN_C DL_IMPORT(PyTypeObject) PyGeventAresChannel_Type; + +#endif /* !__PYX_HAVE_API__gevent__ares */ + +#if PY_MAJOR_VERSION < 3 +PyMODINIT_FUNC initares(void); +#else +PyMODINIT_FUNC PyInit_ares(void); +#endif + +#endif /* !__PYX_HAVE__gevent__ares */ diff --git a/python/gevent/greenlet.py b/python/gevent/greenlet.py new file mode 100644 index 0000000..1378dd7 --- /dev/null +++ b/python/gevent/greenlet.py @@ -0,0 +1,744 @@ +# Copyright (c) 2009-2012 Denis Bilenko. See LICENSE for details. +from __future__ import absolute_import +import sys +from greenlet import greenlet +from gevent._compat import PY3 +from gevent._compat import PYPY +from gevent._compat import reraise +from gevent._util import Lazy +from gevent._tblib import dump_traceback +from gevent._tblib import load_traceback +from gevent.hub import GreenletExit +from gevent.hub import InvalidSwitchError +from gevent.hub import Waiter +from gevent.hub import get_hub +from gevent.hub import getcurrent +from gevent.hub import iwait +from gevent.hub import wait +from gevent.timeout import Timeout +from collections import deque + + +__all__ = [ + 'Greenlet', + 'joinall', + 'killall', +] + + +if PYPY: + import _continuation # pylint:disable=import-error + _continulet = _continuation.continulet + + +class SpawnedLink(object): + """A wrapper around link that calls it in another greenlet. + + Can be called only from main loop. + """ + __slots__ = ['callback'] + + def __init__(self, callback): + if not callable(callback): + raise TypeError("Expected callable: %r" % (callback, )) + self.callback = callback + + def __call__(self, source): + g = greenlet(self.callback, get_hub()) + g.switch(source) + + def __hash__(self): + return hash(self.callback) + + def __eq__(self, other): + return self.callback == getattr(other, 'callback', other) + + def __str__(self): + return str(self.callback) + + def __repr__(self): + return repr(self.callback) + + def __getattr__(self, item): + assert item != 'callback' + return getattr(self.callback, item) + + +class SuccessSpawnedLink(SpawnedLink): + """A wrapper around link that calls it in another greenlet only if source succeed. + + Can be called only from main loop. + """ + __slots__ = [] + + def __call__(self, source): + if source.successful(): + return SpawnedLink.__call__(self, source) + + +class FailureSpawnedLink(SpawnedLink): + """A wrapper around link that calls it in another greenlet only if source failed. + + Can be called only from main loop. + """ + __slots__ = [] + + def __call__(self, source): + if not source.successful(): + return SpawnedLink.__call__(self, source) + +class Greenlet(greenlet): + """A light-weight cooperatively-scheduled execution unit. + """ + # pylint:disable=too-many-public-methods,too-many-instance-attributes + + value = None + _exc_info = () + _notifier = None + + #: An event, such as a timer or a callback that fires. It is established in + #: start() and start_later() as those two objects, respectively. + #: Once this becomes non-None, the Greenlet cannot be started again. Conversely, + #: kill() and throw() check for non-None to determine if this object has ever been + #: scheduled for starting. A placeholder _dummy_event is assigned by them to prevent + #: the greenlet from being started in the future, if necessary. + _start_event = None + args = () + _kwargs = None + + def __init__(self, run=None, *args, **kwargs): + """ + Greenlet constructor. + + :param args: The arguments passed to the ``run`` function. + :param kwargs: The keyword arguments passed to the ``run`` function. + :keyword run: The callable object to run. If not given, this object's + `_run` method will be invoked (typically defined by subclasses). + + .. versionchanged:: 1.1b1 + The ``run`` argument to the constructor is now verified to be a callable + object. Previously, passing a non-callable object would fail after the greenlet + was spawned. + """ + # greenlet.greenlet(run=None, parent=None) + # Calling it with both positional arguments instead of a keyword + # argument (parent=get_hub()) speeds up creation of this object ~30%: + # python -m timeit -s 'import gevent' 'gevent.Greenlet()' + # Python 3.5: 2.70usec with keywords vs 1.94usec with positional + # Python 3.4: 2.32usec with keywords vs 1.74usec with positional + # Python 3.3: 2.55usec with keywords vs 1.92usec with positional + # Python 2.7: 1.73usec with keywords vs 1.40usec with positional + greenlet.__init__(self, None, get_hub()) + + if run is not None: + self._run = run + + # If they didn't pass a callable at all, then they must + # already have one. Note that subclassing to override the run() method + # itself has never been documented or supported. + if not callable(self._run): + raise TypeError("The run argument or self._run must be callable") + + if args: + self.args = args + if kwargs: + self._kwargs = kwargs + + @property + def kwargs(self): + return self._kwargs or {} + + @Lazy + def _links(self): + return deque() + + def _has_links(self): + return '_links' in self.__dict__ and self._links + + def _raise_exception(self): + reraise(*self.exc_info) + + @property + def loop(self): + # needed by killall + return self.parent.loop + + def __bool__(self): + return self._start_event is not None and self._exc_info is Greenlet._exc_info + __nonzero__ = __bool__ + + ### Lifecycle + + if PYPY: + # oops - pypy's .dead relies on __nonzero__ which we overriden above + @property + def dead(self): + if self._greenlet__main: + return False + if self.__start_cancelled_by_kill or self.__started_but_aborted: + return True + + return self._greenlet__started and not _continulet.is_pending(self) + else: + @property + def dead(self): + return self.__start_cancelled_by_kill or self.__started_but_aborted or greenlet.dead.__get__(self) + + @property + def __never_started_or_killed(self): + return self._start_event is None + + @property + def __start_pending(self): + return (self._start_event is not None + and (self._start_event.pending or getattr(self._start_event, 'active', False))) + + @property + def __start_cancelled_by_kill(self): + return self._start_event is _cancelled_start_event + + @property + def __start_completed(self): + return self._start_event is _start_completed_event + + @property + def __started_but_aborted(self): + return (not self.__never_started_or_killed # we have been started or killed + and not self.__start_cancelled_by_kill # we weren't killed, so we must have been started + and not self.__start_completed # the start never completed + and not self.__start_pending) # and we're not pending, so we must have been aborted + + def __cancel_start(self): + if self._start_event is None: + # prevent self from ever being started in the future + self._start_event = _cancelled_start_event + # cancel any pending start event + # NOTE: If this was a real pending start event, this will leave a + # "dangling" callback/timer object in the hub.loop.callbacks list; + # depending on where we are in the event loop, it may even be in a local + # variable copy of that list (in _run_callbacks). This isn't a problem, + # except for the leak-tests. + self._start_event.stop() + + def __handle_death_before_start(self, *args): + # args is (t, v, tb) or simply t or v + if self._exc_info is Greenlet._exc_info and self.dead: + # the greenlet was never switched to before and it will never be, _report_error was not called + # the result was not set and the links weren't notified. let's do it here. + # checking that self.dead is true is essential, because throw() does not necessarily kill the greenlet + # (if the exception raised by throw() is caught somewhere inside the greenlet). + if len(args) == 1: + arg = args[0] + #if isinstance(arg, type): + if type(arg) is type(Exception): + args = (arg, arg(), None) + else: + args = (type(arg), arg, None) + elif not args: + args = (GreenletExit, GreenletExit(), None) + self._report_error(args) + + @property + def started(self): + # DEPRECATED + return bool(self) + + def ready(self): + """ + Return a true value if and only if the greenlet has finished + execution. + + .. versionchanged:: 1.1 + This function is only guaranteed to return true or false *values*, not + necessarily the literal constants ``True`` or ``False``. + """ + return self.dead or self._exc_info + + def successful(self): + """ + Return a true value if and only if the greenlet has finished execution + successfully, that is, without raising an error. + + .. tip:: A greenlet that has been killed with the default + :class:`GreenletExit` exception is considered successful. + That is, ``GreenletExit`` is not considered an error. + + .. note:: This function is only guaranteed to return true or false *values*, + not necessarily the literal constants ``True`` or ``False``. + """ + return self._exc_info and self._exc_info[1] is None + + def __repr__(self): + classname = self.__class__.__name__ + result = '<%s at %s' % (classname, hex(id(self))) + formatted = self._formatinfo() + if formatted: + result += ': ' + formatted + return result + '>' + + _formatted_info = None + + def _formatinfo(self): + info = self._formatted_info + if info is not None: + return info + + try: + result = getfuncname(self.__dict__['_run']) + except Exception: # pylint:disable=broad-except + # Don't cache + return '' + + args = [] + if self.args: + args = [repr(x)[:50] for x in self.args] + if self._kwargs: + args.extend(['%s=%s' % (key, repr(value)[:50]) for (key, value) in self._kwargs.items()]) + if args: + result += '(' + ', '.join(args) + ')' + # it is important to save the result here, because once the greenlet exits '_run' attribute will be removed + self._formatted_info = result + return result + + @property + def exception(self): + """Holds the exception instance raised by the function if the greenlet has finished with an error. + Otherwise ``None``. + """ + return self._exc_info[1] if self._exc_info else None + + @property + def exc_info(self): + """ + Holds the exc_info three-tuple raised by the function if the + greenlet finished with an error. Otherwise a false value. + + .. note:: This is a provisional API and may change. + + .. versionadded:: 1.1 + """ + e = self._exc_info + if e and e[0] is not None: + return (e[0], e[1], load_traceback(e[2])) + + def throw(self, *args): + """Immediatelly switch into the greenlet and raise an exception in it. + + Should only be called from the HUB, otherwise the current greenlet is left unscheduled forever. + To raise an exception in a safe manner from any greenlet, use :meth:`kill`. + + If a greenlet was started but never switched to yet, then also + a) cancel the event that will start it + b) fire the notifications as if an exception was raised in a greenlet + """ + self.__cancel_start() + + try: + if not self.dead: + # Prevent switching into a greenlet *at all* if we had never + # started it. Usually this is the same thing that happens by throwing, + # but if this is done from the hub with nothing else running, prevents a + # LoopExit. + greenlet.throw(self, *args) + finally: + self.__handle_death_before_start(*args) + + def start(self): + """Schedule the greenlet to run in this loop iteration""" + if self._start_event is None: + self._start_event = self.parent.loop.run_callback(self.switch) + + def start_later(self, seconds): + """Schedule the greenlet to run in the future loop iteration *seconds* later""" + if self._start_event is None: + self._start_event = self.parent.loop.timer(seconds) + self._start_event.start(self.switch) + + @classmethod + def spawn(cls, *args, **kwargs): + """ + Create a new :class:`Greenlet` object and schedule it to run ``function(*args, **kwargs)``. + This can be used as ``gevent.spawn`` or ``Greenlet.spawn``. + + The arguments are passed to :meth:`Greenlet.__init__`. + + .. versionchanged:: 1.1b1 + If a *function* is given that is not callable, immediately raise a :exc:`TypeError` + instead of spawning a greenlet that will raise an uncaught TypeError. + """ + g = cls(*args, **kwargs) + g.start() + return g + + @classmethod + def spawn_later(cls, seconds, *args, **kwargs): + """ + Create and return a new Greenlet object scheduled to run ``function(*args, **kwargs)`` + in the future loop iteration *seconds* later. This can be used as ``Greenlet.spawn_later`` + or ``gevent.spawn_later``. + + The arguments are passed to :meth:`Greenlet.__init__`. + + .. versionchanged:: 1.1b1 + If an argument that's meant to be a function (the first argument in *args*, or the ``run`` keyword ) + is given to this classmethod (and not a classmethod of a subclass), + it is verified to be callable. Previously, the spawned greenlet would have failed + when it started running. + """ + if cls is Greenlet and not args and 'run' not in kwargs: + raise TypeError("") + g = cls(*args, **kwargs) + g.start_later(seconds) + return g + + def kill(self, exception=GreenletExit, block=True, timeout=None): + """ + Raise the ``exception`` in the greenlet. + + If ``block`` is ``True`` (the default), wait until the greenlet dies or the optional timeout expires. + If block is ``False``, the current greenlet is not unscheduled. + + The function always returns ``None`` and never raises an error. + + .. note:: + + Depending on what this greenlet is executing and the state + of the event loop, the exception may or may not be raised + immediately when this greenlet resumes execution. It may + be raised on a subsequent green call, or, if this greenlet + exits before making such a call, it may not be raised at + all. As of 1.1, an example where the exception is raised + later is if this greenlet had called :func:`sleep(0) + `; an example where the exception is raised + immediately is if this greenlet had called + :func:`sleep(0.1) `. + + .. caution:: + + Use care when killing greenlets. If the code executing is not + exception safe (e.g., makes proper use of ``finally``) then an + unexpected exception could result in corrupted state. + + See also :func:`gevent.kill`. + + :keyword type exception: The type of exception to raise in the greenlet. The default + is :class:`GreenletExit`, which indicates a :meth:`successful` completion + of the greenlet. + + .. versionchanged:: 0.13.0 + *block* is now ``True`` by default. + .. versionchanged:: 1.1a2 + If this greenlet had never been switched to, killing it will prevent it from ever being switched to. + """ + self.__cancel_start() + + if self.dead: + self.__handle_death_before_start(exception) + else: + waiter = Waiter() if block else None + self.parent.loop.run_callback(_kill, self, exception, waiter) + if block: + waiter.get() + self.join(timeout) + # it should be OK to use kill() in finally or kill a greenlet from more than one place; + # thus it should not raise when the greenlet is already killed (= not started) + + def get(self, block=True, timeout=None): + """Return the result the greenlet has returned or re-raise the exception it has raised. + + If block is ``False``, raise :class:`gevent.Timeout` if the greenlet is still alive. + If block is ``True``, unschedule the current greenlet until the result is available + or the timeout expires. In the latter case, :class:`gevent.Timeout` is raised. + """ + if self.ready(): + if self.successful(): + return self.value + self._raise_exception() + if not block: + raise Timeout() + + switch = getcurrent().switch + self.rawlink(switch) + try: + t = Timeout._start_new_or_dummy(timeout) + try: + result = self.parent.switch() + if result is not self: + raise InvalidSwitchError('Invalid switch into Greenlet.get(): %r' % (result, )) + finally: + t.cancel() + except: + # unlinking in 'except' instead of finally is an optimization: + # if switch occurred normally then link was already removed in _notify_links + # and there's no need to touch the links set. + # Note, however, that if "Invalid switch" assert was removed and invalid switch + # did happen, the link would remain, causing another invalid switch later in this greenlet. + self.unlink(switch) + raise + + if self.ready(): + if self.successful(): + return self.value + self._raise_exception() + + def join(self, timeout=None): + """Wait until the greenlet finishes or *timeout* expires. + Return ``None`` regardless. + """ + if self.ready(): + return + + switch = getcurrent().switch + self.rawlink(switch) + try: + t = Timeout._start_new_or_dummy(timeout) + try: + result = self.parent.switch() + if result is not self: + raise InvalidSwitchError('Invalid switch into Greenlet.join(): %r' % (result, )) + finally: + t.cancel() + except Timeout as ex: + self.unlink(switch) + if ex is not t: + raise + except: + self.unlink(switch) + raise + + def _report_result(self, result): + self._exc_info = (None, None, None) + self.value = result + if self._has_links() and not self._notifier: + self._notifier = self.parent.loop.run_callback(self._notify_links) + + def _report_error(self, exc_info): + if isinstance(exc_info[1], GreenletExit): + self._report_result(exc_info[1]) + return + + self._exc_info = exc_info[0], exc_info[1], dump_traceback(exc_info[2]) + + if self._has_links() and not self._notifier: + self._notifier = self.parent.loop.run_callback(self._notify_links) + + try: + self.parent.handle_error(self, *exc_info) + finally: + del exc_info + + def run(self): + try: + self.__cancel_start() + self._start_event = _start_completed_event + + try: + result = self._run(*self.args, **self.kwargs) + except: # pylint:disable=bare-except + self._report_error(sys.exc_info()) + return + self._report_result(result) + finally: + self.__dict__.pop('_run', None) + self.__dict__.pop('args', None) + self.__dict__.pop('kwargs', None) + + def _run(self): + """Subclasses may override this method to take any number of arguments and keyword arguments. + + .. versionadded:: 1.1a3 + Previously, if no callable object was passed to the constructor, the spawned greenlet would + later fail with an AttributeError. + """ + # We usually override this in __init__ + # pylint: disable=method-hidden + return + + def rawlink(self, callback): + """Register a callable to be executed when the greenlet finishes execution. + + The *callback* will be called with this instance as an argument. + + .. caution:: The callable will be called in the HUB greenlet. + """ + if not callable(callback): + raise TypeError('Expected callable: %r' % (callback, )) + self._links.append(callback) # pylint:disable=no-member + if self.ready() and self._links and not self._notifier: + self._notifier = self.parent.loop.run_callback(self._notify_links) + + def link(self, callback, SpawnedLink=SpawnedLink): + """ + Link greenlet's completion to a callable. + + The *callback* will be called with this instance as an + argument once this greenlet is dead. A callable is called in + its own :class:`greenlet.greenlet` (*not* a + :class:`Greenlet`). + """ + # XXX: Is the redefinition of SpawnedLink supposed to just be an + # optimization, or do people use it? It's not documented + # pylint:disable=redefined-outer-name + self.rawlink(SpawnedLink(callback)) + + def unlink(self, callback): + """Remove the callback set by :meth:`link` or :meth:`rawlink`""" + try: + self._links.remove(callback) # pylint:disable=no-member + except ValueError: + pass + + def link_value(self, callback, SpawnedLink=SuccessSpawnedLink): + """ + Like :meth:`link` but *callback* is only notified when the greenlet + has completed successfully. + """ + # pylint:disable=redefined-outer-name + self.link(callback, SpawnedLink=SpawnedLink) + + def link_exception(self, callback, SpawnedLink=FailureSpawnedLink): + """Like :meth:`link` but *callback* is only notified when the greenlet dies because of an unhandled exception.""" + # pylint:disable=redefined-outer-name + self.link(callback, SpawnedLink=SpawnedLink) + + def _notify_links(self): + while self._links: + link = self._links.popleft() # pylint:disable=no-member + try: + link(self) + except: # pylint:disable=bare-except + self.parent.handle_error((link, self), *sys.exc_info()) + + +class _dummy_event(object): + pending = False + active = False + + def stop(self): + pass + + def start(self, cb): # pylint:disable=unused-argument + raise AssertionError("Cannot start the dummy event") + + +_cancelled_start_event = _dummy_event() +_start_completed_event = _dummy_event() +del _dummy_event + + +def _kill(glet, exception, waiter): + try: + glet.throw(exception) + except: # pylint:disable=bare-except + # XXX do we need this here? + glet.parent.handle_error(glet, *sys.exc_info()) + if waiter is not None: + waiter.switch() + + +def joinall(greenlets, timeout=None, raise_error=False, count=None): + """ + Wait for the ``greenlets`` to finish. + + :param greenlets: A sequence (supporting :func:`len`) of greenlets to wait for. + :keyword float timeout: If given, the maximum number of seconds to wait. + :return: A sequence of the greenlets that finished before the timeout (if any) + expired. + """ + if not raise_error: + return wait(greenlets, timeout=timeout, count=count) + + done = [] + for obj in iwait(greenlets, timeout=timeout, count=count): + if getattr(obj, 'exception', None) is not None: + if hasattr(obj, '_raise_exception'): + obj._raise_exception() + else: + raise obj.exception + done.append(obj) + return done + + +def _killall3(greenlets, exception, waiter): + diehards = [] + for g in greenlets: + if not g.dead: + try: + g.throw(exception) + except: # pylint:disable=bare-except + g.parent.handle_error(g, *sys.exc_info()) + if not g.dead: + diehards.append(g) + waiter.switch(diehards) + + +def _killall(greenlets, exception): + for g in greenlets: + if not g.dead: + try: + g.throw(exception) + except: # pylint:disable=bare-except + g.parent.handle_error(g, *sys.exc_info()) + + +def killall(greenlets, exception=GreenletExit, block=True, timeout=None): + """ + Forceably terminate all the ``greenlets`` by causing them to raise ``exception``. + + .. caution:: Use care when killing greenlets. If they are not prepared for exceptions, + this could result in corrupted state. + + :param greenlets: A **bounded** iterable of the non-None greenlets to terminate. + *All* the items in this iterable must be greenlets that belong to the same thread. + :keyword exception: The exception to raise in the greenlets. By default this is + :class:`GreenletExit`. + :keyword bool block: If True (the default) then this function only returns when all the + greenlets are dead; the current greenlet is unscheduled during that process. + If greenlets ignore the initial exception raised in them, + then they will be joined (with :func:`gevent.joinall`) and allowed to die naturally. + If False, this function returns immediately and greenlets will raise + the exception asynchronously. + :keyword float timeout: A time in seconds to wait for greenlets to die. If given, it is + only honored when ``block`` is True. + :raise Timeout: If blocking and a timeout is given that elapses before + all the greenlets are dead. + + .. versionchanged:: 1.1a2 + *greenlets* can be any iterable of greenlets, like an iterator or a set. + Previously it had to be a list or tuple. + """ + # support non-indexable containers like iterators or set objects + greenlets = list(greenlets) + if not greenlets: + return + loop = greenlets[0].loop + if block: + waiter = Waiter() + loop.run_callback(_killall3, greenlets, exception, waiter) + t = Timeout._start_new_or_dummy(timeout) + try: + alive = waiter.get() + if alive: + joinall(alive, raise_error=False) + finally: + t.cancel() + else: + loop.run_callback(_killall, greenlets, exception) + + +if PY3: + _meth_self = "__self__" +else: + _meth_self = "im_self" + + +def getfuncname(func): + if not hasattr(func, _meth_self): + try: + funcname = func.__name__ + except AttributeError: + pass + else: + if funcname != '': + return funcname + return repr(func) diff --git a/python/gevent/hub.py b/python/gevent/hub.py new file mode 100644 index 0000000..001cd06 --- /dev/null +++ b/python/gevent/hub.py @@ -0,0 +1,1052 @@ +# Copyright (c) 2009-2015 Denis Bilenko. See LICENSE for details. +""" +Event-loop hub. +""" +from __future__ import absolute_import +# XXX: FIXME: Refactor to make this smaller +# pylint:disable=too-many-lines +from functools import partial as _functools_partial +import os +import sys +import traceback + +from greenlet import greenlet as RawGreenlet, getcurrent, GreenletExit + + +__all__ = [ + 'getcurrent', + 'GreenletExit', + 'spawn_raw', + 'sleep', + 'kill', + 'signal', + 'reinit', + 'get_hub', + 'Hub', + 'Waiter', +] + +from gevent._compat import string_types +from gevent._compat import xrange +from gevent._util import _NONE +from gevent._util import readproperty + +if sys.version_info[0] <= 2: + import thread # pylint:disable=import-error +else: + import _thread as thread # python 2 pylint:disable=import-error + +# These must be the "real" native thread versions, +# not monkey-patched. +threadlocal = thread._local + + +class _threadlocal(threadlocal): + + def __init__(self): + # Use a class with an initializer so that we can test + # for 'is None' instead of catching AttributeError, making + # the code cleaner and possibly solving some corner cases + # (like #687) + threadlocal.__init__(self) + self.Hub = None + self.loop = None + self.hub = None + +_threadlocal = _threadlocal() + +get_ident = thread.get_ident +MAIN_THREAD = get_ident() + + + + +class LoopExit(Exception): + """ + Exception thrown when the hub finishes running. + + In a normal application, this is never thrown or caught + explicitly. The internal implementation of functions like + :func:`join` and :func:`joinall` may catch it, but user code + generally should not. + + .. caution:: + Errors in application programming can also lead to this exception being + raised. Some examples include (but are not limited too): + + - greenlets deadlocking on a lock; + - using a socket or other gevent object with native thread + affinity from a different thread + + """ + pass + + +class BlockingSwitchOutError(AssertionError): + pass + + +class InvalidSwitchError(AssertionError): + pass + + +class ConcurrentObjectUseError(AssertionError): + # raised when an object is used (waited on) by two greenlets + # independently, meaning the object was entered into a blocking + # state by one greenlet and then another while still blocking in the + # first one + pass + + +def spawn_raw(function, *args, **kwargs): + """ + Create a new :class:`greenlet.greenlet` object and schedule it to + run ``function(*args, **kwargs)``. + + This returns a raw :class:`~greenlet.greenlet` which does not have all the useful + methods that :class:`gevent.Greenlet` has. Typically, applications + should prefer :func:`~gevent.spawn`, but this method may + occasionally be useful as an optimization if there are many + greenlets involved. + + .. versionchanged:: 1.1b1 + If *function* is not callable, immediately raise a :exc:`TypeError` + instead of spawning a greenlet that will raise an uncaught TypeError. + + .. versionchanged:: 1.1rc2 + Accept keyword arguments for ``function`` as previously (incorrectly) + documented. Note that this may incur an additional expense. + + .. versionchanged:: 1.1a3 + Verify that ``function`` is callable, raising a TypeError if not. Previously, + the spawned greenlet would have failed the first time it was switched to. + """ + if not callable(function): + raise TypeError("function must be callable") + hub = get_hub() + + # The callback class object that we use to run this doesn't + # accept kwargs (and those objects are heavily used, as well as being + # implemented twice in core.ppyx and corecffi.py) so do it with a partial + if kwargs: + function = _functools_partial(function, *args, **kwargs) + g = RawGreenlet(function, hub) + hub.loop.run_callback(g.switch) + else: + g = RawGreenlet(function, hub) + hub.loop.run_callback(g.switch, *args) + return g + + +def sleep(seconds=0, ref=True): + """ + Put the current greenlet to sleep for at least *seconds*. + + *seconds* may be specified as an integer, or a float if fractional + seconds are desired. + + .. tip:: In the current implementation, a value of 0 (the default) + means to yield execution to any other runnable greenlets, but + this greenlet may be scheduled again before the event loop + cycles (in an extreme case, a greenlet that repeatedly sleeps + with 0 can prevent greenlets that are ready to do I/O from + being scheduled for some (small) period of time); a value greater than + 0, on the other hand, will delay running this greenlet until + the next iteration of the loop. + + If *ref* is False, the greenlet running ``sleep()`` will not prevent :func:`gevent.wait` + from exiting. + + .. seealso:: :func:`idle` + """ + hub = get_hub() + loop = hub.loop + if seconds <= 0: + waiter = Waiter() + loop.run_callback(waiter.switch) + waiter.get() + else: + hub.wait(loop.timer(seconds, ref=ref)) + + +def idle(priority=0): + """ + Cause the calling greenlet to wait until the event loop is idle. + + Idle is defined as having no other events of the same or higher + *priority* pending. That is, as long as sockets, timeouts or even + signals of the same or higher priority are being processed, the loop + is not idle. + + .. seealso:: :func:`sleep` + """ + hub = get_hub() + watcher = hub.loop.idle() + if priority: + watcher.priority = priority + hub.wait(watcher) + + +def kill(greenlet, exception=GreenletExit): + """ + Kill greenlet asynchronously. The current greenlet is not unscheduled. + + .. note:: + + The method :meth:`Greenlet.kill` method does the same and + more (and the same caveats listed there apply here). However, the MAIN + greenlet - the one that exists initially - does not have a + ``kill()`` method, and neither do any created with :func:`spawn_raw`, + so you have to use this function. + + .. caution:: Use care when killing greenlets. If they are not prepared for + exceptions, this could result in corrupted state. + + .. versionchanged:: 1.1a2 + If the ``greenlet`` has a :meth:`kill ` method, calls it. This prevents a + greenlet from being switched to for the first time after it's been + killed but not yet executed. + """ + if not greenlet.dead: + if hasattr(greenlet, 'kill'): + # dealing with gevent.greenlet.Greenlet. Use it, especially + # to avoid allowing one to be switched to for the first time + # after it's been killed + greenlet.kill(exception=exception, block=False) + else: + get_hub().loop.run_callback(greenlet.throw, exception) + + +class signal(object): + """ + Call the *handler* with the *args* and *kwargs* when the process + receives the signal *signalnum*. + + The *handler* will be run in a new greenlet when the signal is delivered. + + This returns an object with the useful method ``cancel``, which, when called, + will prevent future deliveries of *signalnum* from calling *handler*. + + .. note:: + + This may not operate correctly with SIGCHLD if libev child watchers + are used (as they are by default with os.fork). + + .. versionchanged:: 1.2a1 + The ``handler`` argument is required to be callable at construction time. + """ + + # XXX: This is manually documented in gevent.rst while it is aliased in + # the gevent module. + + greenlet_class = None + + def __init__(self, signalnum, handler, *args, **kwargs): + if not callable(handler): + raise TypeError("signal handler must be callable.") + + self.hub = get_hub() + self.watcher = self.hub.loop.signal(signalnum, ref=False) + self.watcher.start(self._start) + self.handler = handler + self.args = args + self.kwargs = kwargs + if self.greenlet_class is None: + from gevent import Greenlet + self.greenlet_class = Greenlet + + def _get_ref(self): + return self.watcher.ref + + def _set_ref(self, value): + self.watcher.ref = value + + ref = property(_get_ref, _set_ref) + del _get_ref, _set_ref + + def cancel(self): + self.watcher.stop() + + def _start(self): + try: + greenlet = self.greenlet_class(self.handle) + greenlet.switch() + except: # pylint:disable=bare-except + self.hub.handle_error(None, *sys._exc_info()) # pylint:disable=no-member + + def handle(self): + try: + self.handler(*self.args, **self.kwargs) + except: # pylint:disable=bare-except + self.hub.handle_error(None, *sys.exc_info()) + + +def reinit(): + """ + Prepare the gevent hub to run in a new (forked) process. + + This should be called *immediately* after :func:`os.fork` in the + child process. This is done automatically by + :func:`gevent.os.fork` or if the :mod:`os` module has been + monkey-patched. If this function is not called in a forked + process, symptoms may include hanging of functions like + :func:`socket.getaddrinfo`, and the hub's threadpool is unlikely + to work. + + .. note:: Registered fork watchers may or may not run before + this function (and thus ``gevent.os.fork``) return. If they have + not run, they will run "soon", after an iteration of the event loop. + You can force this by inserting a few small (but non-zero) calls to :func:`sleep` + after fork returns. (As of gevent 1.1 and before, fork watchers will + not have run, but this may change in the future.) + + .. note:: This function may be removed in a future major release + if the fork process can be more smoothly managed. + + .. warning:: See remarks in :func:`gevent.os.fork` about greenlets + and libev watchers in the child process. + """ + # The loop reinit function in turn calls libev's ev_loop_fork + # function. + hub = _get_hub() + + if hub is not None: + # Note that we reinit the existing loop, not destroy it. + # See https://github.com/gevent/gevent/issues/200. + hub.loop.reinit() + # libev's fork watchers are slow to fire because the only fire + # at the beginning of a loop; due to our use of callbacks that + # run at the end of the loop, that may be too late. The + # threadpool and resolvers depend on the fork handlers being + # run (specifically, the threadpool will fail in the forked + # child if there were any threads in it, which there will be + # if the resolver_thread was in use (the default) before the + # fork.) + # + # If the forked process wants to use the threadpool or + # resolver immediately (in a queued callback), it would hang. + # + # The below is a workaround. Fortunately, both of these + # methods are idempotent and can be called multiple times + # following a fork if the suddenly started working, or were + # already working on some platforms. Other threadpools and fork handlers + # will be called at an arbitrary time later ('soon') + if hasattr(hub.threadpool, '_on_fork'): + hub.threadpool._on_fork() + # resolver_ares also has a fork watcher that's not firing + if hasattr(hub.resolver, '_on_fork'): + hub.resolver._on_fork() + + # TODO: We'd like to sleep for a non-zero amount of time to force the loop to make a + # pass around before returning to this greenlet. That will allow any + # user-provided fork watchers to run. (Two calls are necessary.) HOWEVER, if + # we do this, certain tests that heavily mix threads and forking, + # like 2.7/test_threading:test_reinit_tls_after_fork, fail. It's not immediately clear + # why. + #sleep(0.00001) + #sleep(0.00001) + + +def get_hub_class(): + """Return the type of hub to use for the current thread. + + If there's no type of hub for the current thread yet, 'gevent.hub.Hub' is used. + """ + hubtype = _threadlocal.Hub + if hubtype is None: + hubtype = _threadlocal.Hub = Hub + return hubtype + + +def get_hub(*args, **kwargs): + """ + Return the hub for the current thread. + + If a hub does not exist in the current thread, a new one is + created of the type returned by :func:`get_hub_class`. + """ + hub = _threadlocal.hub + if hub is None: + hubtype = get_hub_class() + hub = _threadlocal.hub = hubtype(*args, **kwargs) + return hub + + +def _get_hub(): + """Return the hub for the current thread. + + Return ``None`` if no hub has been created yet. + """ + return _threadlocal.hub + + +def set_hub(hub): + _threadlocal.hub = hub + + +def _import(path): + # pylint:disable=too-many-branches + if isinstance(path, list): + if not path: + raise ImportError('Cannot import from empty list: %r' % (path, )) + + for item in path[:-1]: + try: + return _import(item) + except ImportError: + pass + + return _import(path[-1]) + + if not isinstance(path, string_types): + return path + + if '.' not in path: + raise ImportError("Cannot import %r (required format: [path/][package.]module.class)" % path) + + if '/' in path: + package_path, path = path.rsplit('/', 1) + sys.path = [package_path] + sys.path + else: + package_path = None + + try: + module, item = path.rsplit('.', 1) + x = __import__(module) + for attr in path.split('.')[1:]: + oldx = x + x = getattr(x, attr, _NONE) + if x is _NONE: + raise ImportError('Cannot import %r from %r' % (attr, oldx)) + return x + finally: + try: + sys.path.remove(package_path) + except ValueError: + pass + + +def config(default, envvar): + result = os.environ.get(envvar) or default # absolute import gets confused pylint: disable=no-member + if isinstance(result, string_types): + return result.split(',') + return result + + +def resolver_config(default, envvar): + result = config(default, envvar) + return [_resolvers.get(x, x) for x in result] + + +_resolvers = {'ares': 'gevent.resolver_ares.Resolver', + 'thread': 'gevent.resolver_thread.Resolver', + 'block': 'gevent.socket.BlockingResolver'} + + +_DEFAULT_LOOP_CLASS = 'gevent.core.loop' + + +class Hub(RawGreenlet): + """A greenlet that runs the event loop. + + It is created automatically by :func:`get_hub`. + + **Switching** + + Every time this greenlet (i.e., the event loop) is switched *to*, if + the current greenlet has a ``switch_out`` method, it will be called. This + allows a greenlet to take some cleanup actions before yielding control. This method + should not call any gevent blocking functions. + """ + + #: If instances of these classes are raised into the event loop, + #: they will be propagated out to the main greenlet (where they will + #: usually be caught by Python itself) + SYSTEM_ERROR = (KeyboardInterrupt, SystemExit, SystemError) + + #: Instances of these classes are not considered to be errors and + #: do not get logged/printed when raised by the event loop. + NOT_ERROR = (GreenletExit, SystemExit) + + loop_class = config(_DEFAULT_LOOP_CLASS, 'GEVENT_LOOP') + # For the standard class, go ahead and import it when this class + # is defined. This is no loss of generality because the envvar is + # only read when this class is defined, and we know that the + # standard class will be available. This can solve problems with + # the class being imported from multiple threads at once, leading + # to one of the imports failing. Only do this for the object we + # need in the constructor, as the rest of the factories are + # themselves handled lazily. See #687. (People using a custom loop_class + # can probably manage to get_hub() from the main thread or otherwise import + # that loop_class themselves.) + if loop_class == [_DEFAULT_LOOP_CLASS]: + loop_class = [_import(loop_class)] + + resolver_class = ['gevent.resolver_thread.Resolver', + 'gevent.resolver_ares.Resolver', + 'gevent.socket.BlockingResolver'] + #: The class or callable object, or the name of a factory function or class, + #: that will be used to create :attr:`resolver`. By default, configured according to + #: :doc:`dns`. If a list, a list of objects in preference order. + resolver_class = resolver_config(resolver_class, 'GEVENT_RESOLVER') + threadpool_class = config('gevent.threadpool.ThreadPool', 'GEVENT_THREADPOOL') + backend = config(None, 'GEVENT_BACKEND') + threadpool_size = 10 + + # using pprint.pformat can override custom __repr__ methods on dict/list + # subclasses, which can be a security concern + format_context = 'pprint.saferepr' + + + def __init__(self, loop=None, default=None): + RawGreenlet.__init__(self) + if hasattr(loop, 'run'): + if default is not None: + raise TypeError("Unexpected argument: default") + self.loop = loop + elif _threadlocal.loop is not None: + # Reuse a loop instance previously set by + # destroying a hub without destroying the associated + # loop. See #237 and #238. + self.loop = _threadlocal.loop + else: + if default is None and get_ident() != MAIN_THREAD: + default = False + loop_class = _import(self.loop_class) + if loop is None: + loop = self.backend + self.loop = loop_class(flags=loop, default=default) + self._resolver = None + self._threadpool = None + self.format_context = _import(self.format_context) + + def __repr__(self): + if self.loop is None: + info = 'destroyed' + else: + try: + info = self.loop._format() + except Exception as ex: # pylint:disable=broad-except + info = str(ex) or repr(ex) or 'error' + result = '<%s at 0x%x %s' % (self.__class__.__name__, id(self), info) + if self._resolver is not None: + result += ' resolver=%r' % self._resolver + if self._threadpool is not None: + result += ' threadpool=%r' % self._threadpool + return result + '>' + + def handle_error(self, context, type, value, tb): + """ + Called by the event loop when an error occurs. The arguments + type, value, and tb are the standard tuple returned by :func:`sys.exc_info`. + + Applications can set a property on the hub with this same signature + to override the error handling provided by this class. + + Errors that are :attr:`system errors ` are passed + to :meth:`handle_system_error`. + + :param context: If this is ``None``, indicates a system error that + should generally result in exiting the loop and being thrown to the + parent greenlet. + """ + if isinstance(value, str): + # Cython can raise errors where the value is a plain string + # e.g., AttributeError, "_semaphore.Semaphore has no attr", + value = type(value) + if not issubclass(type, self.NOT_ERROR): + self.print_exception(context, type, value, tb) + if context is None or issubclass(type, self.SYSTEM_ERROR): + self.handle_system_error(type, value) + + def handle_system_error(self, type, value): + current = getcurrent() + if current is self or current is self.parent or self.loop is None: + self.parent.throw(type, value) + else: + # in case system error was handled and life goes on + # switch back to this greenlet as well + cb = None + try: + cb = self.loop.run_callback(current.switch) + except: # pylint:disable=bare-except + traceback.print_exc(file=self.exception_stream) + try: + self.parent.throw(type, value) + finally: + if cb is not None: + cb.stop() + + @readproperty + def exception_stream(self): + """ + The stream to which exceptions will be written. + Defaults to ``sys.stderr`` unless assigned to. + + .. versionadded:: 1.2a1 + """ + # Unwrap any FileObjectThread we have thrown around sys.stderr + # (because it can't be used in the hub). Tricky because we are + # called in error situations when it's not safe to import. + stderr = sys.stderr + if type(stderr).__name__ == 'FileObjectThread': + stderr = stderr.io # pylint:disable=no-member + return stderr + + def print_exception(self, context, type, value, tb): + # Python 3 does not gracefully handle None value or tb in + # traceback.print_exception() as previous versions did. + # pylint:disable=no-member + errstream = self.exception_stream + + if value is None: + errstream.write('%s\n' % type.__name__) + else: + traceback.print_exception(type, value, tb, file=errstream) + del tb + + try: + import time + errstream.write(time.ctime()) + errstream.write(' ' if context is not None else '\n') + except: # pylint:disable=bare-except + # Possible not safe to import under certain + # error conditions in Python 2 + pass + + if context is not None: + if not isinstance(context, str): + try: + context = self.format_context(context) + except: # pylint:disable=bare-except + traceback.print_exc(file=self.exception_stream) + context = repr(context) + errstream.write('%s failed with %s\n\n' % (context, getattr(type, '__name__', 'exception'), )) + + def switch(self): + switch_out = getattr(getcurrent(), 'switch_out', None) + if switch_out is not None: + switch_out() + return RawGreenlet.switch(self) + + def switch_out(self): + raise BlockingSwitchOutError('Impossible to call blocking function in the event loop callback') + + def wait(self, watcher): + """ + Wait until the *watcher* (which should not be started) is ready. + + The current greenlet will be unscheduled during this time. + + .. seealso:: :class:`gevent.core.io`, :class:`gevent.core.timer`, + :class:`gevent.core.signal`, :class:`gevent.core.idle`, :class:`gevent.core.prepare`, + :class:`gevent.core.check`, :class:`gevent.core.fork`, :class:`gevent.core.async`, + :class:`gevent.core.child`, :class:`gevent.core.stat` + + """ + waiter = Waiter() + unique = object() + watcher.start(waiter.switch, unique) + try: + result = waiter.get() + if result is not unique: + raise InvalidSwitchError('Invalid switch into %s: %r (expected %r)' % (getcurrent(), result, unique)) + finally: + watcher.stop() + + def cancel_wait(self, watcher, error): + """ + Cancel an in-progress call to :meth:`wait` by throwing the given *error* + in the waiting greenlet. + """ + if watcher.callback is not None: + self.loop.run_callback(self._cancel_wait, watcher, error) + + def _cancel_wait(self, watcher, error): + if watcher.active: + switch = watcher.callback + if switch is not None: + greenlet = getattr(switch, '__self__', None) + if greenlet is not None: + greenlet.throw(error) + + def run(self): + """ + Entry-point to running the loop. This method is called automatically + when the hub greenlet is scheduled; do not call it directly. + + :raises LoopExit: If the loop finishes running. This means + that there are no other scheduled greenlets, and no active + watchers or servers. In some situations, this indicates a + programming error. + """ + assert self is getcurrent(), 'Do not call Hub.run() directly' + while True: + loop = self.loop + loop.error_handler = self + try: + loop.run() + finally: + loop.error_handler = None # break the refcount cycle + self.parent.throw(LoopExit('This operation would block forever', self)) + # this function must never return, as it will cause switch() in the parent greenlet + # to return an unexpected value + # It is still possible to kill this greenlet with throw. However, in that case + # switching to it is no longer safe, as switch will return immediatelly + + def join(self, timeout=None): + """Wait for the event loop to finish. Exits only when there are + no more spawned greenlets, started servers, active timeouts or watchers. + + If *timeout* is provided, wait no longer for the specified number of seconds. + + Returns True if exited because the loop finished execution. + Returns False if exited because of timeout expired. + """ + assert getcurrent() is self.parent, "only possible from the MAIN greenlet" + if self.dead: + return True + + waiter = Waiter() + + if timeout is not None: + timeout = self.loop.timer(timeout, ref=False) + timeout.start(waiter.switch) + + try: + try: + waiter.get() + except LoopExit: + return True + finally: + if timeout is not None: + timeout.stop() + return False + + def destroy(self, destroy_loop=None): + if self._resolver is not None: + self._resolver.close() + del self._resolver + if self._threadpool is not None: + self._threadpool.kill() + del self._threadpool + if destroy_loop is None: + destroy_loop = not self.loop.default + if destroy_loop: + if _threadlocal.loop is self.loop: + # Don't let anyone try to reuse this + _threadlocal.loop = None + self.loop.destroy() + else: + # Store in case another hub is created for this + # thread. + _threadlocal.loop = self.loop + + self.loop = None + if _threadlocal.hub is self: + _threadlocal.hub = None + + def _get_resolver(self): + if self._resolver is None: + if self.resolver_class is not None: + self.resolver_class = _import(self.resolver_class) + self._resolver = self.resolver_class(hub=self) + return self._resolver + + def _set_resolver(self, value): + self._resolver = value + + def _del_resolver(self): + del self._resolver + + resolver = property(_get_resolver, _set_resolver, _del_resolver) + + def _get_threadpool(self): + if self._threadpool is None: + if self.threadpool_class is not None: + self.threadpool_class = _import(self.threadpool_class) + self._threadpool = self.threadpool_class(self.threadpool_size, hub=self) + return self._threadpool + + def _set_threadpool(self, value): + self._threadpool = value + + def _del_threadpool(self): + del self._threadpool + + threadpool = property(_get_threadpool, _set_threadpool, _del_threadpool) + + +class Waiter(object): + """ + A low level communication utility for greenlets. + + Waiter is a wrapper around greenlet's ``switch()`` and ``throw()`` calls that makes them somewhat safer: + + * switching will occur only if the waiting greenlet is executing :meth:`get` method currently; + * any error raised in the greenlet is handled inside :meth:`switch` and :meth:`throw` + * if :meth:`switch`/:meth:`throw` is called before the receiver calls :meth:`get`, then :class:`Waiter` + will store the value/exception. The following :meth:`get` will return the value/raise the exception. + + The :meth:`switch` and :meth:`throw` methods must only be called from the :class:`Hub` greenlet. + The :meth:`get` method must be called from a greenlet other than :class:`Hub`. + + >>> result = Waiter() + >>> timer = get_hub().loop.timer(0.1) + >>> timer.start(result.switch, 'hello from Waiter') + >>> result.get() # blocks for 0.1 seconds + 'hello from Waiter' + + If switch is called before the greenlet gets a chance to call :meth:`get` then + :class:`Waiter` stores the value. + + >>> result = Waiter() + >>> timer = get_hub().loop.timer(0.1) + >>> timer.start(result.switch, 'hi from Waiter') + >>> sleep(0.2) + >>> result.get() # returns immediatelly without blocking + 'hi from Waiter' + + .. warning:: + + This a limited and dangerous way to communicate between + greenlets. It can easily leave a greenlet unscheduled forever + if used incorrectly. Consider using safer classes such as + :class:`gevent.event.Event`, :class:`gevent.event.AsyncResult`, + or :class:`gevent.queue.Queue`. + """ + + __slots__ = ['hub', 'greenlet', 'value', '_exception'] + + def __init__(self, hub=None): + if hub is None: + self.hub = get_hub() + else: + self.hub = hub + self.greenlet = None + self.value = None + self._exception = _NONE + + def clear(self): + self.greenlet = None + self.value = None + self._exception = _NONE + + def __str__(self): + if self._exception is _NONE: + return '<%s greenlet=%s>' % (type(self).__name__, self.greenlet) + if self._exception is None: + return '<%s greenlet=%s value=%r>' % (type(self).__name__, self.greenlet, self.value) + return '<%s greenlet=%s exc_info=%r>' % (type(self).__name__, self.greenlet, self.exc_info) + + def ready(self): + """Return true if and only if it holds a value or an exception""" + return self._exception is not _NONE + + def successful(self): + """Return true if and only if it is ready and holds a value""" + return self._exception is None + + @property + def exc_info(self): + "Holds the exception info passed to :meth:`throw` if :meth:`throw` was called. Otherwise ``None``." + if self._exception is not _NONE: + return self._exception + + def switch(self, value=None): + """Switch to the greenlet if one's available. Otherwise store the value.""" + greenlet = self.greenlet + if greenlet is None: + self.value = value + self._exception = None + else: + assert getcurrent() is self.hub, "Can only use Waiter.switch method from the Hub greenlet" + switch = greenlet.switch + try: + switch(value) + except: # pylint:disable=bare-except + self.hub.handle_error(switch, *sys.exc_info()) + + def switch_args(self, *args): + return self.switch(args) + + def throw(self, *throw_args): + """Switch to the greenlet with the exception. If there's no greenlet, store the exception.""" + greenlet = self.greenlet + if greenlet is None: + self._exception = throw_args + else: + assert getcurrent() is self.hub, "Can only use Waiter.switch method from the Hub greenlet" + throw = greenlet.throw + try: + throw(*throw_args) + except: # pylint:disable=bare-except + self.hub.handle_error(throw, *sys.exc_info()) + + def get(self): + """If a value/an exception is stored, return/raise it. Otherwise until switch() or throw() is called.""" + if self._exception is not _NONE: + if self._exception is None: + return self.value + else: + getcurrent().throw(*self._exception) + else: + if self.greenlet is not None: + raise ConcurrentObjectUseError('This Waiter is already used by %r' % (self.greenlet, )) + self.greenlet = getcurrent() + try: + return self.hub.switch() + finally: + self.greenlet = None + + def __call__(self, source): + if source.exception is None: + self.switch(source.value) + else: + self.throw(source.exception) + + # can also have a debugging version, that wraps the value in a tuple (self, value) in switch() + # and unwraps it in wait() thus checking that switch() was indeed called + + +class _MultipleWaiter(Waiter): + """ + An internal extension of Waiter that can be used if multiple objects + must be waited on, and there is a chance that in between waits greenlets + might be switched out. All greenlets that switch to this waiter + will have their value returned. + + This does not handle exceptions or throw methods. + """ + __slots__ = ['_values'] + + def __init__(self, *args, **kwargs): + Waiter.__init__(self, *args, **kwargs) + # we typically expect a relatively small number of these to be outstanding. + # since we pop from the left, a deque might be slightly + # more efficient, but since we're in the hub we avoid imports if + # we can help it to better support monkey-patching, and delaying the import + # here can be impractical (see https://github.com/gevent/gevent/issues/652) + self._values = list() + + def switch(self, value): # pylint:disable=signature-differs + self._values.append(value) + Waiter.switch(self, True) + + def get(self): + if not self._values: + Waiter.get(self) + Waiter.clear(self) + + return self._values.pop(0) + + +def iwait(objects, timeout=None, count=None): + """ + Iteratively yield *objects* as they are ready, until all (or *count*) are ready + or *timeout* expired. + + :param objects: A sequence (supporting :func:`len`) containing objects + implementing the wait protocol (rawlink() and unlink()). + :keyword int count: If not `None`, then a number specifying the maximum number + of objects to wait for. If ``None`` (the default), all objects + are waited for. + :keyword float timeout: If given, specifies a maximum number of seconds + to wait. If the timeout expires before the desired waited-for objects + are available, then this method returns immediately. + + .. seealso:: :func:`wait` + + .. versionchanged:: 1.1a1 + Add the *count* parameter. + .. versionchanged:: 1.1a2 + No longer raise :exc:`LoopExit` if our caller switches greenlets + in between items yielded by this function. + """ + # QQQ would be nice to support iterable here that can be generated slowly (why?) + if objects is None: + yield get_hub().join(timeout=timeout) + return + + count = len(objects) if count is None else min(count, len(objects)) + waiter = _MultipleWaiter() + switch = waiter.switch + + if timeout is not None: + timer = get_hub().loop.timer(timeout, priority=-1) + timer.start(switch, _NONE) + + try: + for obj in objects: + obj.rawlink(switch) + + for _ in xrange(count): + item = waiter.get() + waiter.clear() + if item is _NONE: + return + yield item + finally: + if timeout is not None: + timer.stop() + for aobj in objects: + unlink = getattr(aobj, 'unlink', None) + if unlink: + try: + unlink(switch) + except: # pylint:disable=bare-except + traceback.print_exc() + + +def wait(objects=None, timeout=None, count=None): + """ + Wait for ``objects`` to become ready or for event loop to finish. + + If ``objects`` is provided, it must be a list containing objects + implementing the wait protocol (rawlink() and unlink() methods): + + - :class:`gevent.Greenlet` instance + - :class:`gevent.event.Event` instance + - :class:`gevent.lock.Semaphore` instance + - :class:`gevent.subprocess.Popen` instance + + If ``objects`` is ``None`` (the default), ``wait()`` blocks until + the current event loop has nothing to do (or until ``timeout`` passes): + + - all greenlets have finished + - all servers were stopped + - all event loop watchers were stopped. + + If ``count`` is ``None`` (the default), wait for all ``objects`` + to become ready. + + If ``count`` is a number, wait for (up to) ``count`` objects to become + ready. (For example, if count is ``1`` then the function exits + when any object in the list is ready). + + If ``timeout`` is provided, it specifies the maximum number of + seconds ``wait()`` will block. + + Returns the list of ready objects, in the order in which they were + ready. + + .. seealso:: :func:`iwait` + """ + if objects is None: + return get_hub().join(timeout=timeout) + return list(iwait(objects, timeout, count)) + + +class linkproxy(object): + __slots__ = ['callback', 'obj'] + + def __init__(self, callback, obj): + self.callback = callback + self.obj = obj + + def __call__(self, *args): + callback = self.callback + obj = self.obj + self.callback = None + self.obj = None + callback(obj) diff --git a/python/gevent/libev/__init__.py b/python/gevent/libev/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/python/gevent/libev/_corecffi_build.py b/python/gevent/libev/_corecffi_build.py new file mode 100644 index 0000000..a6025fc --- /dev/null +++ b/python/gevent/libev/_corecffi_build.py @@ -0,0 +1,75 @@ +# pylint: disable=no-member + +# This module is only used to create and compile the gevent._corecffi module; +# nothing should be directly imported from it except `ffi`, which should only be +# used for `ffi.compile()`; programs should import gevent._corecfffi. +# However, because we are using "out-of-line" mode, it is necessary to examine +# this file to know what functions are created and available on the generated +# module. +from __future__ import absolute_import, print_function +import sys +import os +import os.path # pylint:disable=no-name-in-module +import struct + +__all__ = [] + + +def system_bits(): + return struct.calcsize('P') * 8 + + +def st_nlink_type(): + if sys.platform == "darwin" or sys.platform.startswith("freebsd"): + return "short" + if system_bits() == 32: + return "unsigned long" + return "long long" + + +from cffi import FFI +ffi = FFI() + +thisdir = os.path.dirname(os.path.abspath(__file__)) +def read_source(name): + with open(os.path.join(thisdir, name), 'r') as f: + return f.read() + +_cdef = read_source('_corecffi_cdef.c') +_source = read_source('_corecffi_source.c') + +_cdef = _cdef.replace('#define GEVENT_ST_NLINK_T int', '') +_cdef = _cdef.replace('#define GEVENT_STRUCT_DONE int', '') +_cdef = _cdef.replace('GEVENT_ST_NLINK_T', st_nlink_type()) +_cdef = _cdef.replace("GEVENT_STRUCT_DONE _;", '...;') + + +if sys.platform.startswith('win'): + # We must have the vfd_open, etc, functions on + # Windows. But on other platforms, going through + # CFFI to just return the file-descriptor is slower + # than just doing it in Python, so we check for and + # workaround their absence in corecffi.py + _cdef += """ +typedef int... vfd_socket_t; +int vfd_open(vfd_socket_t); +vfd_socket_t vfd_get(int); +void vfd_free(int); +""" + + + +include_dirs = [ + thisdir, # libev_vfd.h + os.path.abspath(os.path.join(thisdir, '..', '..', '..', 'deps', 'libev')), +] +ffi.cdef(_cdef) +ffi.set_source('gevent.libev._corecffi', _source, include_dirs=include_dirs) + +if __name__ == '__main__': + # XXX: Note, on Windows, we would need to specify the external libraries + # that should be linked in, such as ws2_32 and (because libev_vfd.h makes + # Python.h calls) the proper Python library---at least for PyPy. I never got + # that to work though, and calling python functions is strongly discouraged + # from CFFI code. + ffi.compile() diff --git a/python/gevent/libev/_corecffi_cdef.c b/python/gevent/libev/_corecffi_cdef.c new file mode 100644 index 0000000..d212887 --- /dev/null +++ b/python/gevent/libev/_corecffi_cdef.c @@ -0,0 +1,226 @@ +/* libev interface */ + +#define EV_MINPRI ... +#define EV_MAXPRI ... + +#define EV_VERSION_MAJOR ... +#define EV_VERSION_MINOR ... + +#define EV_UNDEF ... +#define EV_NONE ... +#define EV_READ ... +#define EV_WRITE ... +#define EV__IOFDSET ... +#define EV_TIMER ... +#define EV_PERIODIC ... +#define EV_SIGNAL ... +#define EV_CHILD ... +#define EV_STAT ... +#define EV_IDLE ... +#define EV_PREPARE ... +#define EV_CHECK ... +#define EV_EMBED ... +#define EV_FORK ... +#define EV_CLEANUP ... +#define EV_ASYNC ... +#define EV_CUSTOM ... +#define EV_ERROR ... + +#define EVFLAG_AUTO ... +#define EVFLAG_NOENV ... +#define EVFLAG_FORKCHECK ... +#define EVFLAG_NOINOTIFY ... +#define EVFLAG_SIGNALFD ... +#define EVFLAG_NOSIGMASK ... + +#define EVBACKEND_SELECT ... +#define EVBACKEND_POLL ... +#define EVBACKEND_EPOLL ... +#define EVBACKEND_KQUEUE ... +#define EVBACKEND_DEVPOLL ... +#define EVBACKEND_PORT ... +/* #define EVBACKEND_IOCP ... */ + +#define EVBACKEND_ALL ... +#define EVBACKEND_MASK ... + +#define EVRUN_NOWAIT ... +#define EVRUN_ONCE ... + +#define EVBREAK_CANCEL ... +#define EVBREAK_ONE ... +#define EVBREAK_ALL ... + +/* markers for the CFFI parser. Replaced when the string is read. */ +#define GEVENT_STRUCT_DONE int +#define GEVENT_ST_NLINK_T int + +struct ev_loop { + int backend_fd; + int activecnt; + GEVENT_STRUCT_DONE _; +}; + +// Watcher types +// base for all watchers +struct ev_watcher{ + GEVENT_STRUCT_DONE _; +}; + +struct ev_io { + int fd; + int events; + void* data; + GEVENT_STRUCT_DONE _; +}; +struct ev_timer { + double at; + void* data; + GEVENT_STRUCT_DONE _; +}; +struct ev_signal { + void* data; + GEVENT_STRUCT_DONE _; +}; +struct ev_idle { + void* data; + GEVENT_STRUCT_DONE _; +}; +struct ev_prepare { + void* data; + GEVENT_STRUCT_DONE _; +}; +struct ev_check { + void* data; + GEVENT_STRUCT_DONE _; +}; +struct ev_fork { + void* data; + GEVENT_STRUCT_DONE _; +}; +struct ev_async { + void* data; + GEVENT_STRUCT_DONE _; +}; + +struct ev_child { + int pid; + int rpid; + int rstatus; + void* data; + GEVENT_STRUCT_DONE _; +}; + +struct stat { + GEVENT_ST_NLINK_T st_nlink; + GEVENT_STRUCT_DONE _; +}; + +struct ev_stat { + struct stat attr; + const char* path; + struct stat prev; + double interval; + void* data; + GEVENT_STRUCT_DONE _; +}; + +typedef double ev_tstamp; + +int ev_version_major(); +int ev_version_minor(); + +unsigned int ev_supported_backends (void); +unsigned int ev_recommended_backends (void); +unsigned int ev_embeddable_backends (void); + +ev_tstamp ev_time (void); +void ev_set_syserr_cb(void *); + +int ev_priority(void*); +void ev_set_priority(void*, int); + +int ev_is_pending(void*); +int ev_is_active(void*); +void ev_io_init(struct ev_io*, void* callback, int fd, int events); +void ev_io_start(struct ev_loop*, struct ev_io*); +void ev_io_stop(struct ev_loop*, struct ev_io*); +void ev_feed_event(struct ev_loop*, void*, int); + +void ev_timer_init(struct ev_timer*, void *callback, double, double); +void ev_timer_start(struct ev_loop*, struct ev_timer*); +void ev_timer_stop(struct ev_loop*, struct ev_timer*); +void ev_timer_again(struct ev_loop*, struct ev_timer*); + +void ev_signal_init(struct ev_signal*, void* callback, int); +void ev_signal_start(struct ev_loop*, struct ev_signal*); +void ev_signal_stop(struct ev_loop*, struct ev_signal*); + +void ev_idle_init(struct ev_idle*, void* callback); +void ev_idle_start(struct ev_loop*, struct ev_idle*); +void ev_idle_stop(struct ev_loop*, struct ev_idle*); + +void ev_prepare_init(struct ev_prepare*, void* callback); +void ev_prepare_start(struct ev_loop*, struct ev_prepare*); +void ev_prepare_stop(struct ev_loop*, struct ev_prepare*); + +void ev_check_init(struct ev_check*, void* callback); +void ev_check_start(struct ev_loop*, struct ev_check*); +void ev_check_stop(struct ev_loop*, struct ev_check*); + +void ev_fork_init(struct ev_fork*, void* callback); +void ev_fork_start(struct ev_loop*, struct ev_fork*); +void ev_fork_stop(struct ev_loop*, struct ev_fork*); + +void ev_async_init(struct ev_async*, void* callback); +void ev_async_start(struct ev_loop*, struct ev_async*); +void ev_async_stop(struct ev_loop*, struct ev_async*); +void ev_async_send(struct ev_loop*, struct ev_async*); +int ev_async_pending(struct ev_async*); + +void ev_child_init(struct ev_child*, void* callback, int, int); +void ev_child_start(struct ev_loop*, struct ev_child*); +void ev_child_stop(struct ev_loop*, struct ev_child*); + +void ev_stat_init(struct ev_stat*, void* callback, char*, double); +void ev_stat_start(struct ev_loop*, struct ev_stat*); +void ev_stat_stop(struct ev_loop*, struct ev_stat*); + +struct ev_loop *ev_default_loop (unsigned int flags); +struct ev_loop* ev_loop_new(unsigned int flags); +void ev_loop_destroy(struct ev_loop*); +void ev_loop_fork(struct ev_loop*); +int ev_is_default_loop (struct ev_loop *); +unsigned int ev_iteration(struct ev_loop*); +unsigned int ev_depth(struct ev_loop*); +unsigned int ev_backend(struct ev_loop*); +void ev_verify(struct ev_loop*); +void ev_run(struct ev_loop*, int flags); + +ev_tstamp ev_now (struct ev_loop *); +void ev_now_update (struct ev_loop *); /* update event loop time */ +void ev_ref(struct ev_loop*); +void ev_unref(struct ev_loop*); +void ev_break(struct ev_loop*, int); +unsigned int ev_pending_count(struct ev_loop*); + +struct ev_loop* gevent_ev_default_loop(unsigned int flags); +void gevent_install_sigchld_handler(); +void gevent_reset_sigchld_handler(); + +void (*gevent_noop)(struct ev_loop *_loop, struct ev_timer *w, int revents); +void ev_sleep (ev_tstamp delay); /* sleep for a while */ + +/* gevent callbacks */ +static int (*python_callback)(void* handle, int revents); +static void (*python_handle_error)(void* handle, int revents); +static void (*python_stop)(void* handle); + +/* + * We use a single C callback for every watcher type, which in turn calls the + * Python callbacks. The ev_watcher pointer type can be used for every watcher type + * because they all start with the same members---libev itself relies on this. Each + * watcher types has a 'void* data' that stores the CFFI handle to the Python watcher + * object. + */ +static void _gevent_generic_callback(struct ev_loop* loop, struct ev_watcher* watcher, int revents); diff --git a/python/gevent/libev/_corecffi_source.c b/python/gevent/libev/_corecffi_source.c new file mode 100644 index 0000000..d179ce6 --- /dev/null +++ b/python/gevent/libev/_corecffi_source.c @@ -0,0 +1,45 @@ +// passed to the real C compiler +#define LIBEV_EMBED 1 + +#ifdef _WIN32 +#define EV_STANDALONE 1 +#include "libev_vfd.h" +#endif + + +#include "libev.h" + +static void +_gevent_noop(struct ev_loop *_loop, struct ev_timer *w, int revents) { } + +void (*gevent_noop)(struct ev_loop *, struct ev_timer *, int) = &_gevent_noop; +static int (*python_callback)(void* handle, int revents); +static void (*python_handle_error)(void* handle, int revents); +static void (*python_stop)(void* handle); + +static void _gevent_generic_callback(struct ev_loop* loop, + struct ev_watcher* watcher, + int revents) +{ + void* handle = watcher->data; + int cb_result = python_callback(handle, revents); + switch(cb_result) { + case -1: + // in case of exception, call self.loop.handle_error; + // this function is also responsible for stopping the watcher + // and allowing memory to be freed + python_handle_error(handle, revents); + break; + case 0: + // Code to stop the event. Note that if python_callback + // has disposed of the last reference to the handle, + // `watcher` could now be invalid/disposed memory! + if (!ev_is_active(watcher)) { + python_stop(handle); + } + break; + default: + assert(cb_result == 1); + // watcher is already stopped and dead, nothing to do. + } +} diff --git a/python/gevent/libev/callbacks.c b/python/gevent/libev/callbacks.c new file mode 100644 index 0000000..f65c67f --- /dev/null +++ b/python/gevent/libev/callbacks.c @@ -0,0 +1,225 @@ +/* Copyright (c) 2011-2012 Denis Bilenko. See LICENSE for details. */ +#ifdef Py_PYTHON_H + +/* the name changes depending on our file layout and --module-name option */ +#define _GEVENTLOOP struct __pyx_vtabstruct_6gevent_5libev_8corecext_loop + + +static void gevent_handle_error(struct PyGeventLoopObject* loop, PyObject* context) { + PyThreadState *tstate; + PyObject *type, *value, *traceback, *result; + tstate = PyThreadState_GET(); + type = tstate->curexc_type; + if (!type) + return; + value = tstate->curexc_value; + traceback = tstate->curexc_traceback; + if (!value) value = Py_None; + if (!traceback) traceback = Py_None; + + Py_INCREF(type); + Py_INCREF(value); + Py_INCREF(traceback); + + PyErr_Clear(); + + result = ((_GEVENTLOOP *)loop->__pyx_vtab)->handle_error(loop, context, type, value, traceback, 0); + + if (result) { + Py_DECREF(result); + } + else { + PyErr_Print(); + PyErr_Clear(); + } + + Py_DECREF(type); + Py_DECREF(value); + Py_DECREF(traceback); +} + + +static CYTHON_INLINE void gevent_check_signals(struct PyGeventLoopObject* loop) { + if (!ev_is_default_loop(loop->_ptr)) { + /* only reporting signals on the default loop */ + return; + } + PyErr_CheckSignals(); + if (PyErr_Occurred()) gevent_handle_error(loop, Py_None); +} + +#define GET_OBJECT(PY_TYPE, EV_PTR, MEMBER) \ + ((struct PY_TYPE *)(((char *)EV_PTR) - offsetof(struct PY_TYPE, MEMBER))) + + +#ifdef WITH_THREAD +#define GIL_DECLARE PyGILState_STATE ___save +#define GIL_ENSURE ___save = PyGILState_Ensure(); +#define GIL_RELEASE PyGILState_Release(___save); +#else +#define GIL_DECLARE +#define GIL_ENSURE +#define GIL_RELEASE +#endif + + +static void gevent_stop(PyObject* watcher, struct PyGeventLoopObject* loop) { + PyObject *result, *method; + int error; + error = 1; + method = PyObject_GetAttrString(watcher, "stop"); + if (method) { + result = PyObject_Call(method, __pyx_empty_tuple, NULL); + if (result) { + Py_DECREF(result); + error = 0; + } + Py_DECREF(method); + } + if (error) { + gevent_handle_error(loop, watcher); + } +} + + +static void gevent_callback(struct PyGeventLoopObject* loop, PyObject* callback, PyObject* args, PyObject* watcher, void *c_watcher, int revents) { + GIL_DECLARE; + PyObject *result, *py_events; + long length; + py_events = 0; + GIL_ENSURE; + Py_INCREF(loop); + Py_INCREF(callback); + Py_INCREF(args); + Py_INCREF(watcher); + gevent_check_signals(loop); + if (args == Py_None) { + args = __pyx_empty_tuple; + } + length = PyTuple_Size(args); + if (length < 0) { + gevent_handle_error(loop, watcher); + goto end; + } + if (length > 0 && PyTuple_GET_ITEM(args, 0) == GEVENT_CORE_EVENTS) { + py_events = PyInt_FromLong(revents); + if (!py_events) { + gevent_handle_error(loop, watcher); + goto end; + } + PyTuple_SET_ITEM(args, 0, py_events); + } + else { + py_events = NULL; + } + result = PyObject_Call(callback, args, NULL); + if (result) { + Py_DECREF(result); + } + else { + gevent_handle_error(loop, watcher); + if (revents & (EV_READ|EV_WRITE)) { + /* io watcher: not stopping it may cause the failing callback to be called repeatedly */ + gevent_stop(watcher, loop); + goto end; + } + } + if (!ev_is_active(c_watcher)) { + /* Watcher was stopped, maybe by libev. Let's call stop() to clean up + * 'callback' and 'args' properties, do Py_DECREF() and ev_ref() if necessary. + * BTW, we don't need to check for EV_ERROR, because libev stops the watcher in that case. */ + gevent_stop(watcher, loop); + } +end: + if (py_events) { + Py_DECREF(py_events); + PyTuple_SET_ITEM(args, 0, GEVENT_CORE_EVENTS); + } + Py_DECREF(watcher); + Py_DECREF(args); + Py_DECREF(callback); + Py_DECREF(loop); + GIL_RELEASE; +} + + +static void gevent_call(struct PyGeventLoopObject* loop, struct PyGeventCallbackObject* cb) { + /* no need for GIL here because it is only called from run_callbacks which already has GIL */ + PyObject *result, *callback, *args; + if (!loop || !cb) + return; + callback = cb->callback; + args = cb->args; + if (!callback || !args) + return; + if (callback == Py_None || args == Py_None) + return; + Py_INCREF(loop); + Py_INCREF(callback); + Py_INCREF(args); + + Py_INCREF(Py_None); + Py_DECREF(cb->callback); + cb->callback = Py_None; + + result = PyObject_Call(callback, args, NULL); + if (result) { + Py_DECREF(result); + } + else { + gevent_handle_error(loop, (PyObject*)cb); + } + + Py_INCREF(Py_None); + Py_DECREF(cb->args); + cb->args = Py_None; + + Py_DECREF(callback); + Py_DECREF(args); + Py_DECREF(loop); +} + + +#undef DEFINE_CALLBACK +#define DEFINE_CALLBACK(WATCHER_LC, WATCHER_TYPE) \ + static void gevent_callback_##WATCHER_LC(struct ev_loop *_loop, void *c_watcher, int revents) { \ + struct PyGevent##WATCHER_TYPE##Object* watcher = GET_OBJECT(PyGevent##WATCHER_TYPE##Object, c_watcher, _watcher); \ + gevent_callback(watcher->loop, watcher->_callback, watcher->args, (PyObject*)watcher, c_watcher, revents); \ + } + + +DEFINE_CALLBACKS + + +static void gevent_run_callbacks(struct ev_loop *_loop, void *watcher, int revents) { + struct PyGeventLoopObject* loop; + PyObject *result; + GIL_DECLARE; + GIL_ENSURE; + loop = GET_OBJECT(PyGeventLoopObject, watcher, _prepare); + Py_INCREF(loop); + gevent_check_signals(loop); + result = ((_GEVENTLOOP *)loop->__pyx_vtab)->_run_callbacks(loop); + if (result) { + Py_DECREF(result); + } + else { + PyErr_Print(); + PyErr_Clear(); + } + Py_DECREF(loop); + GIL_RELEASE; +} + +#if defined(_WIN32) + +static void gevent_periodic_signal_check(struct ev_loop *_loop, void *watcher, int revents) { + GIL_DECLARE; + GIL_ENSURE; + gevent_check_signals(GET_OBJECT(PyGeventLoopObject, watcher, _periodic_signal_checker)); + GIL_RELEASE; +} + +#endif /* _WIN32 */ + +#endif /* Py_PYTHON_H */ diff --git a/python/gevent/libev/callbacks.h b/python/gevent/libev/callbacks.h new file mode 100644 index 0000000..669ea9e --- /dev/null +++ b/python/gevent/libev/callbacks.h @@ -0,0 +1,43 @@ +#define DEFINE_CALLBACK(WATCHER_LC, WATCHER_TYPE) \ + static void gevent_callback_##WATCHER_LC(struct ev_loop *, void *, int); + + +#define DEFINE_CALLBACKS0 \ + DEFINE_CALLBACK(io, IO); \ + DEFINE_CALLBACK(timer, Timer); \ + DEFINE_CALLBACK(signal, Signal); \ + DEFINE_CALLBACK(idle, Idle); \ + DEFINE_CALLBACK(prepare, Prepare); \ + DEFINE_CALLBACK(check, Check); \ + DEFINE_CALLBACK(fork, Fork); \ + DEFINE_CALLBACK(async, Async); \ + DEFINE_CALLBACK(stat, Stat); + + +#ifndef _WIN32 + +#define DEFINE_CALLBACKS \ + DEFINE_CALLBACKS0 \ + DEFINE_CALLBACK(child, Child) + +#else + +#define DEFINE_CALLBACKS DEFINE_CALLBACKS0 + +#endif + + +DEFINE_CALLBACKS + + +static void gevent_run_callbacks(struct ev_loop *, void *, int); +struct PyGeventLoopObject; +static void gevent_handle_error(struct PyGeventLoopObject* loop, PyObject* context); +struct PyGeventCallbackObject; +static void gevent_call(struct PyGeventLoopObject* loop, struct PyGeventCallbackObject* cb); + +#if defined(_WIN32) +static void gevent_periodic_signal_check(struct ev_loop *, void *, int); +#endif + +static void gevent_noop(struct ev_loop *_loop, void *watcher, int revents) { } diff --git a/python/gevent/libev/corecext.ppyx b/python/gevent/libev/corecext.ppyx new file mode 100644 index 0000000..a474d7e --- /dev/null +++ b/python/gevent/libev/corecext.ppyx @@ -0,0 +1,1134 @@ +# 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, gevent_run_callbacks) +#ifdef _WIN32 + libev.ev_timer_init(&self._periodic_signal_checker, gevent_periodic_signal_check, 0.3, 0.3) +#endif + libev.ev_timer_init(&self._timer0, gevent_noop, 0.0, 0.0) + if ptr: + self._ptr = 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 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(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(self) + + def _format(self): + return '' + + +#define PYTHON_INCREF if not self._flags & 1: \ + Py_INCREF(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(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(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, 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(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(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, 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, 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, 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, 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, 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, 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, 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 = (path).encode(sys.getfilesystemencoding()) + self._paths = paths + else: + paths = path + self._paths = paths + libev.ev_stat_init(&self._watcher, gevent_callback_stat, 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(_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 diff --git a/python/gevent/libev/corecext.pyx b/python/gevent/libev/corecext.pyx new file mode 100644 index 0000000..a7fb888 --- /dev/null +++ b/python/gevent/libev/corecext.pyx @@ -0,0 +1,2110 @@ +# Generated by cythonpp.py on 2017-06-05 11:30:19 +# 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() + + + + +cdef bint _default_loop_destroyed = False + + + + + + + +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, gevent_run_callbacks) +#ifdef _WIN32 + libev.ev_timer_init(&self._periodic_signal_checker, gevent_periodic_signal_check, 0.3, 0.3) +#endif + libev.ev_timer_init(&self._timer0, gevent_noop, 0.0, 0.0) + if ptr: + self._ptr = 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 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): + + if not self._ptr: + raise ValueError('operation on destroyed loop') + 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): + + if not self._ptr: + raise ValueError('operation on destroyed loop') + libev.ev_ref(self._ptr) + + def unref(self): + + if not self._ptr: + raise ValueError('operation on destroyed loop') + libev.ev_unref(self._ptr) + + def break_(self, int how=libev.EVBREAK_ONE): + + if not self._ptr: + raise ValueError('operation on destroyed loop') + libev.ev_break(self._ptr, how) + + def verify(self): + + if not self._ptr: + raise ValueError('operation on destroyed loop') + libev.ev_verify(self._ptr) + + def now(self): + + if not self._ptr: + raise ValueError('operation on destroyed loop') + return libev.ev_now(self._ptr) + + def update(self): + + if not self._ptr: + raise ValueError('operation on destroyed loop') + 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): + + if not self._ptr: + raise ValueError('operation on destroyed loop') + return True if libev.ev_is_default_loop(self._ptr) else False + + property iteration: + + def __get__(self): + + if not self._ptr: + raise ValueError('operation on destroyed loop') + return libev.ev_iteration(self._ptr) + + property depth: + + def __get__(self): + + if not self._ptr: + raise ValueError('operation on destroyed loop') + return libev.ev_depth(self._ptr) + + property backend_int: + + def __get__(self): + + if not self._ptr: + raise ValueError('operation on destroyed loop') + return libev.ev_backend(self._ptr) + + property backend: + + def __get__(self): + + if not self._ptr: + raise ValueError('operation on destroyed loop') + 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): + + if not self._ptr: + raise ValueError('operation on destroyed loop') + 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): + + if not self._ptr: + raise ValueError('operation on destroyed loop') + 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 + + property activecnt: + + def __get__(self): + + if not self._ptr: + raise ValueError('operation on destroyed loop') + return self._ptr.activecnt + + property sig_pending: + + def __get__(self): + + if not self._ptr: + raise ValueError('operation on destroyed loop') + return self._ptr.sig_pending + +#if EV_USE_SIGNALFD + property sigfd: + + def __get__(self): + + if not self._ptr: + raise ValueError('operation on destroyed loop') + return self._ptr.sigfd +#endif + + property origflags: + + def __get__(self): + + if not self._ptr: + raise ValueError('operation on destroyed loop') + return _flags_to_list(self._ptr.origflags) + + property origflags_int: + + def __get__(self): + + if not self._ptr: + raise ValueError('operation on destroyed loop') + 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(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(self) + + def _format(self): + return '' + + + + +# 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() + + + + + + + + + + + + + + +cdef public class watcher [object PyGeventWatcherObject, type PyGeventWatcher_Type]: + """Abstract base class for all the watchers""" + + def __repr__(self): + if Py_ReprEnter(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(self) + + def _format(self): + return '' + + +cdef public class io(watcher) [object PyGeventIOObject, type PyGeventIO_Type]: + + + cdef public loop loop + cdef object _callback + cdef public tuple args + cdef readonly int _flags + cdef libev.ev_io _watcher + + property ref: + + def __get__(self): + return False if self._flags & 4 else True + + def __set__(self, object value): + + if not self.loop._ptr: + raise ValueError('operation on destroyed 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(callback) and callback is not None: + raise TypeError("Expected callable, not %r" % (callback, )) + self._callback = callback + + def stop(self): + + if not self.loop._ptr: + raise ValueError('operation on destroyed loop') + if self._flags & 2: + libev.ev_ref(self.loop._ptr) + self._flags &= ~2 + libev.ev_io_stop(self.loop._ptr, &self._watcher) + self._callback = None + self.args = None + if self._flags & 1: + Py_DECREF(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): + + if not self.loop._ptr: + raise ValueError('operation on destroyed loop') + self.callback = callback + self.args = args + if self._flags & 6 == 4: + libev.ev_unref(self.loop._ptr) + self._flags |= 2 + libev.ev_feed_event(self.loop._ptr, &self._watcher, revents) + if not self._flags & 1: + Py_INCREF(self) + self._flags |= 1 + + def start(self, object callback, *args, pass_events=False): + + if not self.loop._ptr: + raise ValueError('operation on destroyed 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 + if self._flags & 6 == 4: + libev.ev_unref(self.loop._ptr) + self._flags |= 2 + libev.ev_io_start(self.loop._ptr, &self._watcher) + if not self._flags & 1: + Py_INCREF(self) + self._flags |= 1 + + property active: + + def __get__(self): + return True if libev.ev_is_active(&self._watcher) else False + + + property pending: + + def __get__(self): + return True if libev.ev_is_pending(&self._watcher) else False + +#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, 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, 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, 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, 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]: + + + cdef public loop loop + cdef object _callback + cdef public tuple args + cdef readonly int _flags + cdef libev.ev_timer _watcher + + property ref: + + def __get__(self): + return False if self._flags & 4 else True + + def __set__(self, object value): + + if not self.loop._ptr: + raise ValueError('operation on destroyed 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(callback) and callback is not None: + raise TypeError("Expected callable, not %r" % (callback, )) + self._callback = callback + + def stop(self): + + if not self.loop._ptr: + raise ValueError('operation on destroyed loop') + if self._flags & 2: + libev.ev_ref(self.loop._ptr) + self._flags &= ~2 + libev.ev_timer_stop(self.loop._ptr, &self._watcher) + self._callback = None + self.args = None + if self._flags & 1: + Py_DECREF(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): + + if not self.loop._ptr: + raise ValueError('operation on destroyed loop') + self.callback = callback + self.args = args + if self._flags & 6 == 4: + libev.ev_unref(self.loop._ptr) + self._flags |= 2 + libev.ev_feed_event(self.loop._ptr, &self._watcher, revents) + if not self._flags & 1: + Py_INCREF(self) + self._flags |= 1 + + def start(self, object callback, *args, update=True): + + if not self.loop._ptr: + raise ValueError('operation on destroyed loop') + if callback is None: + raise TypeError('callback must be callable, not None') + self.callback = callback + self.args = args + if self._flags & 6 == 4: + libev.ev_unref(self.loop._ptr) + self._flags |= 2 + if update: + libev.ev_now_update(self.loop._ptr) + libev.ev_timer_start(self.loop._ptr, &self._watcher) + if not self._flags & 1: + Py_INCREF(self) + self._flags |= 1 + + property active: + + def __get__(self): + return True if libev.ev_is_active(&self._watcher) else False + + + property pending: + + def __get__(self): + return True if libev.ev_is_pending(&self._watcher) else False + + 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, 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): + + if not self.loop._ptr: + raise ValueError('operation on destroyed loop') + self.callback = callback + self.args = args + if self._flags & 6 == 4: + libev.ev_unref(self.loop._ptr) + self._flags |= 2 + if update: + libev.ev_now_update(self.loop._ptr) + libev.ev_timer_again(self.loop._ptr, &self._watcher) + if not self._flags & 1: + Py_INCREF(self) + self._flags |= 1 + + +cdef public class signal(watcher) [object PyGeventSignalObject, type PyGeventSignal_Type]: + + + cdef public loop loop + cdef object _callback + cdef public tuple args + cdef readonly int _flags + cdef libev.ev_signal _watcher + + property ref: + + def __get__(self): + return False if self._flags & 4 else True + + def __set__(self, object value): + + if not self.loop._ptr: + raise ValueError('operation on destroyed 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(callback) and callback is not None: + raise TypeError("Expected callable, not %r" % (callback, )) + self._callback = callback + + def stop(self): + + if not self.loop._ptr: + raise ValueError('operation on destroyed loop') + if self._flags & 2: + libev.ev_ref(self.loop._ptr) + self._flags &= ~2 + libev.ev_signal_stop(self.loop._ptr, &self._watcher) + self._callback = None + self.args = None + if self._flags & 1: + Py_DECREF(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): + + if not self.loop._ptr: + raise ValueError('operation on destroyed loop') + self.callback = callback + self.args = args + if self._flags & 6 == 4: + libev.ev_unref(self.loop._ptr) + self._flags |= 2 + libev.ev_feed_event(self.loop._ptr, &self._watcher, revents) + if not self._flags & 1: + Py_INCREF(self) + self._flags |= 1 + + def start(self, object callback, *args): + + if not self.loop._ptr: + raise ValueError('operation on destroyed loop') + if callback is None: + raise TypeError('callback must be callable, not None') + self.callback = callback + self.args = args + if self._flags & 6 == 4: + libev.ev_unref(self.loop._ptr) + self._flags |= 2 + libev.ev_signal_start(self.loop._ptr, &self._watcher) + if not self._flags & 1: + Py_INCREF(self) + self._flags |= 1 + + property active: + + def __get__(self): + return True if libev.ev_is_active(&self._watcher) else False + + + property pending: + + def __get__(self): + return True if libev.ev_is_pending(&self._watcher) else False + + 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, 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]: + + + cdef public loop loop + cdef object _callback + cdef public tuple args + cdef readonly int _flags + cdef libev.ev_idle _watcher + + property ref: + + def __get__(self): + return False if self._flags & 4 else True + + def __set__(self, object value): + + if not self.loop._ptr: + raise ValueError('operation on destroyed 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(callback) and callback is not None: + raise TypeError("Expected callable, not %r" % (callback, )) + self._callback = callback + + def stop(self): + + if not self.loop._ptr: + raise ValueError('operation on destroyed loop') + if self._flags & 2: + libev.ev_ref(self.loop._ptr) + self._flags &= ~2 + libev.ev_idle_stop(self.loop._ptr, &self._watcher) + self._callback = None + self.args = None + if self._flags & 1: + Py_DECREF(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): + + if not self.loop._ptr: + raise ValueError('operation on destroyed loop') + self.callback = callback + self.args = args + if self._flags & 6 == 4: + libev.ev_unref(self.loop._ptr) + self._flags |= 2 + libev.ev_feed_event(self.loop._ptr, &self._watcher, revents) + if not self._flags & 1: + Py_INCREF(self) + self._flags |= 1 + + def start(self, object callback, *args): + + if not self.loop._ptr: + raise ValueError('operation on destroyed loop') + if callback is None: + raise TypeError('callback must be callable, not None') + self.callback = callback + self.args = args + if self._flags & 6 == 4: + libev.ev_unref(self.loop._ptr) + self._flags |= 2 + libev.ev_idle_start(self.loop._ptr, &self._watcher) + if not self._flags & 1: + Py_INCREF(self) + self._flags |= 1 + + property active: + + def __get__(self): + return True if libev.ev_is_active(&self._watcher) else False + + + property pending: + + def __get__(self): + return True if libev.ev_is_pending(&self._watcher) else False + + + def __init__(self, loop loop , ref=True, priority=None): + libev.ev_idle_init(&self._watcher, gevent_callback_idle ) + 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 prepare(watcher) [object PyGeventPrepareObject, type PyGeventPrepare_Type]: + + + cdef public loop loop + cdef object _callback + cdef public tuple args + cdef readonly int _flags + cdef libev.ev_prepare _watcher + + property ref: + + def __get__(self): + return False if self._flags & 4 else True + + def __set__(self, object value): + + if not self.loop._ptr: + raise ValueError('operation on destroyed 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(callback) and callback is not None: + raise TypeError("Expected callable, not %r" % (callback, )) + self._callback = callback + + def stop(self): + + if not self.loop._ptr: + raise ValueError('operation on destroyed loop') + if self._flags & 2: + libev.ev_ref(self.loop._ptr) + self._flags &= ~2 + libev.ev_prepare_stop(self.loop._ptr, &self._watcher) + self._callback = None + self.args = None + if self._flags & 1: + Py_DECREF(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): + + if not self.loop._ptr: + raise ValueError('operation on destroyed loop') + self.callback = callback + self.args = args + if self._flags & 6 == 4: + libev.ev_unref(self.loop._ptr) + self._flags |= 2 + libev.ev_feed_event(self.loop._ptr, &self._watcher, revents) + if not self._flags & 1: + Py_INCREF(self) + self._flags |= 1 + + def start(self, object callback, *args): + + if not self.loop._ptr: + raise ValueError('operation on destroyed loop') + if callback is None: + raise TypeError('callback must be callable, not None') + self.callback = callback + self.args = args + if self._flags & 6 == 4: + libev.ev_unref(self.loop._ptr) + self._flags |= 2 + libev.ev_prepare_start(self.loop._ptr, &self._watcher) + if not self._flags & 1: + Py_INCREF(self) + self._flags |= 1 + + property active: + + def __get__(self): + return True if libev.ev_is_active(&self._watcher) else False + + + property pending: + + def __get__(self): + return True if libev.ev_is_pending(&self._watcher) else False + + + def __init__(self, loop loop , ref=True, priority=None): + libev.ev_prepare_init(&self._watcher, gevent_callback_prepare ) + 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 check(watcher) [object PyGeventCheckObject, type PyGeventCheck_Type]: + + + cdef public loop loop + cdef object _callback + cdef public tuple args + cdef readonly int _flags + cdef libev.ev_check _watcher + + property ref: + + def __get__(self): + return False if self._flags & 4 else True + + def __set__(self, object value): + + if not self.loop._ptr: + raise ValueError('operation on destroyed 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(callback) and callback is not None: + raise TypeError("Expected callable, not %r" % (callback, )) + self._callback = callback + + def stop(self): + + if not self.loop._ptr: + raise ValueError('operation on destroyed loop') + if self._flags & 2: + libev.ev_ref(self.loop._ptr) + self._flags &= ~2 + libev.ev_check_stop(self.loop._ptr, &self._watcher) + self._callback = None + self.args = None + if self._flags & 1: + Py_DECREF(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): + + if not self.loop._ptr: + raise ValueError('operation on destroyed loop') + self.callback = callback + self.args = args + if self._flags & 6 == 4: + libev.ev_unref(self.loop._ptr) + self._flags |= 2 + libev.ev_feed_event(self.loop._ptr, &self._watcher, revents) + if not self._flags & 1: + Py_INCREF(self) + self._flags |= 1 + + def start(self, object callback, *args): + + if not self.loop._ptr: + raise ValueError('operation on destroyed loop') + if callback is None: + raise TypeError('callback must be callable, not None') + self.callback = callback + self.args = args + if self._flags & 6 == 4: + libev.ev_unref(self.loop._ptr) + self._flags |= 2 + libev.ev_check_start(self.loop._ptr, &self._watcher) + if not self._flags & 1: + Py_INCREF(self) + self._flags |= 1 + + property active: + + def __get__(self): + return True if libev.ev_is_active(&self._watcher) else False + + + property pending: + + def __get__(self): + return True if libev.ev_is_pending(&self._watcher) else False + + + def __init__(self, loop loop , ref=True, priority=None): + libev.ev_check_init(&self._watcher, gevent_callback_check ) + 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 fork(watcher) [object PyGeventForkObject, type PyGeventFork_Type]: + + + cdef public loop loop + cdef object _callback + cdef public tuple args + cdef readonly int _flags + cdef libev.ev_fork _watcher + + property ref: + + def __get__(self): + return False if self._flags & 4 else True + + def __set__(self, object value): + + if not self.loop._ptr: + raise ValueError('operation on destroyed 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(callback) and callback is not None: + raise TypeError("Expected callable, not %r" % (callback, )) + self._callback = callback + + def stop(self): + + if not self.loop._ptr: + raise ValueError('operation on destroyed loop') + if self._flags & 2: + libev.ev_ref(self.loop._ptr) + self._flags &= ~2 + libev.ev_fork_stop(self.loop._ptr, &self._watcher) + self._callback = None + self.args = None + if self._flags & 1: + Py_DECREF(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): + + if not self.loop._ptr: + raise ValueError('operation on destroyed loop') + self.callback = callback + self.args = args + if self._flags & 6 == 4: + libev.ev_unref(self.loop._ptr) + self._flags |= 2 + libev.ev_feed_event(self.loop._ptr, &self._watcher, revents) + if not self._flags & 1: + Py_INCREF(self) + self._flags |= 1 + + def start(self, object callback, *args): + + if not self.loop._ptr: + raise ValueError('operation on destroyed loop') + if callback is None: + raise TypeError('callback must be callable, not None') + self.callback = callback + self.args = args + if self._flags & 6 == 4: + libev.ev_unref(self.loop._ptr) + self._flags |= 2 + libev.ev_fork_start(self.loop._ptr, &self._watcher) + if not self._flags & 1: + Py_INCREF(self) + self._flags |= 1 + + property active: + + def __get__(self): + return True if libev.ev_is_active(&self._watcher) else False + + + property pending: + + def __get__(self): + return True if libev.ev_is_pending(&self._watcher) else False + + + def __init__(self, loop loop , ref=True, priority=None): + libev.ev_fork_init(&self._watcher, gevent_callback_fork ) + 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 async(watcher) [object PyGeventAsyncObject, type PyGeventAsync_Type]: + + + cdef public loop loop + cdef object _callback + cdef public tuple args + cdef readonly int _flags + cdef libev.ev_async _watcher + + property ref: + + def __get__(self): + return False if self._flags & 4 else True + + def __set__(self, object value): + + if not self.loop._ptr: + raise ValueError('operation on destroyed 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(callback) and callback is not None: + raise TypeError("Expected callable, not %r" % (callback, )) + self._callback = callback + + def stop(self): + + if not self.loop._ptr: + raise ValueError('operation on destroyed loop') + if self._flags & 2: + libev.ev_ref(self.loop._ptr) + self._flags &= ~2 + libev.ev_async_stop(self.loop._ptr, &self._watcher) + self._callback = None + self.args = None + if self._flags & 1: + Py_DECREF(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): + + if not self.loop._ptr: + raise ValueError('operation on destroyed loop') + self.callback = callback + self.args = args + if self._flags & 6 == 4: + libev.ev_unref(self.loop._ptr) + self._flags |= 2 + libev.ev_feed_event(self.loop._ptr, &self._watcher, revents) + if not self._flags & 1: + Py_INCREF(self) + self._flags |= 1 + + def start(self, object callback, *args): + + if not self.loop._ptr: + raise ValueError('operation on destroyed loop') + if callback is None: + raise TypeError('callback must be callable, not None') + self.callback = callback + self.args = args + if self._flags & 6 == 4: + libev.ev_unref(self.loop._ptr) + self._flags |= 2 + libev.ev_async_start(self.loop._ptr, &self._watcher) + if not self._flags & 1: + Py_INCREF(self) + self._flags |= 1 + + property active: + + def __get__(self): + return True if libev.ev_is_active(&self._watcher) else False + + property pending: + + def __get__(self): + return True if libev.ev_async_pending(&self._watcher) else False + + + def __init__(self, loop loop , ref=True, priority=None): + libev.ev_async_init(&self._watcher, gevent_callback_async ) + self.loop = loop + if ref: + self._flags = 0 + else: + self._flags = 4 + if priority is not None: + libev.ev_set_priority(&self._watcher, priority) + + def send(self): + + if not self.loop._ptr: + raise ValueError('operation on destroyed loop') + libev.ev_async_send(self.loop._ptr, &self._watcher) + +#ifdef _WIN32 +#else + +cdef public class child(watcher) [object PyGeventChildObject, type PyGeventChild_Type]: + + + cdef public loop loop + cdef object _callback + cdef public tuple args + cdef readonly int _flags + cdef libev.ev_child _watcher + + property ref: + + def __get__(self): + return False if self._flags & 4 else True + + def __set__(self, object value): + + if not self.loop._ptr: + raise ValueError('operation on destroyed 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(callback) and callback is not None: + raise TypeError("Expected callable, not %r" % (callback, )) + self._callback = callback + + def stop(self): + + if not self.loop._ptr: + raise ValueError('operation on destroyed loop') + if self._flags & 2: + libev.ev_ref(self.loop._ptr) + self._flags &= ~2 + libev.ev_child_stop(self.loop._ptr, &self._watcher) + self._callback = None + self.args = None + if self._flags & 1: + Py_DECREF(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): + + if not self.loop._ptr: + raise ValueError('operation on destroyed loop') + self.callback = callback + self.args = args + if self._flags & 6 == 4: + libev.ev_unref(self.loop._ptr) + self._flags |= 2 + libev.ev_feed_event(self.loop._ptr, &self._watcher, revents) + if not self._flags & 1: + Py_INCREF(self) + self._flags |= 1 + + def start(self, object callback, *args): + + if not self.loop._ptr: + raise ValueError('operation on destroyed loop') + if callback is None: + raise TypeError('callback must be callable, not None') + self.callback = callback + self.args = args + if self._flags & 6 == 4: + libev.ev_unref(self.loop._ptr) + self._flags |= 2 + libev.ev_child_start(self.loop._ptr, &self._watcher) + if not self._flags & 1: + Py_INCREF(self) + self._flags |= 1 + + property active: + + def __get__(self): + return True if libev.ev_is_active(&self._watcher) else False + + + property pending: + + def __get__(self): + return True if libev.ev_is_pending(&self._watcher) else False + + 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, 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]: + + + cdef public loop loop + cdef object _callback + cdef public tuple args + cdef readonly int _flags + cdef libev.ev_stat _watcher + + property ref: + + def __get__(self): + return False if self._flags & 4 else True + + def __set__(self, object value): + + if not self.loop._ptr: + raise ValueError('operation on destroyed 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(callback) and callback is not None: + raise TypeError("Expected callable, not %r" % (callback, )) + self._callback = callback + + def stop(self): + + if not self.loop._ptr: + raise ValueError('operation on destroyed loop') + if self._flags & 2: + libev.ev_ref(self.loop._ptr) + self._flags &= ~2 + libev.ev_stat_stop(self.loop._ptr, &self._watcher) + self._callback = None + self.args = None + if self._flags & 1: + Py_DECREF(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): + + if not self.loop._ptr: + raise ValueError('operation on destroyed loop') + self.callback = callback + self.args = args + if self._flags & 6 == 4: + libev.ev_unref(self.loop._ptr) + self._flags |= 2 + libev.ev_feed_event(self.loop._ptr, &self._watcher, revents) + if not self._flags & 1: + Py_INCREF(self) + self._flags |= 1 + + def start(self, object callback, *args): + + if not self.loop._ptr: + raise ValueError('operation on destroyed loop') + if callback is None: + raise TypeError('callback must be callable, not None') + self.callback = callback + self.args = args + if self._flags & 6 == 4: + libev.ev_unref(self.loop._ptr) + self._flags |= 2 + libev.ev_stat_start(self.loop._ptr, &self._watcher) + if not self._flags & 1: + Py_INCREF(self) + self._flags |= 1 + + property active: + + def __get__(self): + return True if libev.ev_is_active(&self._watcher) else False + + + property pending: + + def __get__(self): + return True if libev.ev_is_pending(&self._watcher) else False + 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 = (path).encode(sys.getfilesystemencoding()) + self._paths = paths + else: + paths = path + self._paths = paths + libev.ev_stat_init(&self._watcher, gevent_callback_stat, 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(_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 diff --git a/python/gevent/libev/corecffi.py b/python/gevent/libev/corecffi.py new file mode 100644 index 0000000..7283fb4 --- /dev/null +++ b/python/gevent/libev/corecffi.py @@ -0,0 +1,1132 @@ +# pylint:disable=too-many-lines, protected-access, redefined-outer-name, not-callable, +# pylint:disable=no-member +from __future__ import absolute_import, print_function +import sys +import os +import traceback +import signal as signalmodule + +# pylint:disable=undefined-all-variable +__all__ = [ + 'get_version', + 'get_header_version', + 'supported_backends', + 'recommended_backends', + 'embeddable_backends', + 'time', + 'loop', +] + +import gevent.libev._corecffi as _corecffi # pylint:disable=no-name-in-module + +ffi = _corecffi.ffi # pylint:disable=no-member +libev = _corecffi.lib # pylint:disable=no-member + +if hasattr(libev, 'vfd_open'): + # Must be on windows + assert sys.platform.startswith("win"), "vfd functions only needed on windows" + vfd_open = libev.vfd_open + vfd_free = libev.vfd_free + vfd_get = libev.vfd_get +else: + vfd_open = vfd_free = vfd_get = lambda fd: fd + +##### +## NOTE on Windows: +# The C implementation does several things specially for Windows; +# a possibly incomplete list is: +# +# - the loop runs a periodic signal checker; +# - the io watcher constructor is different and it has a destructor; +# - the child watcher is not defined +# +# The CFFI implementation does none of these things, and so +# is possibly NOT FUNCTIONALLY CORRECT on Win32 +##### + +##### +## Note on CFFI objects, callbacks and the lifecycle of watcher objects +# +# Each subclass of `watcher` allocates a C structure of the +# appropriate type e.g., struct gevent_ev_io and holds this pointer in +# its `_gwatcher` attribute. When that watcher instance is garbage +# collected, then the C structure is also freed. The C structure is +# passed to libev from the watcher's start() method and then to the +# appropriate C callback function, e.g., _gevent_ev_io_callback, which +# passes it back to python's _python_callback where we need the +# watcher instance. Therefore, as long as that callback is active (the +# watcher is started), the watcher instance must not be allowed to get +# GC'd---any access at the C level or even the FFI level to the freed +# memory could crash the process. +# +# However, the typical idiom calls for writing something like this: +# loop.io(fd, python_cb).start() +# thus forgetting the newly created watcher subclass and allowing it to be immediately +# GC'd. To combat this, when the watcher is started, it places itself into the loop's +# `_keepaliveset`, and it only removes itself when the watcher's `stop()` method is called. +# Often, this is the *only* reference keeping the watcher object, and hence its C structure, +# alive. +# +# This is slightly complicated by the fact that the python-level +# callback, called from the C callback, could choose to manually stop +# the watcher. When we return to the C level callback, we now have an +# invalid pointer, and attempting to pass it back to Python (e.g., to +# handle an error) could crash. Hence, _python_callback, +# _gevent_io_callback, and _python_handle_error cooperate to make sure +# that the watcher instance stays in the loops `_keepaliveset` while +# the C code could be running---and if it gets removed, to not call back +# to Python again. +# See also https://github.com/gevent/gevent/issues/676 +#### + + +@ffi.callback("int(void* handle, int revents)") +def _python_callback(handle, revents): + """ + Returns an integer having one of three values: + + - -1 + An exception occurred during the callback and you must call + :func:`_python_handle_error` to deal with it. The Python watcher + object will have the exception tuple saved in ``_exc_info``. + - 0 + Everything went according to plan. You should check to see if the libev + watcher is still active, and call :func:`_python_stop` if so. This will + clean up the memory. + - 1 + Everything went according to plan, but the watcher has already + been stopped. Its memory may no longer be valid. + """ + try: + # Even dereferencing the handle needs to be inside the try/except; + # if we don't return normally (e.g., a signal) then we wind up going + # to the 'onerror' handler, which + # is not what we want; that can permanently wedge the loop depending + # on which callback was executing + the_watcher = ffi.from_handle(handle) + args = the_watcher.args + if args is None: + # Legacy behaviour from corecext: convert None into () + # See test__core_watcher.py + args = _NOARGS + if args and args[0] == GEVENT_CORE_EVENTS: + args = (revents, ) + args[1:] + the_watcher.callback(*args) + except: # pylint:disable=bare-except + the_watcher._exc_info = sys.exc_info() + # Depending on when the exception happened, the watcher + # may or may not have been stopped. We need to make sure its + # memory stays valid so we can stop it at the ev level if needed. + the_watcher.loop._keepaliveset.add(the_watcher) + return -1 + else: + if the_watcher in the_watcher.loop._keepaliveset: + # It didn't stop itself + return 0 + return 1 # It stopped itself +libev.python_callback = _python_callback + + +@ffi.callback("void(void* handle, int revents)") +def _python_handle_error(handle, revents): + try: + watcher = ffi.from_handle(handle) + exc_info = watcher._exc_info + del watcher._exc_info + watcher.loop.handle_error(watcher, *exc_info) + finally: + # XXX Since we're here on an error condition, and we + # made sure that the watcher object was put in loop._keepaliveset, + # what about not stopping the watcher? Looks like a possible + # memory leak? + if revents & (libev.EV_READ | libev.EV_WRITE): + try: + watcher.stop() + except: # pylint:disable=bare-except + watcher.loop.handle_error(watcher, *sys.exc_info()) + return # pylint:disable=lost-exception +libev.python_handle_error = _python_handle_error + + +@ffi.callback("void(void* handle)") +def _python_stop(handle): + watcher = ffi.from_handle(handle) + watcher.stop() +libev.python_stop = _python_stop + + +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 + + +class _EVENTSType(object): + def __repr__(self): + return 'gevent.core.EVENTS' + +EVENTS = GEVENT_CORE_EVENTS = _EVENTSType() + + +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) + +_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_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')] + + +def _flags_to_list(flags): + 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) + integer_types = (int,) +else: + import __builtin__ # pylint:disable=import-error + basestring = __builtin__.basestring, + integer_types = (int, __builtin__.long) + + +def _flags_to_int(flags): + # Note, that order does not matter, libev has its own predefined order + if not flags: + return 0 + if isinstance(flags, integer_types): + return flags + 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 + + +def _str_hex(flag): + if isinstance(flag, integer_types): + return hex(flag) + return str(flag) + + +def _check_flags(flags): + 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)) + + +def _events_to_str(events): + result = [] + 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() + +_default_loop_destroyed = False + + +def _loop_callback(*args, **kwargs): + return ffi.callback(*args, **kwargs) + + +class loop(object): + # pylint:disable=too-many-public-methods + + error_handler = None + + def __init__(self, flags=None, default=None): + self._in_callback = False + self._callbacks = [] + + # self._check is a watcher that runs in each iteration of the + # mainloop, just after the blocking call + self._check = ffi.new("struct ev_check *") + self._check_callback_ffi = _loop_callback("void(*)(struct ev_loop *, void*, int)", + self._check_callback, + onerror=self._check_callback_handle_error) + libev.ev_check_init(self._check, self._check_callback_ffi) + + # self._prepare is a watcher that runs in each iteration of the mainloop, + # just before the blocking call + self._prepare = ffi.new("struct ev_prepare *") + self._prepare_callback_ffi = _loop_callback("void(*)(struct ev_loop *, void*, int)", + self._run_callbacks, + onerror=self._check_callback_handle_error) + libev.ev_prepare_init(self._prepare, self._prepare_callback_ffi) + + # A timer we start and stop on demand. If we have callbacks, + # too many to run in one iteration of _run_callbacks, we turn this + # on so as to have the next iteration of the run loop return to us + # as quickly as possible. + # TODO: There may be a more efficient way to do this using ev_timer_again; + # see the "ev_timer" section of the ev manpage (http://linux.die.net/man/3/ev) + self._timer0 = ffi.new("struct ev_timer *") + libev.ev_timer_init(self._timer0, libev.gevent_noop, 0.0, 0.0) + + # TODO: We may be able to do something nicer and use the existing python_callback + # combined with onerror and the class check/timer/prepare to simplify things + # and unify our handling + + 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, )) + + 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 globals()["__SYSERR_CALLBACK"] is None: + set_syserr_cb(self._handle_syserr) + + libev.ev_prepare_start(self._ptr, self._prepare) + self.unref() + libev.ev_check_start(self._ptr, self._check) + self.unref() + + self._keepaliveset = set() + + def _check_callback_handle_error(self, t, v, tb): + # None as the context argument causes the exception to be raised + # in the main greenlet. + self.handle_error(None, t, v, tb) + + def _check_callback(self, *args): + # If we have the onerror callback, this is a no-op; all the real + # work to rethrow the exception is done by the onerror callback + pass + + def _run_callbacks(self, _evloop, _, _revents): + 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: + self.unref() + callback = cb.callback + args = cb.args + if callback is None or args is None: + # it's been stopped + continue + + cb.callback = None + + try: + callback(*args) + except: # pylint:disable=bare-except + # If we allow an exception to escape this method (while we are running the ev callback), + # then CFFI will print the error and libev will continue executing. + # There are two problems with this. The first is that the code after + # the loop won't run. The second is that any remaining callbacks scheduled + # for this loop iteration will be silently dropped; they won't run, but they'll + # also not be *stopped* (which is not a huge deal unless you're looking for + # consistency or checking the boolean/pending status; the loop doesn't keep + # a reference to them like it does to watchers...*UNLESS* the callback itself had + # a reference to a watcher; then I don't know what would happen, it depends on + # the state of the watcher---a leak or crash is not totally inconceivable). + # The Cython implementation in core.ppyx uses gevent_call from callbacks.c + # to run the callback, which uses gevent_handle_error to handle any errors the + # Python callback raises...it unconditionally simply prints any error raised + # by loop.handle_error and clears it, so callback handling continues. + # We take a similar approach (but are extra careful about printing) + try: + self.handle_error(cb, *sys.exc_info()) + except: # pylint:disable=bare-except + try: + print("Exception while handling another error", file=sys.stderr) + traceback.print_exc() + except: # pylint:disable=bare-except + pass # Nothing we can do here + finally: + # NOTE: this must be reset here, because cb.args is used as a flag in + # the callback class so that bool(cb) of a callback that has been run + # becomes False + cb.args = None + count -= 1 + if self._callbacks: + libev.ev_timer_start(self._ptr, self._timer0) + + def _stop_aux_watchers(self): + if libev.ev_is_active(self._prepare): + self.ref() + libev.ev_prepare_stop(self._ptr, self._prepare) + if libev.ev_is_active(self._check): + self.ref() + libev.ev_check_stop(self._ptr, self._check) + + def destroy(self): + global _default_loop_destroyed + if self._ptr: + self._stop_aux_watchers() + if globals()["__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 = ffi.NULL + + @property + def ptr(self): + return self._ptr + + @property + def WatcherType(self): + return watcher + + @property + def MAXPRI(self): + return libev.EV_MAXPRI + + @property + def MINPRI(self): + return libev.EV_MINPRI + + def _handle_syserr(self, message, errno): + try: + errno = os.strerror(errno) + except: # pylint:disable=bare-except + traceback.print_exc() + try: + message = '%s: %s' % (message, errno) + except: # pylint:disable=bare-except + traceback.print_exc() + self.handle_error(None, SystemError, SystemError(message), None) + + def handle_error(self, context, type, value, tb): + handle_error = None + 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) + + def _default_handle_error(self, context, type, value, tb): # pylint:disable=unused-argument + # 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) + libev.ev_break(self._ptr, libev.EVBREAK_ONE) + + def run(self, nowait=False, once=False): + flags = 0 + if nowait: + flags |= libev.EVRUN_NOWAIT + if once: + flags |= libev.EVRUN_ONCE + + libev.ev_run(self._ptr, flags) + + def reinit(self): + libev.ev_loop_fork(self._ptr) + + def ref(self): + libev.ev_ref(self._ptr) + + def unref(self): + libev.ev_unref(self._ptr) + + def break_(self, how=libev.EVBREAK_ONE): + libev.ev_break(self._ptr, how) + + def verify(self): + libev.ev_verify(self._ptr) + + def now(self): + return libev.ev_now(self._ptr) + + def update(self): + libev.ev_now_update(self._ptr) + + def __repr__(self): + return '<%s at 0x%x %s>' % (self.__class__.__name__, id(self), self._format()) + + @property + def default(self): + return True if libev.ev_is_default_loop(self._ptr) else False + + @property + def iteration(self): + return libev.ev_iteration(self._ptr) + + @property + def depth(self): + return libev.ev_depth(self._ptr) + + @property + def backend_int(self): + return libev.ev_backend(self._ptr) + + @property + def backend(self): + backend = libev.ev_backend(self._ptr) + for key, value in _flags: + if key == backend: + return value + return backend + + @property + def pendingcnt(self): + return libev.ev_pending_count(self._ptr) + + def io(self, fd, events, ref=True, priority=None): + return io(self, fd, events, ref, priority) + + def timer(self, after, repeat=0.0, ref=True, priority=None): + return timer(self, after, repeat, ref, priority) + + def signal(self, 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) + + if sys.platform != "win32": + + def child(self, pid, 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() + + def stat(self, path, interval=0.0, ref=True, priority=None): + return stat(self, path, interval, ref, priority) + + def callback(self, priority=None): + return callback(self, priority) + + def run_callback(self, func, *args): + cb = callback(func, args) + self._callbacks.append(cb) + self.ref() + + return cb + + def _format(self): + if not self._ptr: + return 'destroyed' + msg = self.backend + if self.default: + msg += ' default' + msg += ' pending=%s' % self.pendingcnt + msg += self._format_details() + return msg + + def _format_details(self): + msg = '' + fileno = self.fileno() + try: + activecnt = self.activecnt + except AttributeError: + activecnt = None + 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): + if self._ptr: + fd = self._ptr.backend_fd + if fd >= 0: + return fd + + @property + def activecnt(self): + if not self._ptr: + raise ValueError('operation on destroyed loop') + return self._ptr.activecnt + +# For times when *args is captured but often not passed (empty), +# we can avoid keeping the new tuple that was created for *args +# around by using a constant. +_NOARGS = () + + +class callback(object): + + __slots__ = ('callback', 'args') + + def __init__(self, callback, args): + self.callback = callback + self.args = args or _NOARGS + + def stop(self): + self.callback = None + self.args = None + + # Note that __nonzero__ and pending are different + # bool() 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 actually + # running the callback + + def __nonzero__(self): + # it's nonzero if it's pending or currently executing + # NOTE: This depends on loop._run_callbacks setting the args property + # to None. + return self.args is not None + __bool__ = __nonzero__ + + @property + def pending(self): + return self.callback is not None + + def _format(self): + return '' + + def __repr__(self): + result = "<%s at 0x%x" % (self.__class__.__name__, id(self)) + 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 + ">" + + +class watcher(object): + + def __init__(self, _loop, ref=True, priority=None, args=_NOARGS): + self.loop = _loop + if ref: + self._flags = 0 + else: + self._flags = 4 + self._args = None + self._callback = None + self._handle = ffi.new_handle(self) + + self._watcher = ffi.new(self._watcher_struct_pointer_type) + self._watcher.data = self._handle + if priority is not None: + libev.ev_set_priority(self._watcher, priority) + self._watcher_init(self._watcher, + self._watcher_callback, + *args) + + # A string identifying the type of libev object we watch, e.g., 'ev_io' + # This should be a class attribute. + _watcher_type = None + # A class attribute that is the callback on the libev object that init's the C struct, + # e.g., libev.ev_io_init. If None, will be set by _init_subclasses. + _watcher_init = None + # A class attribute that is the callback on the libev object that starts the C watcher, + # e.g., libev.ev_io_start. If None, will be set by _init_subclasses. + _watcher_start = None + # A class attribute that is the callback on the libev object that stops the C watcher, + # e.g., libev.ev_io_stop. If None, will be set by _init_subclasses. + _watcher_stop = None + # A cffi ctype object identifying the struct pointer we create. + # This is a class attribute set based on the _watcher_type + _watcher_struct_pointer_type = None + # The attribute of the libev object identifying the custom + # callback function for this type of watcher. This is a class + # attribute set based on the _watcher_type in _init_subclasses. + _watcher_callback = None + + @classmethod + def _init_subclasses(cls): + for subclass in cls.__subclasses__(): # pylint:disable=no-member + watcher_type = subclass._watcher_type + subclass._watcher_struct_pointer_type = ffi.typeof('struct ' + watcher_type + '*') + subclass._watcher_callback = ffi.addressof(libev, + '_gevent_generic_callback') + for name in 'start', 'stop', 'init': + ev_name = watcher_type + '_' + name + watcher_name = '_watcher' + '_' + name + if getattr(subclass, watcher_name) is None: + setattr(subclass, watcher_name, + getattr(libev, ev_name)) + + # this is not needed, since we keep alive the watcher while it's started + #def __del__(self): + # self._watcher_stop(self.loop._ptr, self._watcher) + + def __repr__(self): + formats = self._format() + result = "<%s at 0x%x%s" % (self.__class__.__name__, id(self), formats) + 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" + result += " handle=%s" % (self._watcher.data) + return result + ">" + + def _format(self): + return '' + + def _libev_unref(self): + if self._flags & 6 == 4: + self.loop.unref() + self._flags |= 2 + + def _get_ref(self): + return False if self._flags & 4 else True + + def _set_ref(self, value): + if value: + if not self._flags & 4: + return # ref is already True + if self._flags & 2: # ev_unref was called, undo + self.loop.ref() + 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): + self.loop.unref() + self._flags |= 2 + + ref = property(_get_ref, _set_ref) + + def _get_callback(self): + return self._callback + + def _set_callback(self, cb): + if not callable(cb) and cb is not None: + raise TypeError("Expected callable, not %r" % (cb, )) + self._callback = cb + callback = property(_get_callback, _set_callback) + + def _get_args(self): + return self._args + + def _set_args(self, args): + if not isinstance(args, tuple) and args is not None: + raise TypeError("args must be a tuple or None") + self._args = args + + args = property(_get_args, _set_args) + + def start(self, callback, *args): + if callback is None: + raise TypeError('callback must be callable, not None') + self.callback = callback + self.args = args or _NOARGS + self._libev_unref() + self.loop._keepaliveset.add(self) + self._watcher_start(self.loop._ptr, self._watcher) + + def stop(self): + if self._flags & 2: + self.loop.ref() + self._flags &= ~2 + self._watcher_stop(self.loop._ptr, self._watcher) + self.loop._keepaliveset.discard(self) + self._callback = None + self.args = None + + def _get_priority(self): + return libev.ev_priority(self._watcher) + + def _set_priority(self, priority): + if libev.ev_is_active(self._watcher): + raise AttributeError("Cannot set priority of an active watcher") + libev.ev_set_priority(self._watcher, priority) + + priority = property(_get_priority, _set_priority) + + def feed(self, revents, callback, *args): + self.callback = callback + self.args = args or _NOARGS + if self._flags & 6 == 4: + self.loop.unref() + self._flags |= 2 + libev.ev_feed_event(self.loop._ptr, self._watcher, revents) + if not self._flags & 1: + # Py_INCREF(self) + self._flags |= 1 + + @property + def active(self): + return True if libev.ev_is_active(self._watcher) else False + + @property + def pending(self): + return True if libev.ev_is_pending(self._watcher) else False + + +class io(watcher): + _watcher_type = 'ev_io' + + def __init__(self, loop, fd, events, ref=True, priority=None): + # XXX: Win32: Need to vfd_open the fd and free the old one? + # XXX: Win32: Need a destructor to free the old fd? + 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) + watcher.__init__(self, loop, ref=ref, priority=priority, args=(fd, events)) + + def start(self, callback, *args, **kwargs): + # pylint:disable=arguments-differ + args = args or _NOARGS + if kwargs.get('pass_events'): + args = (GEVENT_CORE_EVENTS, ) + args + watcher.start(self, callback, *args) + + def _get_fd(self): + return vfd_get(self._watcher.fd) + + def _set_fd(self, fd): + if libev.ev_is_active(self._watcher): + raise AttributeError("'io' watcher attribute 'fd' is read-only while watcher is active") + vfd = vfd_open(fd) + vfd_free(self._watcher.fd) + self._watcher_init(self._watcher, self._watcher_callback, vfd, self._watcher.events) + + fd = property(_get_fd, _set_fd) + + def _get_events(self): + return self._watcher.events + + def _set_events(self, events): + if libev.ev_is_active(self._watcher): + raise AttributeError("'io' watcher attribute 'events' is read-only while watcher is active") + self._watcher_init(self._watcher, self._watcher_callback, self._watcher.fd, events) + + events = property(_get_events, _set_events) + + @property + def events_str(self): + return _events_to_str(self._watcher.events) + + def _format(self): + return ' fd=%s events=%s' % (self.fd, self.events_str) + + +class timer(watcher): + _watcher_type = 'ev_timer' + + def __init__(self, loop, after=0.0, repeat=0.0, ref=True, priority=None): + if repeat < 0.0: + raise ValueError("repeat must be positive or zero: %r" % repeat) + watcher.__init__(self, loop, ref=ref, priority=priority, args=(after, repeat)) + + def start(self, callback, *args, **kw): + # pylint:disable=arguments-differ + update = kw.get("update", True) + if update: + # Quoth the libev doc: "This is a costly operation and is + # usually done automatically within ev_run(). This + # function is rarely useful, but when some event callback + # runs for a very long time without entering the event + # loop, updating libev's idea of the current time is a + # good idea." + # So do we really need to default to true? + libev.ev_now_update(self.loop._ptr) + watcher.start(self, callback, *args) + + @property + def at(self): + return self._watcher.at + + def again(self, callback, *args, **kw): + # Exactly the same as start(), just with a different initializer + # function + self._watcher_start = libev.ev_timer_again + try: + self.start(callback, *args, **kw) + finally: + del self._watcher_start + + +class signal(watcher): + _watcher_type = 'ev_signal' + + def __init__(self, loop, 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 + watcher.__init__(self, loop, ref=ref, priority=priority, args=(signalnum, )) + + +class idle(watcher): + _watcher_type = 'ev_idle' + + +class prepare(watcher): + _watcher_type = 'ev_prepare' + + +class check(watcher): + _watcher_type = 'ev_check' + + +class fork(watcher): + _watcher_type = 'ev_fork' + + +class async(watcher): + _watcher_type = 'ev_async' + + def send(self): + libev.ev_async_send(self.loop._ptr, self._watcher) + + @property + def pending(self): + return True if libev.ev_async_pending(self._watcher) else False + + +class child(watcher): + _watcher_type = 'ev_child' + + def __init__(self, loop, pid, trace=0, ref=True): + if not loop.default: + raise TypeError('child watchers are only available on the default loop') + loop.install_sigchld() + watcher.__init__(self, loop, ref=ref, args=(pid, trace)) + + def _format(self): + return ' pid=%r rstatus=%r' % (self.pid, self.rstatus) + + @property + def pid(self): + return self._watcher.pid + + @property + def rpid(self, ): + return self._watcher.rpid + + @rpid.setter + def rpid(self, value): + self._watcher.rpid = value + + @property + def rstatus(self): + return self._watcher.rstatus + + @rstatus.setter + def rstatus(self, value): + self._watcher.rstatus = value + + +class stat(watcher): + _watcher_type = 'ev_stat' + + @staticmethod + def _encode_path(path): + if isinstance(path, bytes): + return path + + # encode for the filesystem. Not all systems (e.g., Unix) + # will have an encoding specified + encoding = sys.getfilesystemencoding() or 'utf-8' + try: + path = path.encode(encoding, 'surrogateescape') + except LookupError: + # Can't encode it, and the error handler doesn't + # exist. Probably on Python 2 with an astral character. + # Not sure how to handle this. + raise UnicodeEncodeError("Can't encode path to filesystem encoding") + return path + + def __init__(self, _loop, path, interval=0.0, ref=True, priority=None): + # Store the encoded path in the same attribute that corecext does + self._paths = self._encode_path(path) + + # Keep the original path to avoid re-encoding, especially on Python 3 + self._path = path + + # Although CFFI would automatically convert a bytes object into a char* when + # calling ev_stat_init(..., char*, ...), on PyPy the char* pointer is not + # guaranteed to live past the function call. On CPython, only with a constant/interned + # bytes object is the pointer guaranteed to last path the function call. (And since + # Python 3 is pretty much guaranteed to produce a newly-encoded bytes object above, thats + # rarely the case). Therefore, we must keep a reference to the produced cdata object + # so that the struct ev_stat_watcher's `path` pointer doesn't become invalid/deallocated + self._cpath = ffi.new('char[]', self._paths) + + watcher.__init__(self, _loop, ref=ref, priority=priority, + args=(self._cpath, + interval)) + + @property + def path(self): + return self._path + + @property + def attr(self): + if not self._watcher.attr.st_nlink: + return + return self._watcher.attr + + @property + def prev(self): + if not self._watcher.prev.st_nlink: + return + return self._watcher.prev + + @property + def interval(self): + return self._watcher.interval + +# All watcher subclasses must be declared above. Now we do some +# initialization; this is not only a minor optimization, it protects +# against later runtime typos and attribute errors +watcher._init_subclasses() + + +def _syserr_cb(msg): + try: + msg = ffi.string(msg) + __SYSERR_CALLBACK(msg, ffi.errno) + except: + set_syserr_cb(None) + raise # let cffi print the traceback + +_syserr_cb._cb = ffi.callback("void(*)(char *msg)", _syserr_cb) + + +def set_syserr_cb(callback): + global __SYSERR_CALLBACK + if callback is None: + libev.ev_set_syserr_cb(ffi.NULL) + __SYSERR_CALLBACK = None + elif callable(callback): + libev.ev_set_syserr_cb(_syserr_cb._cb) + __SYSERR_CALLBACK = callback + else: + raise TypeError('Expected callable or None, got %r' % (callback, )) + +__SYSERR_CALLBACK = None + +LIBEV_EMBED = True diff --git a/python/gevent/libev/gevent.corecext.c b/python/gevent/libev/gevent.corecext.c new file mode 100644 index 0000000..d118d59 --- /dev/null +++ b/python/gevent/libev/gevent.corecext.c @@ -0,0 +1,33465 @@ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +/* Generated by cythonpp.py on 2017-06-05 11:30:19 */ +/* Generated by Cython 0.25.2 */ +#define PY_SSIZE_T_CLEAN +#include "Python.h" +#ifndef Py_PYTHON_H + #error Python headers needed to compile C extensions, please install development version of Python. +#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03020000) + #error Cython requires Python 2.6+ or Python 3.2+. +#else +#define CYTHON_ABI "0_25_2" +#include +#ifndef offsetof + #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) +#endif +#if !defined(WIN32) && !defined(MS_WINDOWS) + #ifndef __stdcall + #define __stdcall + #endif + #ifndef __cdecl + #define __cdecl + #endif + #ifndef __fastcall + #define __fastcall + #endif +#endif +#ifndef DL_IMPORT + #define DL_IMPORT(t) t +#endif +#ifndef DL_EXPORT + #define DL_EXPORT(t) t +#endif +#ifndef HAVE_LONG_LONG + #if PY_VERSION_HEX >= 0x03030000 || (PY_MAJOR_VERSION == 2 && PY_VERSION_HEX >= 0x02070000) + #define HAVE_LONG_LONG + #endif +#endif +#ifndef PY_LONG_LONG + #define PY_LONG_LONG LONG_LONG +#endif +#ifndef Py_HUGE_VAL + #define Py_HUGE_VAL HUGE_VAL +#endif +#ifdef PYPY_VERSION + #define CYTHON_COMPILING_IN_PYPY 1 + #define CYTHON_COMPILING_IN_PYSTON 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #undef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 1 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 +#elif defined(PYSTON_VERSION) + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_PYSTON 1 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 +#else + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_PYSTON 0 + #define CYTHON_COMPILING_IN_CPYTHON 1 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #if PY_MAJOR_VERSION < 3 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #elif !defined(CYTHON_USE_ASYNC_SLOTS) + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #if PY_VERSION_HEX < 0x02070000 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #elif !defined(CYTHON_USE_PYLONG_INTERNALS) + #define CYTHON_USE_PYLONG_INTERNALS 1 + #endif + #ifndef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 1 + #endif + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #if PY_VERSION_HEX < 0x030300F0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #elif !defined(CYTHON_USE_UNICODE_WRITER) + #define CYTHON_USE_UNICODE_WRITER 1 + #endif + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #ifndef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 1 + #endif + #ifndef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 1 + #endif +#endif +#if !defined(CYTHON_FAST_PYCCALL) +#define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) +#endif +#if CYTHON_USE_PYLONG_INTERNALS + #include "longintrepr.h" + #undef SHIFT + #undef BASE + #undef MASK +#endif +#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) + #define Py_OptimizeFlag 0 +#endif +#define __PYX_BUILD_PY_SSIZE_T "n" +#define CYTHON_FORMAT_SSIZE_T "z" +#if PY_MAJOR_VERSION < 3 + #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) + #define __Pyx_DefaultClassType PyClass_Type +#else + #define __Pyx_BUILTIN_MODULE_NAME "builtins" + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) + #define __Pyx_DefaultClassType PyType_Type +#endif +#ifndef Py_TPFLAGS_CHECKTYPES + #define Py_TPFLAGS_CHECKTYPES 0 +#endif +#ifndef Py_TPFLAGS_HAVE_INDEX + #define Py_TPFLAGS_HAVE_INDEX 0 +#endif +#ifndef Py_TPFLAGS_HAVE_NEWBUFFER + #define Py_TPFLAGS_HAVE_NEWBUFFER 0 +#endif +#ifndef Py_TPFLAGS_HAVE_FINALIZE + #define Py_TPFLAGS_HAVE_FINALIZE 0 +#endif +#ifndef METH_FASTCALL + #define METH_FASTCALL 0x80 + typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject **args, + Py_ssize_t nargs, PyObject *kwnames); +#else + #define __Pyx_PyCFunctionFast _PyCFunctionFast +#endif +#if CYTHON_FAST_PYCCALL +#define __Pyx_PyFastCFunction_Check(func)\ + ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST))))) +#else +#define __Pyx_PyFastCFunction_Check(func) 0 +#endif +#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) + #define CYTHON_PEP393_ENABLED 1 + #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ + 0 : _PyUnicode_Ready((PyObject *)(op))) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) + #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) + #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) + #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) +#else + #define CYTHON_PEP393_ENABLED 0 + #define PyUnicode_1BYTE_KIND 1 + #define PyUnicode_2BYTE_KIND 2 + #define PyUnicode_4BYTE_KIND 4 + #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111) + #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) + #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) + #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = ch) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) +#endif +#if CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) +#else + #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ + PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) + #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check) + #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format) + #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) + #define PyObject_Malloc(s) PyMem_Malloc(s) + #define PyObject_Free(p) PyMem_Free(p) + #define PyObject_Realloc(p) PyMem_Realloc(p) +#endif +#if CYTHON_COMPILING_IN_PYSTON + #define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno) +#else + #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) +#endif +#define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) +#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) +#else + #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) +#endif +#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII) + #define PyObject_ASCII(o) PyObject_Repr(o) +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBaseString_Type PyUnicode_Type + #define PyStringObject PyUnicodeObject + #define PyString_Type PyUnicode_Type + #define PyString_Check PyUnicode_Check + #define PyString_CheckExact PyUnicode_CheckExact +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) + #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) +#else + #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) + #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) +#endif +#ifndef PySet_CheckExact + #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) +#endif +#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) +#define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) +#if PY_MAJOR_VERSION >= 3 + #define PyIntObject PyLongObject + #define PyInt_Type PyLong_Type + #define PyInt_Check(op) PyLong_Check(op) + #define PyInt_CheckExact(op) PyLong_CheckExact(op) + #define PyInt_FromString PyLong_FromString + #define PyInt_FromUnicode PyLong_FromUnicode + #define PyInt_FromLong PyLong_FromLong + #define PyInt_FromSize_t PyLong_FromSize_t + #define PyInt_FromSsize_t PyLong_FromSsize_t + #define PyInt_AsLong PyLong_AsLong + #define PyInt_AS_LONG PyLong_AS_LONG + #define PyInt_AsSsize_t PyLong_AsSsize_t + #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask + #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask + #define PyNumber_Int PyNumber_Long +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBoolObject PyLongObject +#endif +#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY + #ifndef PyUnicode_InternFromString + #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) + #endif +#endif +#if PY_VERSION_HEX < 0x030200A4 + typedef long Py_hash_t; + #define __Pyx_PyInt_FromHash_t PyInt_FromLong + #define __Pyx_PyInt_AsHash_t PyInt_AsLong +#else + #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t + #define __Pyx_PyInt_AsHash_t PyInt_AsSsize_t +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : PyInstanceMethod_New(func)) +#else + #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) +#endif +#if CYTHON_USE_ASYNC_SLOTS + #if PY_VERSION_HEX >= 0x030500B1 + #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods + #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) + #else + typedef struct { + unaryfunc am_await; + unaryfunc am_aiter; + unaryfunc am_anext; + } __Pyx_PyAsyncMethodsStruct; + #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) + #endif +#else + #define __Pyx_PyType_AsAsync(obj) NULL +#endif +#ifndef CYTHON_RESTRICT + #if defined(__GNUC__) + #define CYTHON_RESTRICT __restrict__ + #elif defined(_MSC_VER) && _MSC_VER >= 1400 + #define CYTHON_RESTRICT __restrict + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_RESTRICT restrict + #else + #define CYTHON_RESTRICT + #endif +#endif +#ifndef CYTHON_UNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +#endif +#ifndef CYTHON_MAYBE_UNUSED_VAR +# if defined(__cplusplus) + template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } +# else +# define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) +# endif +#endif +#ifndef CYTHON_NCP_UNUSED +# if CYTHON_COMPILING_IN_CPYTHON +# define CYTHON_NCP_UNUSED +# else +# define CYTHON_NCP_UNUSED CYTHON_UNUSED +# endif +#endif +#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) + +#ifndef CYTHON_INLINE + #if defined(__clang__) + #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) + #elif defined(__GNUC__) + #define CYTHON_INLINE __inline__ + #elif defined(_MSC_VER) + #define CYTHON_INLINE __inline + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_INLINE inline + #else + #define CYTHON_INLINE + #endif +#endif + +#if defined(WIN32) || defined(MS_WINDOWS) + #define _USE_MATH_DEFINES +#endif +#include +#ifdef NAN +#define __PYX_NAN() ((float) NAN) +#else +static CYTHON_INLINE float __PYX_NAN() { + float value; + memset(&value, 0xFF, sizeof(value)); + return value; +} +#endif +#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) +#define __Pyx_truncl trunc +#else +#define __Pyx_truncl truncl +#endif + + +#define __PYX_ERR(f_index, lineno, Ln_error) \ +{ \ + __pyx_filename = __pyx_f[f_index]; __pyx_lineno = lineno; __pyx_clineno = __LINE__; goto Ln_error; \ +} + +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) +#else + #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) +#endif + +#ifndef __PYX_EXTERN_C + #ifdef __cplusplus + #define __PYX_EXTERN_C extern "C" + #else + #define __PYX_EXTERN_C extern + #endif +#endif + +#define __PYX_HAVE__gevent__libev__corecext +#define __PYX_HAVE_API__gevent__libev__corecext +#include "libev_vfd.h" +#include "libev.h" +#include "frameobject.h" +#include "callbacks.h" +#include "stathelper.c" +#ifdef _OPENMP +#include +#endif /* _OPENMP */ + +#ifdef PYREX_WITHOUT_ASSERTIONS +#define CYTHON_WITHOUT_ASSERTIONS +#endif + +typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding; + const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; + +#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 +#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT 0 +#define __PYX_DEFAULT_STRING_ENCODING "" +#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString +#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#define __Pyx_uchar_cast(c) ((unsigned char)c) +#define __Pyx_long_cast(x) ((long)x) +#define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ + (sizeof(type) < sizeof(Py_ssize_t)) ||\ + (sizeof(type) > sizeof(Py_ssize_t) &&\ + likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX) &&\ + (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ + v == (type)PY_SSIZE_T_MIN))) ||\ + (sizeof(type) == sizeof(Py_ssize_t) &&\ + (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX))) ) +#if defined (__cplusplus) && __cplusplus >= 201103L + #include + #define __Pyx_sst_abs(value) std::abs(value) +#elif SIZEOF_INT >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) abs(value) +#elif SIZEOF_LONG >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) labs(value) +#elif defined (_MSC_VER) && defined (_M_X64) + #define __Pyx_sst_abs(value) _abs64(value) +#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define __Pyx_sst_abs(value) llabs(value) +#elif defined (__GNUC__) + #define __Pyx_sst_abs(value) __builtin_llabs(value) +#else + #define __Pyx_sst_abs(value) ((value<0) ? -value : value) +#endif +static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject*); +static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); +#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) +#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) +#define __Pyx_PyBytes_FromString PyBytes_FromString +#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); +#if PY_MAJOR_VERSION < 3 + #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#else + #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize +#endif +#define __Pyx_PyObject_AsSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) +#define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) +#define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) +#define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) +#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) +#if PY_MAJOR_VERSION < 3 +static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) +{ + const Py_UNICODE *u_end = u; + while (*u_end++) ; + return (size_t)(u_end - u - 1); +} +#else +#define __Pyx_Py_UNICODE_strlen Py_UNICODE_strlen +#endif +#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) +#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode +#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode +#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) +#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) +#define __Pyx_PyBool_FromLong(b) ((b) ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False)) +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); +static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); +#if CYTHON_ASSUME_SAFE_MACROS +#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) +#else +#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) +#endif +#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) +#if PY_MAJOR_VERSION >= 3 +#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) +#else +#define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) +#endif +#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x)) +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII +static int __Pyx_sys_getdefaultencoding_not_ascii; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + PyObject* ascii_chars_u = NULL; + PyObject* ascii_chars_b = NULL; + const char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + if (strcmp(default_encoding_c, "ascii") == 0) { + __Pyx_sys_getdefaultencoding_not_ascii = 0; + } else { + char ascii_chars[128]; + int c; + for (c = 0; c < 128; c++) { + ascii_chars[c] = c; + } + __Pyx_sys_getdefaultencoding_not_ascii = 1; + ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); + if (!ascii_chars_u) goto bad; + ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); + if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { + PyErr_Format( + PyExc_ValueError, + "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", + default_encoding_c); + goto bad; + } + Py_DECREF(ascii_chars_u); + Py_DECREF(ascii_chars_b); + } + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + Py_XDECREF(ascii_chars_u); + Py_XDECREF(ascii_chars_b); + return -1; +} +#endif +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) +#else +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +static char* __PYX_DEFAULT_STRING_ENCODING; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c)); + if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; + strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + return -1; +} +#endif +#endif + + +/* Test for GCC > 2.95 */ +#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) + #define likely(x) __builtin_expect(!!(x), 1) + #define unlikely(x) __builtin_expect(!!(x), 0) +#else /* !__GNUC__ or GCC < 2.95 */ + #define likely(x) (x) + #define unlikely(x) (x) +#endif /* __GNUC__ */ + +static PyObject *__pyx_m; +static PyObject *__pyx_d; +static PyObject *__pyx_b; +static PyObject *__pyx_empty_tuple; +static PyObject *__pyx_empty_bytes; +static PyObject *__pyx_empty_unicode; +static int __pyx_lineno; +static int __pyx_clineno = 0; +static const char * __pyx_cfilenm= __FILE__; +static const char *__pyx_filename; + + +static const char *__pyx_f[] = { + "gevent.libev.corecext.pyx", +}; + +/*--- Type declarations ---*/ +struct __pyx_obj_6gevent_5libev_8corecext__EVENTSType; +struct PyGeventLoopObject; +struct PyGeventCallbackObject; +struct PyGeventWatcherObject; +struct PyGeventIOObject; +struct PyGeventTimerObject; +struct PyGeventSignalObject; +struct PyGeventIdleObject; +struct PyGeventPrepareObject; +struct PyGeventCheckObject; +struct PyGeventForkObject; +struct PyGeventAsyncObject; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +struct PyGeventChildObject; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +struct PyGeventStatObject; +struct __pyx_obj_6gevent_5libev_8corecext___pyx_scope_struct__genexpr; + +struct __pyx_obj_6gevent_5libev_8corecext__EVENTSType { + PyObject_HEAD +}; + + +struct PyGeventLoopObject { + PyObject_HEAD + struct __pyx_vtabstruct_6gevent_5libev_8corecext_loop *__pyx_vtab; + struct ev_loop *_ptr; + PyObject *error_handler; + struct ev_prepare _prepare; + PyObject *_callbacks; + struct ev_timer _timer0; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + struct ev_timer _periodic_signal_checker; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +}; + +__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyGeventLoop_Type; + +struct PyGeventCallbackObject { + PyObject_HEAD + PyObject *callback; + PyObject *args; +}; + +__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyGeventCallback_Type; + +struct PyGeventWatcherObject { + PyObject_HEAD +}; + +__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyGeventWatcher_Type; + +struct PyGeventIOObject { + struct PyGeventWatcherObject __pyx_base; + struct PyGeventLoopObject *loop; + PyObject *_callback; + PyObject *args; + int _flags; + struct ev_io _watcher; +}; + +__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyGeventIO_Type; + +struct PyGeventTimerObject { + struct PyGeventWatcherObject __pyx_base; + struct PyGeventLoopObject *loop; + PyObject *_callback; + PyObject *args; + int _flags; + struct ev_timer _watcher; +}; + +__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyGeventTimer_Type; + +struct PyGeventSignalObject { + struct PyGeventWatcherObject __pyx_base; + struct PyGeventLoopObject *loop; + PyObject *_callback; + PyObject *args; + int _flags; + struct ev_signal _watcher; +}; + +__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyGeventSignal_Type; + +struct PyGeventIdleObject { + struct PyGeventWatcherObject __pyx_base; + struct PyGeventLoopObject *loop; + PyObject *_callback; + PyObject *args; + int _flags; + struct ev_idle _watcher; +}; + +__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyGeventIdle_Type; + +struct PyGeventPrepareObject { + struct PyGeventWatcherObject __pyx_base; + struct PyGeventLoopObject *loop; + PyObject *_callback; + PyObject *args; + int _flags; + struct ev_prepare _watcher; +}; + +__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyGeventPrepare_Type; + +struct PyGeventCheckObject { + struct PyGeventWatcherObject __pyx_base; + struct PyGeventLoopObject *loop; + PyObject *_callback; + PyObject *args; + int _flags; + struct ev_check _watcher; +}; + +__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyGeventCheck_Type; + +struct PyGeventForkObject { + struct PyGeventWatcherObject __pyx_base; + struct PyGeventLoopObject *loop; + PyObject *_callback; + PyObject *args; + int _flags; + struct ev_fork _watcher; +}; + +__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyGeventFork_Type; + +struct PyGeventAsyncObject { + struct PyGeventWatcherObject __pyx_base; + struct PyGeventLoopObject *loop; + PyObject *_callback; + PyObject *args; + int _flags; + struct ev_async _watcher; +}; + +__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyGeventAsync_Type; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + +struct PyGeventChildObject { + struct PyGeventWatcherObject __pyx_base; + struct PyGeventLoopObject *loop; + PyObject *_callback; + PyObject *args; + int _flags; + struct ev_child _watcher; +}; + +__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyGeventChild_Type; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + +struct PyGeventStatObject { + struct PyGeventWatcherObject __pyx_base; + struct PyGeventLoopObject *loop; + PyObject *_callback; + PyObject *args; + int _flags; + struct ev_stat _watcher; + PyObject *path; + PyObject *_paths; +}; + +__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyGeventStat_Type; + +struct __pyx_obj_6gevent_5libev_8corecext___pyx_scope_struct__genexpr { + PyObject_HEAD + PyObject *__pyx_v_flag; + PyObject *__pyx_v_string; +}; + + +__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyGeventLoop_Type; + + +struct __pyx_vtabstruct_6gevent_5libev_8corecext_loop { + PyObject *(*_run_callbacks)(struct PyGeventLoopObject *); + PyObject *(*handle_error)(struct PyGeventLoopObject *, PyObject *, PyObject *, PyObject *, PyObject *, int __pyx_skip_dispatch); + PyObject *(*_default_handle_error)(struct PyGeventLoopObject *, PyObject *, PyObject *, PyObject *, PyObject *, int __pyx_skip_dispatch); +}; +static struct __pyx_vtabstruct_6gevent_5libev_8corecext_loop *__pyx_vtabptr_6gevent_5libev_8corecext_loop; + +/* --- Runtime support code (head) --- */ +/* Refnanny.proto */ +#ifndef CYTHON_REFNANNY + #define CYTHON_REFNANNY 0 +#endif +#if CYTHON_REFNANNY + typedef struct { + void (*INCREF)(void*, PyObject*, int); + void (*DECREF)(void*, PyObject*, int); + void (*GOTREF)(void*, PyObject*, int); + void (*GIVEREF)(void*, PyObject*, int); + void* (*SetupContext)(const char*, int, const char*); + void (*FinishContext)(void**); + } __Pyx_RefNannyAPIStruct; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); + #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; +#ifdef WITH_THREAD + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + if (acquire_gil) {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + PyGILState_Release(__pyx_gilstate_save);\ + } else {\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + } +#else + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) +#endif + #define __Pyx_RefNannyFinishContext()\ + __Pyx_RefNanny->FinishContext(&__pyx_refnanny) + #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) + #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) + #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) + #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) +#else + #define __Pyx_RefNannyDeclarations + #define __Pyx_RefNannySetupContext(name, acquire_gil) + #define __Pyx_RefNannyFinishContext() + #define __Pyx_INCREF(r) Py_INCREF(r) + #define __Pyx_DECREF(r) Py_DECREF(r) + #define __Pyx_GOTREF(r) + #define __Pyx_GIVEREF(r) + #define __Pyx_XINCREF(r) Py_XINCREF(r) + #define __Pyx_XDECREF(r) Py_XDECREF(r) + #define __Pyx_XGOTREF(r) + #define __Pyx_XGIVEREF(r) +#endif +#define __Pyx_XDECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_XDECREF(tmp);\ + } while (0) +#define __Pyx_DECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_DECREF(tmp);\ + } while (0) +#define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) +#define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) + +/* PyObjectGetAttrStr.proto */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro)) + return tp->tp_getattro(obj, attr_name); +#if PY_MAJOR_VERSION < 3 + if (likely(tp->tp_getattr)) + return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); +#endif + return PyObject_GetAttr(obj, attr_name); +} +#else +#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) +#endif + +/* GetBuiltinName.proto */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name); + +/* GetModuleGlobalName.proto */ +static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name); + +/* RaiseTooManyValuesToUnpack.proto */ +static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); + +/* RaiseNeedMoreValuesToUnpack.proto */ +static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); + +/* IterFinish.proto */ +static CYTHON_INLINE int __Pyx_IterFinish(void); + +/* UnpackItemEndCheck.proto */ +static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected); + +/* ListAppend.proto */ +#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS +static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) { + PyListObject* L = (PyListObject*) list; + Py_ssize_t len = Py_SIZE(list); + if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) { + Py_INCREF(x); + PyList_SET_ITEM(list, len, x); + Py_SIZE(list) = len+1; + return 0; + } + return PyList_Append(list, x); +} +#else +#define __Pyx_PyList_Append(L,x) PyList_Append(L,x) +#endif + +/* PyObjectCall.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); +#else +#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) +#endif + +/* PyCFunctionFastCall.proto */ +#if CYTHON_FAST_PYCCALL +static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs); +#else +#define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL) +#endif + +/* PyFunctionFastCall.proto */ +#if CYTHON_FAST_PYCALL +#define __Pyx_PyFunction_FastCall(func, args, nargs)\ + __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) +#if 1 || PY_VERSION_HEX < 0x030600B1 +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, int nargs, PyObject *kwargs); +#else +#define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs) +#endif +#endif + +/* PyObjectCallMethO.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); +#endif + +/* PyObjectCallOneArg.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); + +/* PyObjectCallNoArg.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); +#else +#define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL) +#endif + +/* PyThreadStateGet.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; +#define __Pyx_PyThreadState_assign __pyx_tstate = PyThreadState_GET(); +#else +#define __Pyx_PyThreadState_declare +#define __Pyx_PyThreadState_assign +#endif + +/* SaveResetException.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#define __Pyx_ExceptionReset(type, value, tb) __Pyx__ExceptionReset(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +#else +#define __Pyx_ExceptionSave(type, value, tb) PyErr_GetExcInfo(type, value, tb) +#define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb) +#endif + +/* PyErrExceptionMatches.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) +static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); +#else +#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) +#endif + +/* GetException.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb) +static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#else +static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); +#endif + +/* StringJoin.proto */ +#if PY_MAJOR_VERSION < 3 +#define __Pyx_PyString_Join __Pyx_PyBytes_Join +#define __Pyx_PyBaseString_Join(s, v) (PyUnicode_CheckExact(s) ? PyUnicode_Join(s, v) : __Pyx_PyBytes_Join(s, v)) +#else +#define __Pyx_PyString_Join PyUnicode_Join +#define __Pyx_PyBaseString_Join PyUnicode_Join +#endif +#if CYTHON_COMPILING_IN_CPYTHON + #if PY_MAJOR_VERSION < 3 + #define __Pyx_PyBytes_Join _PyString_Join + #else + #define __Pyx_PyBytes_Join _PyBytes_Join + #endif +#else +static CYTHON_INLINE PyObject* __Pyx_PyBytes_Join(PyObject* sep, PyObject* values); +#endif + +/* PyErrFetchRestore.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#else +#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) +#endif + +/* RaiseException.proto */ +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); + +/* ListCompAppend.proto */ +#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS +static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) { + PyListObject* L = (PyListObject*) list; + Py_ssize_t len = Py_SIZE(list); + if (likely(L->allocated > len)) { + Py_INCREF(x); + PyList_SET_ITEM(list, len, x); + Py_SIZE(list) = len+1; + return 0; + } + return PyList_Append(list, x); +} +#else +#define __Pyx_ListComp_Append(L,x) PyList_Append(L,x) +#endif + +/* RaiseDoubleKeywords.proto */ +static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); + +/* ParseKeywords.proto */ +static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ + PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ + const char* function_name); + +/* RaiseArgTupleInvalid.proto */ +static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, + Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); + +/* ExtTypeTest.proto */ +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); + +/* WriteUnraisableException.proto */ +static void __Pyx_WriteUnraisable(const char *name, int clineno, + int lineno, const char *filename, + int full_traceback, int nogil); + +/* GetItemInt.proto */ +#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\ + (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\ + __Pyx_GetItemInt_Generic(o, to_py_func(i)))) +#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ + (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck); +#define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ + (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL)) +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck); +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, + int is_list, int wraparound, int boundscheck); + +/* GetAttr.proto */ +static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *); + +/* GetAttr3.proto */ +static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *, PyObject *, PyObject *); + +/* ArgTypeTest.proto */ +static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed, + const char *name, int exact); + +/* SwapException.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_ExceptionSwap(type, value, tb) __Pyx__ExceptionSwap(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#else +static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb); +#endif + +/* PyObjectSetAttrStr.proto */ +#if CYTHON_USE_TYPE_SLOTS +#define __Pyx_PyObject_DelAttrStr(o,n) __Pyx_PyObject_SetAttrStr(o,n,NULL) +static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr_name, PyObject* value) { + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_setattro)) + return tp->tp_setattro(obj, attr_name, value); +#if PY_MAJOR_VERSION < 3 + if (likely(tp->tp_setattr)) + return tp->tp_setattr(obj, PyString_AS_STRING(attr_name), value); +#endif + return PyObject_SetAttr(obj, attr_name, value); +} +#else +#define __Pyx_PyObject_DelAttrStr(o,n) PyObject_DelAttr(o,n) +#define __Pyx_PyObject_SetAttrStr(o,n,v) PyObject_SetAttr(o,n,v) +#endif + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) +/* KeywordStringCheck.proto */ +static CYTHON_INLINE int __Pyx_CheckKeywordStrings(PyObject *kwdict, const char* function_name, int kw_allowed); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +/* ForceInitThreads.proto */ +#ifndef __PYX_FORCE_INIT_THREADS + #define __PYX_FORCE_INIT_THREADS 0 +#endif + +/* CallableCheck.proto */ +#if CYTHON_USE_TYPE_SLOTS && PY_MAJOR_VERSION >= 3 +#define __Pyx_PyCallable_Check(obj) ((obj)->ob_type->tp_call != NULL) +#else +#define __Pyx_PyCallable_Check(obj) PyCallable_Check(obj) +#endif + +/* CallNextTpTraverse.proto */ +static int __Pyx_call_next_tp_traverse(PyObject* obj, visitproc v, void *a, traverseproc current_tp_traverse); + +/* CallNextTpClear.proto */ +static void __Pyx_call_next_tp_clear(PyObject* obj, inquiry current_tp_dealloc); + +/* IncludeStringH.proto */ +#include + +/* SetVTable.proto */ +static int __Pyx_SetVtable(PyObject *dict, void *vtable); + +/* CodeObjectCache.proto */ +typedef struct { + PyCodeObject* code_object; + int code_line; +} __Pyx_CodeObjectCacheEntry; +struct __Pyx_CodeObjectCache { + int count; + int max_count; + __Pyx_CodeObjectCacheEntry* entries; +}; +static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); +static PyCodeObject *__pyx_find_code_object(int code_line); +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); + +/* AddTraceback.proto */ +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_int(unsigned int value); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_vfd_socket_t(vfd_socket_t value); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +/* CIntFromPy.proto */ +static CYTHON_INLINE unsigned int __Pyx_PyInt_As_unsigned_int(PyObject *); + +/* CIntFromPy.proto */ +static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); + +/* CIntFromPy.proto */ +static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *); +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + +/* CIntFromPy.proto */ +static CYTHON_INLINE vfd_socket_t __Pyx_PyInt_As_vfd_socket_t(PyObject *); +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + +/* CIntFromPy.proto */ +static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); + +/* FetchCommonType.proto */ +static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type); + +/* PyObjectCallMethod1.proto */ +static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg); + +/* CoroutineBase.proto */ +typedef PyObject *(*__pyx_coroutine_body_t)(PyObject *, PyObject *); +typedef struct { + PyObject_HEAD + __pyx_coroutine_body_t body; + PyObject *closure; + PyObject *exc_type; + PyObject *exc_value; + PyObject *exc_traceback; + PyObject *gi_weakreflist; + PyObject *classobj; + PyObject *yieldfrom; + PyObject *gi_name; + PyObject *gi_qualname; + PyObject *gi_modulename; + int resume_label; + char is_running; +} __pyx_CoroutineObject; +static __pyx_CoroutineObject *__Pyx__Coroutine_New( + PyTypeObject *type, __pyx_coroutine_body_t body, PyObject *closure, + PyObject *name, PyObject *qualname, PyObject *module_name); +static int __Pyx_Coroutine_clear(PyObject *self); +#if 1 || PY_VERSION_HEX < 0x030300B0 +static int __Pyx_PyGen_FetchStopIterationValue(PyObject **pvalue); +#else +#define __Pyx_PyGen_FetchStopIterationValue(pvalue) PyGen_FetchStopIterationValue(pvalue) +#endif + +/* PatchModuleWithCoroutine.proto */ +static PyObject* __Pyx_Coroutine_patch_module(PyObject* module, const char* py_code); + +/* PatchGeneratorABC.proto */ +static int __Pyx_patch_abc(void); + +/* Generator.proto */ +#define __Pyx_Generator_USED +static PyTypeObject *__pyx_GeneratorType = 0; +#define __Pyx_Generator_CheckExact(obj) (Py_TYPE(obj) == __pyx_GeneratorType) +#define __Pyx_Generator_New(body, closure, name, qualname, module_name)\ + __Pyx__Coroutine_New(__pyx_GeneratorType, body, closure, name, qualname, module_name) +static PyObject *__Pyx_Generator_Next(PyObject *self); +static int __pyx_Generator_init(void); + +/* CheckBinaryVersion.proto */ +static int __Pyx_check_binary_version(void); + +/* InitStrings.proto */ +static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); + +static PyObject *__pyx_f_6gevent_5libev_8corecext_4loop__run_callbacks(struct PyGeventLoopObject *__pyx_v_self); /* proto*/ +static PyObject *__pyx_f_6gevent_5libev_8corecext_4loop_handle_error(struct PyGeventLoopObject *__pyx_v_self, PyObject *__pyx_v_context, PyObject *__pyx_v_type, PyObject *__pyx_v_value, PyObject *__pyx_v_tb, int __pyx_skip_dispatch); /* proto*/ +static PyObject *__pyx_f_6gevent_5libev_8corecext_4loop__default_handle_error(struct PyGeventLoopObject *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_context, PyObject *__pyx_v_type, PyObject *__pyx_v_value, PyObject *__pyx_v_tb, int __pyx_skip_dispatch); /* proto*/ + +/* Module declarations from 'cython' */ + +/* Module declarations from 'libev' */ + +/* Module declarations from 'python' */ + +/* Module declarations from 'gevent.libev.corecext' */ +static PyTypeObject *__pyx_ptype_6gevent_5libev_8corecext__EVENTSType = 0; +static PyTypeObject *__pyx_ptype_6gevent_5libev_8corecext_loop = 0; +static PyTypeObject *__pyx_ptype_6gevent_5libev_8corecext_callback = 0; +static PyTypeObject *__pyx_ptype_6gevent_5libev_8corecext_watcher = 0; +static PyTypeObject *__pyx_ptype_6gevent_5libev_8corecext_io = 0; +static PyTypeObject *__pyx_ptype_6gevent_5libev_8corecext_timer = 0; +static PyTypeObject *__pyx_ptype_6gevent_5libev_8corecext_signal = 0; +static PyTypeObject *__pyx_ptype_6gevent_5libev_8corecext_idle = 0; +static PyTypeObject *__pyx_ptype_6gevent_5libev_8corecext_prepare = 0; +static PyTypeObject *__pyx_ptype_6gevent_5libev_8corecext_check = 0; +static PyTypeObject *__pyx_ptype_6gevent_5libev_8corecext_fork = 0; +static PyTypeObject *__pyx_ptype_6gevent_5libev_8corecext_async = 0; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyTypeObject *__pyx_ptype_6gevent_5libev_8corecext_child = 0; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyTypeObject *__pyx_ptype_6gevent_5libev_8corecext_stat = 0; +static PyTypeObject *__pyx_ptype_6gevent_5libev_8corecext___pyx_scope_struct__genexpr = 0; +static PyObject *__pyx_v_6gevent_5libev_8corecext_integer_types = 0; +__PYX_EXTERN_C DL_EXPORT(PyObject) *GEVENT_CORE_EVENTS; +static int __pyx_v_6gevent_5libev_8corecext__default_loop_destroyed; +static PyObject *__pyx_f_6gevent_5libev_8corecext__flags_to_list(unsigned int, int __pyx_skip_dispatch); /*proto*/ +static unsigned int __pyx_f_6gevent_5libev_8corecext__flags_to_int(PyObject *, int __pyx_skip_dispatch); /*proto*/ +static PyObject *__pyx_f_6gevent_5libev_8corecext__str_hex(PyObject *); /*proto*/ +static PyObject *__pyx_f_6gevent_5libev_8corecext__check_flags(unsigned int, int __pyx_skip_dispatch); /*proto*/ +static PyObject *__pyx_f_6gevent_5libev_8corecext__events_to_str(int, int __pyx_skip_dispatch); /*proto*/ +static void __pyx_f_6gevent_5libev_8corecext__syserr_cb(char *); /*proto*/ +static PyObject *__pyx_f_6gevent_5libev_8corecext_set_syserr_cb(PyObject *, int __pyx_skip_dispatch); /*proto*/ +#define __Pyx_MODULE_NAME "gevent.libev.corecext" +int __pyx_module_is_main_gevent__libev__corecext = 0; + +/* Implementation of 'gevent.libev.corecext' */ +static PyObject *__pyx_builtin___import__; +static PyObject *__pyx_builtin_KeyError; +static PyObject *__pyx_builtin_ValueError; +static PyObject *__pyx_builtin_hex; +static PyObject *__pyx_builtin_SystemError; +static PyObject *__pyx_builtin_id; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_builtin_AttributeError; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_builtin_TypeError; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) +static PyObject *__pyx_builtin_AttributeError; +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static const char __pyx_k_[] = ","; +static const char __pyx_k__3[] = ", "; +static const char __pyx_k__4[] = "|"; +static const char __pyx_k__5[] = ": "; +static const char __pyx_k_fd[] = "fd"; +static const char __pyx_k_id[] = "id"; +static const char __pyx_k_os[] = "os"; +static const char __pyx_k_tb[] = "tb"; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) +static const char __pyx_k__21[] = "<...>"; +static const char __pyx_k__22[] = ">"; +static const char __pyx_k__23[] = ""; +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static const char __pyx_k__21[] = ""; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) +static const char __pyx_k__27[] = "<...>"; +static const char __pyx_k__28[] = ">"; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static const char __pyx_k__26[] = "<...>"; +static const char __pyx_k__27[] = ">"; +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static const char __pyx_k_all[] = "__all__"; +static const char __pyx_k_hex[] = "hex"; +static const char __pyx_k_how[] = "how"; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static const char __pyx_k_pid[] = "pid"; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static const char __pyx_k_ptr[] = "ptr"; +static const char __pyx_k_ref[] = "ref"; +static const char __pyx_k_sys[] = "sys"; +static const char __pyx_k_FORK[] = "FORK"; +static const char __pyx_k_IDLE[] = "IDLE"; +static const char __pyx_k_NONE[] = "NONE"; +static const char __pyx_k_NSIG[] = "NSIG"; +static const char __pyx_k_READ[] = "READ"; +static const char __pyx_k_STAT[] = "STAT"; +static const char __pyx_k_args[] = "args"; +static const char __pyx_k_func[] = "func"; +static const char __pyx_k_join[] = "join"; +static const char __pyx_k_keys[] = "keys"; +static const char __pyx_k_loop[] = "loop"; +static const char __pyx_k_main[] = "__main__"; +static const char __pyx_k_name[] = "__name__"; +static const char __pyx_k_once[] = "once"; +static const char __pyx_k_path[] = "path"; +static const char __pyx_k_poll[] = "poll"; +static const char __pyx_k_port[] = "port"; +static const char __pyx_k_send[] = "send"; +static const char __pyx_k_test[] = "__test__"; +static const char __pyx_k_time[] = "time"; +static const char __pyx_k_type[] = "type"; +static const char __pyx_k_ASYNC[] = "ASYNC"; +static const char __pyx_k_CHECK[] = "CHECK"; +static const char __pyx_k_CHILD[] = "CHILD"; +static const char __pyx_k_EMBED[] = "EMBED"; +static const char __pyx_k_ERROR[] = "ERROR"; +static const char __pyx_k_TIMER[] = "TIMER"; +static const char __pyx_k_UNDEF[] = "UNDEF"; +static const char __pyx_k_WRITE[] = "WRITE"; +static const char __pyx_k_after[] = "after"; +static const char __pyx_k_class[] = "__class__"; +static const char __pyx_k_close[] = "close"; +static const char __pyx_k_epoll[] = "epoll"; +static const char __pyx_k_errno[] = "errno"; +static const char __pyx_k_flags[] = "_flags"; +static const char __pyx_k_level[] = "level"; +static const char __pyx_k_lower[] = "lower"; +static const char __pyx_k_noenv[] = "noenv"; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static const char __pyx_k_ref_2[] = " ref="; +static const char __pyx_k_sigfd[] = "sigfd"; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static const char __pyx_k_split[] = "split"; +static const char __pyx_k_strip[] = "strip"; +static const char __pyx_k_throw[] = "throw"; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static const char __pyx_k_trace[] = "trace"; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static const char __pyx_k_value[] = "value"; +static const char __pyx_k_CUSTOM[] = "CUSTOM"; +static const char __pyx_k_EVENTS[] = "EVENTS"; +static const char __pyx_k_MAXPRI[] = "MAXPRI"; +static const char __pyx_k_MINPRI[] = "MINPRI"; +static const char __pyx_k_SIGNAL[] = "SIGNAL"; +static const char __pyx_k_active[] = "active"; +static const char __pyx_k_args_r[] = " args=%r"; +static const char __pyx_k_decode[] = "decode"; +static const char __pyx_k_encode[] = "encode"; +static const char __pyx_k_events[] = "_events"; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static const char __pyx_k_fileno[] = "fileno"; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static const char __pyx_k_format[] = "_format"; +static const char __pyx_k_import[] = "__import__"; +static const char __pyx_k_kqueue[] = "kqueue"; +static const char __pyx_k_nowait[] = "nowait"; +static const char __pyx_k_repeat[] = "repeat"; +static const char __pyx_k_select[] = "select"; +static const char __pyx_k_signal[] = "signal"; +static const char __pyx_k_signum[] = "signum"; +static const char __pyx_k_update[] = "update"; +static const char __pyx_k_CLEANUP[] = "CLEANUP"; +static const char __pyx_k_IOFDSET[] = "_IOFDSET"; +static const char __pyx_k_PREPARE[] = "PREPARE"; +static const char __pyx_k_backend[] = "backend"; +static const char __pyx_k_context[] = "context"; +static const char __pyx_k_default[] = "default"; +static const char __pyx_k_flags_2[] = "flags"; +static const char __pyx_k_genexpr[] = "genexpr"; +static const char __pyx_k_message[] = "message"; +static const char __pyx_k_pending[] = "pending"; +static const char __pyx_k_revents[] = "revents"; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static const char __pyx_k_rstatus[] = "rstatus"; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static const char __pyx_k_sigfd_2[] = " sigfd="; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static const char __pyx_k_stopped[] = " stopped"; +static const char __pyx_k_KeyError[] = "KeyError"; +static const char __pyx_k_PERIODIC[] = "PERIODIC"; +static const char __pyx_k_SIGNALFD[] = "SIGNALFD"; +static const char __pyx_k_active_2[] = " active"; +static const char __pyx_k_builtins[] = "__builtins__"; +static const char __pyx_k_callback[] = "callback"; +static const char __pyx_k_events_2[] = "events"; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static const char __pyx_k_fileno_2[] = " fileno="; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static const char __pyx_k_interval[] = "interval"; +static const char __pyx_k_priority[] = "priority"; +static const char __pyx_k_signalfd[] = "signalfd"; +static const char __pyx_k_strerror[] = "strerror"; +static const char __pyx_k_FORKCHECK[] = "FORKCHECK"; +static const char __pyx_k_NOINOTIFY[] = "NOINOTIFY"; +static const char __pyx_k_NOSIGMASK[] = "NOSIGMASK"; +static const char __pyx_k_READWRITE[] = "READWRITE"; +static const char __pyx_k_TypeError[] = "TypeError"; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static const char __pyx_k_activecnt[] = "activecnt"; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static const char __pyx_k_default_2[] = " default"; +static const char __pyx_k_destroyed[] = "destroyed"; +static const char __pyx_k_forkcheck[] = "forkcheck"; +static const char __pyx_k_noinotify[] = "noinotify"; +static const char __pyx_k_nosigmask[] = "nosigmask"; +static const char __pyx_k_pending_2[] = " pending"; +static const char __pyx_k_pending_s[] = " pending=%s"; +static const char __pyx_k_print_exc[] = "print_exc"; +static const char __pyx_k_signalnum[] = "signalnum"; +static const char __pyx_k_traceback[] = "traceback"; +static const char __pyx_k_ValueError[] = "ValueError"; +static const char __pyx_k_basestring[] = "basestring"; +static const char __pyx_k_callback_r[] = " callback=%r"; +static const char __pyx_k_events_str[] = "events_str"; +static const char __pyx_k_pendingcnt[] = "pendingcnt"; +static const char __pyx_k_pyx_vtable[] = "__pyx_vtable__"; +static const char __pyx_k_LIBEV_EMBED[] = "LIBEV_EMBED"; +static const char __pyx_k_SystemError[] = "SystemError"; +static const char __pyx_k_get_version[] = "get_version"; +static const char __pyx_k_libev_d_02d[] = "libev-%d.%02d"; +static const char __pyx_k_pass_events[] = "pass_events"; +static const char __pyx_k_s_at_0x_x_s[] = "<%s at 0x%x %s>"; +static const char __pyx_k_BACKEND_POLL[] = "BACKEND_POLL"; +static const char __pyx_k_BACKEND_PORT[] = "BACKEND_PORT"; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static const char __pyx_k_EV_USE_4HEAP[] = "EV_USE_4HEAP"; +static const char __pyx_k_EV_USE_FLOOR[] = "EV_USE_FLOOR"; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static const char __pyx_k_handle_error[] = "handle_error"; +static const char __pyx_k_signalmodule[] = "signalmodule"; +static const char __pyx_k_version_info[] = "version_info"; +static const char __pyx_k_BACKEND_EPOLL[] = "BACKEND_EPOLL"; +static const char __pyx_k_fd_s_events_s[] = " fd=%s events=%s"; +static const char __pyx_k_flags_str2int[] = "_flags_str2int"; +static const char __pyx_k_handle_syserr[] = "_handle_syserr"; +static const char __pyx_k_s_at_0x_x_s_2[] = "<%s at 0x%x%s"; +static const char __pyx_k_stop_watchers[] = "_stop_watchers"; +static const char __pyx_k_AttributeError[] = "AttributeError"; +static const char __pyx_k_BACKEND_KQUEUE[] = "BACKEND_KQUEUE"; +static const char __pyx_k_BACKEND_SELECT[] = "BACKEND_SELECT"; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static const char __pyx_k_EV_USE_EVENTFD[] = "EV_USE_EVENTFD"; +static const char __pyx_k_EV_USE_INOTIFY[] = "EV_USE_INOTIFY"; +static const char __pyx_k_format_details[] = "_format_details"; +static const char __pyx_k_EV_USE_REALTIME[] = "EV_USE_REALTIME"; +static const char __pyx_k_EV_USE_SIGNALFD[] = "EV_USE_SIGNALFD"; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static const char __pyx_k_SYSERR_CALLBACK[] = "__SYSERR_CALLBACK"; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static const char __pyx_k_pid_r_rstatus_r[] = " pid=%r rstatus=%r"; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static const char __pyx_k_print_exception[] = "print_exception"; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static const char __pyx_k_EV_USE_MONOTONIC[] = "EV_USE_MONOTONIC"; +static const char __pyx_k_EV_USE_NANOSLEEP[] = "EV_USE_NANOSLEEP"; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static const char __pyx_k_get_header_version[] = "get_header_version"; +static const char __pyx_k_gevent_core_EVENTS[] = "gevent.core.EVENTS"; +static const char __pyx_k_supported_backends[] = "supported_backends"; +static const char __pyx_k_embeddable_backends[] = "embeddable_backends"; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static const char __pyx_k_EV_USE_CLOCK_SYSCALL[] = "EV_USE_CLOCK_SYSCALL"; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static const char __pyx_k_default_handle_error[] = "_default_handle_error"; +static const char __pyx_k_ev_loop_new_s_failed[] = "ev_loop_new(%s) failed"; +static const char __pyx_k_illegal_event_mask_r[] = "illegal event mask: %r"; +static const char __pyx_k_recommended_backends[] = "recommended_backends"; +static const char __pyx_k_Unsupported_backend_s[] = "Unsupported backend: %s"; +static const char __pyx_k_getfilesystemencoding[] = "getfilesystemencoding"; +static const char __pyx_k_gevent_libev_corecext[] = "gevent.libev.corecext"; +static const char __pyx_k_Expected_callable_not_r[] = "Expected callable, not %r"; +static const char __pyx_k_illegal_signal_number_r[] = "illegal signal number: %r"; +static const char __pyx_k_ev_default_loop_s_failed[] = "ev_default_loop(%s) failed"; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static const char __pyx_k_fd_must_be_non_negative_r[] = "fd must be non-negative: %r"; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static const char __pyx_k_operation_on_destroyed_loop[] = "operation on destroyed loop"; +static const char __pyx_k_Invalid_value_for_backend_0x_x[] = "Invalid value for backend: 0x%x"; +static const char __pyx_k_io_watcher_attribute_events_is[] = "'io' watcher attribute 'events' is read-only while watcher is active"; +static const char __pyx_k_Expected_callable_or_None_got_r[] = "Expected callable or None, got %r"; +static const char __pyx_k_io_watcher_attribute_fd_is_read[] = "'io' watcher attribute 'fd' is read-only while watcher is active"; +static const char __pyx_k_repeat_must_be_positive_or_zero[] = "repeat must be positive or zero: %r"; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static const char __pyx_k_C_Users_appveyor_AppData_Local_T[] = "C:\\Users\\appveyor\\AppData\\Local\\Temp\\1\\tmpqvkqo2j9\\gevent.libev.corecext.pyx"; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) +static const char __pyx_k_C_Users_appveyor_AppData_Local_T[] = "C:\\Users\\appveyor\\AppData\\Local\\Temp\\1\\tmp2ctkbz0o\\gevent.libev.corecext.pyx"; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) +static const char __pyx_k_C_Users_appveyor_AppData_Local_T[] = "C:\\Users\\appveyor\\AppData\\Local\\Temp\\1\\tmp2ae88oah\\gevent.libev.corecext.pyx"; +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) +static const char __pyx_k_C_Users_appveyor_AppData_Local_T[] = "C:\\Users\\appveyor\\AppData\\Local\\Temp\\1\\tmpoursn1jm\\gevent.libev.corecext.pyx"; +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) +static const char __pyx_k_C_Users_appveyor_AppData_Local_T[] = "C:\\Users\\appveyor\\AppData\\Local\\Temp\\1\\tmp60jryori\\gevent.libev.corecext.pyx"; +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static const char __pyx_k_C_Users_appveyor_AppData_Local_T[] = "C:\\Users\\appveyor\\AppData\\Local\\Temp\\1\\tmpetzymc07\\gevent.libev.corecext.pyx"; +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static const char __pyx_k_Cannot_set_priority_of_an_active[] = "Cannot set priority of an active watcher"; +static const char __pyx_k_Invalid_backend_or_flag_s_Possib[] = "Invalid backend or flag: %s\nPossible values: %s"; +static const char __pyx_k_callback_must_be_callable_not_No[] = "callback must be callable, not None"; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static const char __pyx_k_child_watchers_are_only_availabl[] = "child watchers are only available on the default loop"; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_kp_s_; +static PyObject *__pyx_n_s_ASYNC; +static PyObject *__pyx_n_s_AttributeError; +static PyObject *__pyx_n_s_BACKEND_EPOLL; +static PyObject *__pyx_n_s_BACKEND_KQUEUE; +static PyObject *__pyx_n_s_BACKEND_POLL; +static PyObject *__pyx_n_s_BACKEND_PORT; +static PyObject *__pyx_n_s_BACKEND_SELECT; +static PyObject *__pyx_n_s_CHECK; +static PyObject *__pyx_n_s_CHILD; +static PyObject *__pyx_n_s_CLEANUP; +static PyObject *__pyx_n_s_CUSTOM; +static PyObject *__pyx_kp_s_C_Users_appveyor_AppData_Local_T; +static PyObject *__pyx_kp_s_Cannot_set_priority_of_an_active; +static PyObject *__pyx_n_s_EMBED; +static PyObject *__pyx_n_s_ERROR; +static PyObject *__pyx_n_s_EVENTS; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_n_s_EV_USE_4HEAP; +static PyObject *__pyx_n_s_EV_USE_CLOCK_SYSCALL; +static PyObject *__pyx_n_s_EV_USE_EVENTFD; +static PyObject *__pyx_n_s_EV_USE_FLOOR; +static PyObject *__pyx_n_s_EV_USE_INOTIFY; +static PyObject *__pyx_n_s_EV_USE_MONOTONIC; +static PyObject *__pyx_n_s_EV_USE_NANOSLEEP; +static PyObject *__pyx_n_s_EV_USE_REALTIME; +static PyObject *__pyx_n_s_EV_USE_SIGNALFD; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_kp_s_Expected_callable_not_r; +static PyObject *__pyx_kp_s_Expected_callable_or_None_got_r; +static PyObject *__pyx_n_s_FORK; +static PyObject *__pyx_n_s_FORKCHECK; +static PyObject *__pyx_n_s_IDLE; +static PyObject *__pyx_n_s_IOFDSET; +static PyObject *__pyx_kp_s_Invalid_backend_or_flag_s_Possib; +static PyObject *__pyx_kp_s_Invalid_value_for_backend_0x_x; +static PyObject *__pyx_n_s_KeyError; +static PyObject *__pyx_n_s_LIBEV_EMBED; +static PyObject *__pyx_n_s_MAXPRI; +static PyObject *__pyx_n_s_MINPRI; +static PyObject *__pyx_n_s_NOINOTIFY; +static PyObject *__pyx_n_s_NONE; +static PyObject *__pyx_n_s_NOSIGMASK; +static PyObject *__pyx_n_s_NSIG; +static PyObject *__pyx_n_s_PERIODIC; +static PyObject *__pyx_n_s_PREPARE; +static PyObject *__pyx_n_s_READ; +static PyObject *__pyx_n_s_READWRITE; +static PyObject *__pyx_n_s_SIGNAL; +static PyObject *__pyx_n_s_SIGNALFD; +static PyObject *__pyx_n_s_STAT; +static PyObject *__pyx_n_s_SYSERR_CALLBACK; +static PyObject *__pyx_n_s_SystemError; +static PyObject *__pyx_n_s_TIMER; +static PyObject *__pyx_n_s_TypeError; +static PyObject *__pyx_n_s_UNDEF; +static PyObject *__pyx_kp_s_Unsupported_backend_s; +static PyObject *__pyx_n_s_ValueError; +static PyObject *__pyx_n_s_WRITE; +static PyObject *__pyx_kp_s__21; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) +static PyObject *__pyx_kp_s__22; +static PyObject *__pyx_kp_s__23; +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_kp_s__26; +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_kp_s__27; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) +static PyObject *__pyx_kp_s__28; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_kp_s__3; +static PyObject *__pyx_kp_s__4; +static PyObject *__pyx_kp_s__5; +static PyObject *__pyx_n_s_active; +static PyObject *__pyx_kp_s_active_2; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_n_s_activecnt; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_n_s_after; +static PyObject *__pyx_n_s_all; +static PyObject *__pyx_n_s_args; +static PyObject *__pyx_kp_s_args_r; +static PyObject *__pyx_n_s_backend; +static PyObject *__pyx_n_s_basestring; +static PyObject *__pyx_n_s_builtins; +static PyObject *__pyx_n_s_callback; +static PyObject *__pyx_kp_s_callback_must_be_callable_not_No; +static PyObject *__pyx_kp_s_callback_r; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_kp_s_child_watchers_are_only_availabl; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_n_s_class; +static PyObject *__pyx_n_s_close; +static PyObject *__pyx_n_s_context; +static PyObject *__pyx_n_s_decode; +static PyObject *__pyx_n_s_default; +static PyObject *__pyx_kp_s_default_2; +static PyObject *__pyx_n_s_default_handle_error; +static PyObject *__pyx_n_s_destroyed; +static PyObject *__pyx_n_s_embeddable_backends; +static PyObject *__pyx_n_s_encode; +static PyObject *__pyx_n_s_epoll; +static PyObject *__pyx_n_s_errno; +static PyObject *__pyx_kp_s_ev_default_loop_s_failed; +static PyObject *__pyx_kp_s_ev_loop_new_s_failed; +static PyObject *__pyx_n_s_events; +static PyObject *__pyx_n_s_events_2; +static PyObject *__pyx_n_s_events_str; +static PyObject *__pyx_n_s_fd; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_kp_s_fd_must_be_non_negative_r; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_kp_s_fd_s_events_s; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_n_s_fileno; +static PyObject *__pyx_kp_s_fileno_2; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_n_s_flags; +static PyObject *__pyx_n_s_flags_2; +static PyObject *__pyx_n_s_flags_str2int; +static PyObject *__pyx_n_s_forkcheck; +static PyObject *__pyx_n_s_format; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_n_s_format_details; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_n_s_func; +static PyObject *__pyx_n_s_genexpr; +static PyObject *__pyx_n_s_get_header_version; +static PyObject *__pyx_n_s_get_version; +static PyObject *__pyx_n_s_getfilesystemencoding; +static PyObject *__pyx_kp_s_gevent_core_EVENTS; +static PyObject *__pyx_n_s_gevent_libev_corecext; +static PyObject *__pyx_n_s_handle_error; +static PyObject *__pyx_n_s_handle_syserr; +static PyObject *__pyx_n_s_hex; +static PyObject *__pyx_n_s_how; +static PyObject *__pyx_n_s_id; +static PyObject *__pyx_kp_s_illegal_event_mask_r; +static PyObject *__pyx_kp_s_illegal_signal_number_r; +static PyObject *__pyx_n_s_import; +static PyObject *__pyx_n_s_interval; +static PyObject *__pyx_kp_s_io_watcher_attribute_events_is; +static PyObject *__pyx_kp_s_io_watcher_attribute_fd_is_read; +static PyObject *__pyx_n_s_join; +static PyObject *__pyx_n_s_keys; +static PyObject *__pyx_n_s_kqueue; +static PyObject *__pyx_n_s_level; +static PyObject *__pyx_kp_s_libev_d_02d; +static PyObject *__pyx_n_s_loop; +static PyObject *__pyx_n_s_lower; +static PyObject *__pyx_n_s_main; +static PyObject *__pyx_n_s_message; +static PyObject *__pyx_n_s_name; +static PyObject *__pyx_n_s_noenv; +static PyObject *__pyx_n_s_noinotify; +static PyObject *__pyx_n_s_nosigmask; +static PyObject *__pyx_n_s_nowait; +static PyObject *__pyx_n_s_once; +static PyObject *__pyx_kp_s_operation_on_destroyed_loop; +static PyObject *__pyx_n_s_os; +static PyObject *__pyx_n_s_pass_events; +static PyObject *__pyx_n_s_path; +static PyObject *__pyx_n_s_pending; +static PyObject *__pyx_kp_s_pending_2; +static PyObject *__pyx_kp_s_pending_s; +static PyObject *__pyx_n_s_pendingcnt; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_n_s_pid; +static PyObject *__pyx_kp_s_pid_r_rstatus_r; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_n_s_poll; +static PyObject *__pyx_n_s_port; +static PyObject *__pyx_n_s_print_exc; +static PyObject *__pyx_n_s_print_exception; +static PyObject *__pyx_n_s_priority; +static PyObject *__pyx_n_s_ptr; +static PyObject *__pyx_n_s_pyx_vtable; +static PyObject *__pyx_n_s_recommended_backends; +static PyObject *__pyx_n_s_ref; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_kp_s_ref_2; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_n_s_repeat; +static PyObject *__pyx_kp_s_repeat_must_be_positive_or_zero; +static PyObject *__pyx_n_s_revents; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_n_s_rstatus; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_kp_s_s_at_0x_x_s; +static PyObject *__pyx_kp_s_s_at_0x_x_s_2; +static PyObject *__pyx_n_s_select; +static PyObject *__pyx_n_s_send; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_n_s_sigfd; +static PyObject *__pyx_kp_s_sigfd_2; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_n_s_signal; +static PyObject *__pyx_n_s_signalfd; +static PyObject *__pyx_n_s_signalmodule; +static PyObject *__pyx_n_s_signalnum; +static PyObject *__pyx_n_s_signum; +static PyObject *__pyx_n_s_split; +static PyObject *__pyx_n_s_stop_watchers; +static PyObject *__pyx_kp_s_stopped; +static PyObject *__pyx_n_s_strerror; +static PyObject *__pyx_n_s_strip; +static PyObject *__pyx_n_s_supported_backends; +static PyObject *__pyx_n_s_sys; +static PyObject *__pyx_n_s_tb; +static PyObject *__pyx_n_s_test; +static PyObject *__pyx_n_s_throw; +static PyObject *__pyx_n_s_time; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_n_s_trace; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_n_s_traceback; +static PyObject *__pyx_n_s_type; +static PyObject *__pyx_n_s_update; +static PyObject *__pyx_n_s_value; +static PyObject *__pyx_n_s_version_info; +static PyObject *__pyx_pf_6gevent_5libev_8corecext_22genexpr(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_11_EVENTSType___repr__(CYTHON_UNUSED struct __pyx_obj_6gevent_5libev_8corecext__EVENTSType *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_get_version(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_2get_header_version(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4_flags_to_list(CYTHON_UNUSED PyObject *__pyx_self, unsigned int __pyx_v_flags); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_6_flags_to_int(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_flags); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_8_check_flags(CYTHON_UNUSED PyObject *__pyx_self, unsigned int __pyx_v_flags); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_10_events_to_str(CYTHON_UNUSED PyObject *__pyx_self, int __pyx_v_events); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_12supported_backends(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_14recommended_backends(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_16embeddable_backends(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_18time(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_4loop___init__(struct PyGeventLoopObject *__pyx_v_self, PyObject *__pyx_v_flags, PyObject *__pyx_v_default, size_t __pyx_v_ptr); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_2_stop_watchers(struct PyGeventLoopObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_4destroy(struct PyGeventLoopObject *__pyx_v_self); /* proto */ +static void __pyx_pf_6gevent_5libev_8corecext_4loop_6__dealloc__(struct PyGeventLoopObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_3ptr___get__(struct PyGeventLoopObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_11WatcherType___get__(CYTHON_UNUSED struct PyGeventLoopObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_6MAXPRI___get__(CYTHON_UNUSED struct PyGeventLoopObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_6MINPRI___get__(CYTHON_UNUSED struct PyGeventLoopObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_8_handle_syserr(struct PyGeventLoopObject *__pyx_v_self, PyObject *__pyx_v_message, PyObject *__pyx_v_errno); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_10handle_error(struct PyGeventLoopObject *__pyx_v_self, PyObject *__pyx_v_context, PyObject *__pyx_v_type, PyObject *__pyx_v_value, PyObject *__pyx_v_tb); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_12_default_handle_error(struct PyGeventLoopObject *__pyx_v_self, PyObject *__pyx_v_context, PyObject *__pyx_v_type, PyObject *__pyx_v_value, PyObject *__pyx_v_tb); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_14run(struct PyGeventLoopObject *__pyx_v_self, PyObject *__pyx_v_nowait, PyObject *__pyx_v_once); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_16reinit(struct PyGeventLoopObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_18ref(struct PyGeventLoopObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_20unref(struct PyGeventLoopObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_22break_(struct PyGeventLoopObject *__pyx_v_self, int __pyx_v_how); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_24verify(struct PyGeventLoopObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_26now(struct PyGeventLoopObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_28update(struct PyGeventLoopObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_30__repr__(struct PyGeventLoopObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_7default___get__(struct PyGeventLoopObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_9iteration___get__(struct PyGeventLoopObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_5depth___get__(struct PyGeventLoopObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_11backend_int___get__(struct PyGeventLoopObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_7backend___get__(struct PyGeventLoopObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_10pendingcnt___get__(struct PyGeventLoopObject *__pyx_v_self); /* proto */ +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_32io(struct PyGeventLoopObject *__pyx_v_self, vfd_socket_t __pyx_v_fd, int __pyx_v_events, PyObject *__pyx_v_ref, PyObject *__pyx_v_priority); /* proto */ +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_32io(struct PyGeventLoopObject *__pyx_v_self, int __pyx_v_fd, int __pyx_v_events, PyObject *__pyx_v_ref, PyObject *__pyx_v_priority); /* proto */ +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_32io(struct PyGeventLoopObject *__pyx_v_self, vfd_socket_t __pyx_v_fd, int __pyx_v_events, PyObject *__pyx_v_ref, PyObject *__pyx_v_priority); /* proto */ +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_34timer(struct PyGeventLoopObject *__pyx_v_self, double __pyx_v_after, double __pyx_v_repeat, PyObject *__pyx_v_ref, PyObject *__pyx_v_priority); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_36signal(struct PyGeventLoopObject *__pyx_v_self, int __pyx_v_signum, PyObject *__pyx_v_ref, PyObject *__pyx_v_priority); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_38idle(struct PyGeventLoopObject *__pyx_v_self, PyObject *__pyx_v_ref, PyObject *__pyx_v_priority); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_40prepare(struct PyGeventLoopObject *__pyx_v_self, PyObject *__pyx_v_ref, PyObject *__pyx_v_priority); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_42check(struct PyGeventLoopObject *__pyx_v_self, PyObject *__pyx_v_ref, PyObject *__pyx_v_priority); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_44fork(struct PyGeventLoopObject *__pyx_v_self, PyObject *__pyx_v_ref, PyObject *__pyx_v_priority); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_46async(struct PyGeventLoopObject *__pyx_v_self, PyObject *__pyx_v_ref, PyObject *__pyx_v_priority); /* proto */ +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_48stat(struct PyGeventLoopObject *__pyx_v_self, PyObject *__pyx_v_path, float __pyx_v_interval, PyObject *__pyx_v_ref, PyObject *__pyx_v_priority); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_50run_callback(struct PyGeventLoopObject *__pyx_v_self, PyObject *__pyx_v_func, PyObject *__pyx_v_args); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_52_format(struct PyGeventLoopObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_54_format_details(struct PyGeventLoopObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_56fileno(struct PyGeventLoopObject *__pyx_v_self); /* proto */ +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_48child(struct PyGeventLoopObject *__pyx_v_self, int __pyx_v_pid, int __pyx_v_trace, PyObject *__pyx_v_ref); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_50install_sigchld(CYTHON_UNUSED struct PyGeventLoopObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_52reset_sigchld(CYTHON_UNUSED struct PyGeventLoopObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_54stat(struct PyGeventLoopObject *__pyx_v_self, PyObject *__pyx_v_path, float __pyx_v_interval, PyObject *__pyx_v_ref, PyObject *__pyx_v_priority); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_56run_callback(struct PyGeventLoopObject *__pyx_v_self, PyObject *__pyx_v_func, PyObject *__pyx_v_args); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_58_format(struct PyGeventLoopObject *__pyx_v_self); /* proto */ +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_60_format_details(struct PyGeventLoopObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_62fileno(struct PyGeventLoopObject *__pyx_v_self); /* proto */ +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_48stat(struct PyGeventLoopObject *__pyx_v_self, PyObject *__pyx_v_path, float __pyx_v_interval, PyObject *__pyx_v_ref, PyObject *__pyx_v_priority); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_50run_callback(struct PyGeventLoopObject *__pyx_v_self, PyObject *__pyx_v_func, PyObject *__pyx_v_args); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_52_format(struct PyGeventLoopObject *__pyx_v_self); /* proto */ +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_54_format_details(struct PyGeventLoopObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_56fileno(struct PyGeventLoopObject *__pyx_v_self); /* proto */ +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_60_format_details(struct PyGeventLoopObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_62fileno(struct PyGeventLoopObject *__pyx_v_self); /* proto */ +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_9activecnt___get__(struct PyGeventLoopObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_11sig_pending___get__(struct PyGeventLoopObject *__pyx_v_self); /* proto */ +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_5sigfd___get__(struct PyGeventLoopObject *__pyx_v_self); /* proto */ +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_9origflags___get__(struct PyGeventLoopObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_13origflags_int___get__(struct PyGeventLoopObject *__pyx_v_self); /* proto */ +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_13error_handler___get__(struct PyGeventLoopObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_4loop_13error_handler_2__set__(struct PyGeventLoopObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_4loop_13error_handler_4__del__(struct PyGeventLoopObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_10_callbacks___get__(struct PyGeventLoopObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_4loop_10_callbacks_2__set__(struct PyGeventLoopObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_4loop_10_callbacks_4__del__(struct PyGeventLoopObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_8callback___init__(struct PyGeventCallbackObject *__pyx_v_self, PyObject *__pyx_v_callback, PyObject *__pyx_v_args); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_8callback_2stop(struct PyGeventCallbackObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_8callback_4__nonzero__(struct PyGeventCallbackObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_8callback_7pending___get__(struct PyGeventCallbackObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_8callback_6__repr__(struct PyGeventCallbackObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_8callback_8_format(CYTHON_UNUSED struct PyGeventCallbackObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_8callback_8callback___get__(struct PyGeventCallbackObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_8callback_8callback_2__set__(struct PyGeventCallbackObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_8callback_8callback_4__del__(struct PyGeventCallbackObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_8callback_4args___get__(struct PyGeventCallbackObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_8callback_4args_2__set__(struct PyGeventCallbackObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_8callback_4args_4__del__(struct PyGeventCallbackObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_7watcher___repr__(struct PyGeventWatcherObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_7watcher_2_format(CYTHON_UNUSED struct PyGeventWatcherObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_2io_3ref___get__(struct PyGeventIOObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_2io_3ref_2__set__(struct PyGeventIOObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_2io_8callback___get__(struct PyGeventIOObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_2io_8callback_2__set__(struct PyGeventIOObject *__pyx_v_self, PyObject *__pyx_v_callback); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_2io_stop(struct PyGeventIOObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_2io_8priority___get__(struct PyGeventIOObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_2io_8priority_2__set__(struct PyGeventIOObject *__pyx_v_self, int __pyx_v_priority); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_2io_2feed(struct PyGeventIOObject *__pyx_v_self, int __pyx_v_revents, PyObject *__pyx_v_callback, PyObject *__pyx_v_args); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_2io_4start(struct PyGeventIOObject *__pyx_v_self, PyObject *__pyx_v_callback, PyObject *__pyx_v_pass_events, PyObject *__pyx_v_args); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_2io_6active___get__(struct PyGeventIOObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_2io_7pending___get__(struct PyGeventIOObject *__pyx_v_self); /* proto */ +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) +static int __pyx_pf_6gevent_5libev_8corecext_2io_6__init__(struct PyGeventIOObject *__pyx_v_self, struct PyGeventLoopObject *__pyx_v_loop, vfd_socket_t __pyx_v_fd, int __pyx_v_events, PyObject *__pyx_v_ref, PyObject *__pyx_v_priority); /* proto */ +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static int __pyx_pf_6gevent_5libev_8corecext_2io_6__init__(struct PyGeventIOObject *__pyx_v_self, struct PyGeventLoopObject *__pyx_v_loop, int __pyx_v_fd, int __pyx_v_events, PyObject *__pyx_v_ref, PyObject *__pyx_v_priority); /* proto */ +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) +static int __pyx_pf_6gevent_5libev_8corecext_2io_6__init__(struct PyGeventIOObject *__pyx_v_self, struct PyGeventLoopObject *__pyx_v_loop, vfd_socket_t __pyx_v_fd, int __pyx_v_events, PyObject *__pyx_v_ref, PyObject *__pyx_v_priority); /* proto */ +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_pf_6gevent_5libev_8corecext_2io_2fd___get__(struct PyGeventIOObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_2io_2fd_2__set__(struct PyGeventIOObject *__pyx_v_self, long __pyx_v_fd); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_2io_6events___get__(struct PyGeventIOObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_2io_6events_2__set__(struct PyGeventIOObject *__pyx_v_self, int __pyx_v_events); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_2io_10events_str___get__(struct PyGeventIOObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_2io_8_format(struct PyGeventIOObject *__pyx_v_self); /* proto */ +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) +static int __pyx_pf_6gevent_5libev_8corecext_2io_10__cinit__(struct PyGeventIOObject *__pyx_v_self); /* proto */ +static void __pyx_pf_6gevent_5libev_8corecext_2io_12__dealloc__(struct PyGeventIOObject *__pyx_v_self); /* proto */ +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_pf_6gevent_5libev_8corecext_2io_4loop___get__(struct PyGeventIOObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_2io_4loop_2__set__(struct PyGeventIOObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_2io_4loop_4__del__(struct PyGeventIOObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_2io_4args___get__(struct PyGeventIOObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_2io_4args_2__set__(struct PyGeventIOObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_2io_4args_4__del__(struct PyGeventIOObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_2io_6_flags___get__(struct PyGeventIOObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5timer_3ref___get__(struct PyGeventTimerObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_5timer_3ref_2__set__(struct PyGeventTimerObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5timer_8callback___get__(struct PyGeventTimerObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_5timer_8callback_2__set__(struct PyGeventTimerObject *__pyx_v_self, PyObject *__pyx_v_callback); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5timer_stop(struct PyGeventTimerObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5timer_8priority___get__(struct PyGeventTimerObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_5timer_8priority_2__set__(struct PyGeventTimerObject *__pyx_v_self, int __pyx_v_priority); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5timer_2feed(struct PyGeventTimerObject *__pyx_v_self, int __pyx_v_revents, PyObject *__pyx_v_callback, PyObject *__pyx_v_args); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5timer_4start(struct PyGeventTimerObject *__pyx_v_self, PyObject *__pyx_v_callback, PyObject *__pyx_v_update, PyObject *__pyx_v_args); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5timer_6active___get__(struct PyGeventTimerObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5timer_7pending___get__(struct PyGeventTimerObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_5timer_6__init__(struct PyGeventTimerObject *__pyx_v_self, struct PyGeventLoopObject *__pyx_v_loop, double __pyx_v_after, double __pyx_v_repeat, PyObject *__pyx_v_ref, PyObject *__pyx_v_priority); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5timer_2at___get__(struct PyGeventTimerObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5timer_8again(struct PyGeventTimerObject *__pyx_v_self, PyObject *__pyx_v_callback, PyObject *__pyx_v_update, PyObject *__pyx_v_args); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5timer_4loop___get__(struct PyGeventTimerObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_5timer_4loop_2__set__(struct PyGeventTimerObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_5timer_4loop_4__del__(struct PyGeventTimerObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5timer_4args___get__(struct PyGeventTimerObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_5timer_4args_2__set__(struct PyGeventTimerObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_5timer_4args_4__del__(struct PyGeventTimerObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5timer_6_flags___get__(struct PyGeventTimerObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_6signal_3ref___get__(struct PyGeventSignalObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_6signal_3ref_2__set__(struct PyGeventSignalObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_6signal_8callback___get__(struct PyGeventSignalObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_6signal_8callback_2__set__(struct PyGeventSignalObject *__pyx_v_self, PyObject *__pyx_v_callback); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_6signal_stop(struct PyGeventSignalObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_6signal_8priority___get__(struct PyGeventSignalObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_6signal_8priority_2__set__(struct PyGeventSignalObject *__pyx_v_self, int __pyx_v_priority); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_6signal_2feed(struct PyGeventSignalObject *__pyx_v_self, int __pyx_v_revents, PyObject *__pyx_v_callback, PyObject *__pyx_v_args); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_6signal_4start(struct PyGeventSignalObject *__pyx_v_self, PyObject *__pyx_v_callback, PyObject *__pyx_v_args); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_6signal_6active___get__(struct PyGeventSignalObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_6signal_7pending___get__(struct PyGeventSignalObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_6signal_6__init__(struct PyGeventSignalObject *__pyx_v_self, struct PyGeventLoopObject *__pyx_v_loop, int __pyx_v_signalnum, PyObject *__pyx_v_ref, PyObject *__pyx_v_priority); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_6signal_4loop___get__(struct PyGeventSignalObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_6signal_4loop_2__set__(struct PyGeventSignalObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_6signal_4loop_4__del__(struct PyGeventSignalObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_6signal_4args___get__(struct PyGeventSignalObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_6signal_4args_2__set__(struct PyGeventSignalObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_6signal_4args_4__del__(struct PyGeventSignalObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_6signal_6_flags___get__(struct PyGeventSignalObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4idle_3ref___get__(struct PyGeventIdleObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_4idle_3ref_2__set__(struct PyGeventIdleObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4idle_8callback___get__(struct PyGeventIdleObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_4idle_8callback_2__set__(struct PyGeventIdleObject *__pyx_v_self, PyObject *__pyx_v_callback); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4idle_stop(struct PyGeventIdleObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4idle_8priority___get__(struct PyGeventIdleObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_4idle_8priority_2__set__(struct PyGeventIdleObject *__pyx_v_self, int __pyx_v_priority); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4idle_2feed(struct PyGeventIdleObject *__pyx_v_self, int __pyx_v_revents, PyObject *__pyx_v_callback, PyObject *__pyx_v_args); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4idle_4start(struct PyGeventIdleObject *__pyx_v_self, PyObject *__pyx_v_callback, PyObject *__pyx_v_args); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4idle_6active___get__(struct PyGeventIdleObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4idle_7pending___get__(struct PyGeventIdleObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_4idle_6__init__(struct PyGeventIdleObject *__pyx_v_self, struct PyGeventLoopObject *__pyx_v_loop, PyObject *__pyx_v_ref, PyObject *__pyx_v_priority); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4idle_4loop___get__(struct PyGeventIdleObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_4idle_4loop_2__set__(struct PyGeventIdleObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_4idle_4loop_4__del__(struct PyGeventIdleObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4idle_4args___get__(struct PyGeventIdleObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_4idle_4args_2__set__(struct PyGeventIdleObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_4idle_4args_4__del__(struct PyGeventIdleObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4idle_6_flags___get__(struct PyGeventIdleObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_7prepare_3ref___get__(struct PyGeventPrepareObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_7prepare_3ref_2__set__(struct PyGeventPrepareObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_7prepare_8callback___get__(struct PyGeventPrepareObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_7prepare_8callback_2__set__(struct PyGeventPrepareObject *__pyx_v_self, PyObject *__pyx_v_callback); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_7prepare_stop(struct PyGeventPrepareObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_7prepare_8priority___get__(struct PyGeventPrepareObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_7prepare_8priority_2__set__(struct PyGeventPrepareObject *__pyx_v_self, int __pyx_v_priority); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_7prepare_2feed(struct PyGeventPrepareObject *__pyx_v_self, int __pyx_v_revents, PyObject *__pyx_v_callback, PyObject *__pyx_v_args); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_7prepare_4start(struct PyGeventPrepareObject *__pyx_v_self, PyObject *__pyx_v_callback, PyObject *__pyx_v_args); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_7prepare_6active___get__(struct PyGeventPrepareObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_7prepare_7pending___get__(struct PyGeventPrepareObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_7prepare_6__init__(struct PyGeventPrepareObject *__pyx_v_self, struct PyGeventLoopObject *__pyx_v_loop, PyObject *__pyx_v_ref, PyObject *__pyx_v_priority); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_7prepare_4loop___get__(struct PyGeventPrepareObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_7prepare_4loop_2__set__(struct PyGeventPrepareObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_7prepare_4loop_4__del__(struct PyGeventPrepareObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_7prepare_4args___get__(struct PyGeventPrepareObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_7prepare_4args_2__set__(struct PyGeventPrepareObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_7prepare_4args_4__del__(struct PyGeventPrepareObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_7prepare_6_flags___get__(struct PyGeventPrepareObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5check_3ref___get__(struct PyGeventCheckObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_5check_3ref_2__set__(struct PyGeventCheckObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5check_8callback___get__(struct PyGeventCheckObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_5check_8callback_2__set__(struct PyGeventCheckObject *__pyx_v_self, PyObject *__pyx_v_callback); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5check_stop(struct PyGeventCheckObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5check_8priority___get__(struct PyGeventCheckObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_5check_8priority_2__set__(struct PyGeventCheckObject *__pyx_v_self, int __pyx_v_priority); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5check_2feed(struct PyGeventCheckObject *__pyx_v_self, int __pyx_v_revents, PyObject *__pyx_v_callback, PyObject *__pyx_v_args); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5check_4start(struct PyGeventCheckObject *__pyx_v_self, PyObject *__pyx_v_callback, PyObject *__pyx_v_args); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5check_6active___get__(struct PyGeventCheckObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5check_7pending___get__(struct PyGeventCheckObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_5check_6__init__(struct PyGeventCheckObject *__pyx_v_self, struct PyGeventLoopObject *__pyx_v_loop, PyObject *__pyx_v_ref, PyObject *__pyx_v_priority); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5check_4loop___get__(struct PyGeventCheckObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_5check_4loop_2__set__(struct PyGeventCheckObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_5check_4loop_4__del__(struct PyGeventCheckObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5check_4args___get__(struct PyGeventCheckObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_5check_4args_2__set__(struct PyGeventCheckObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_5check_4args_4__del__(struct PyGeventCheckObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5check_6_flags___get__(struct PyGeventCheckObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4fork_3ref___get__(struct PyGeventForkObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_4fork_3ref_2__set__(struct PyGeventForkObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4fork_8callback___get__(struct PyGeventForkObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_4fork_8callback_2__set__(struct PyGeventForkObject *__pyx_v_self, PyObject *__pyx_v_callback); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4fork_stop(struct PyGeventForkObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4fork_8priority___get__(struct PyGeventForkObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_4fork_8priority_2__set__(struct PyGeventForkObject *__pyx_v_self, int __pyx_v_priority); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4fork_2feed(struct PyGeventForkObject *__pyx_v_self, int __pyx_v_revents, PyObject *__pyx_v_callback, PyObject *__pyx_v_args); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4fork_4start(struct PyGeventForkObject *__pyx_v_self, PyObject *__pyx_v_callback, PyObject *__pyx_v_args); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4fork_6active___get__(struct PyGeventForkObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4fork_7pending___get__(struct PyGeventForkObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_4fork_6__init__(struct PyGeventForkObject *__pyx_v_self, struct PyGeventLoopObject *__pyx_v_loop, PyObject *__pyx_v_ref, PyObject *__pyx_v_priority); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4fork_4loop___get__(struct PyGeventForkObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_4fork_4loop_2__set__(struct PyGeventForkObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_4fork_4loop_4__del__(struct PyGeventForkObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4fork_4args___get__(struct PyGeventForkObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_4fork_4args_2__set__(struct PyGeventForkObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_4fork_4args_4__del__(struct PyGeventForkObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4fork_6_flags___get__(struct PyGeventForkObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5async_3ref___get__(struct PyGeventAsyncObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_5async_3ref_2__set__(struct PyGeventAsyncObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5async_8callback___get__(struct PyGeventAsyncObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_5async_8callback_2__set__(struct PyGeventAsyncObject *__pyx_v_self, PyObject *__pyx_v_callback); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5async_stop(struct PyGeventAsyncObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5async_8priority___get__(struct PyGeventAsyncObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_5async_8priority_2__set__(struct PyGeventAsyncObject *__pyx_v_self, int __pyx_v_priority); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5async_2feed(struct PyGeventAsyncObject *__pyx_v_self, int __pyx_v_revents, PyObject *__pyx_v_callback, PyObject *__pyx_v_args); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5async_4start(struct PyGeventAsyncObject *__pyx_v_self, PyObject *__pyx_v_callback, PyObject *__pyx_v_args); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5async_6active___get__(struct PyGeventAsyncObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5async_7pending___get__(struct PyGeventAsyncObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_5async_6__init__(struct PyGeventAsyncObject *__pyx_v_self, struct PyGeventLoopObject *__pyx_v_loop, PyObject *__pyx_v_ref, PyObject *__pyx_v_priority); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5async_8send(struct PyGeventAsyncObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5async_4loop___get__(struct PyGeventAsyncObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_5async_4loop_2__set__(struct PyGeventAsyncObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_5async_4loop_4__del__(struct PyGeventAsyncObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5async_4args___get__(struct PyGeventAsyncObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_5async_4args_2__set__(struct PyGeventAsyncObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_5async_4args_4__del__(struct PyGeventAsyncObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5async_6_flags___get__(struct PyGeventAsyncObject *__pyx_v_self); /* proto */ +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5child_3ref___get__(struct PyGeventChildObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_5child_3ref_2__set__(struct PyGeventChildObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5child_8callback___get__(struct PyGeventChildObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_5child_8callback_2__set__(struct PyGeventChildObject *__pyx_v_self, PyObject *__pyx_v_callback); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5child_stop(struct PyGeventChildObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5child_8priority___get__(struct PyGeventChildObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_5child_8priority_2__set__(struct PyGeventChildObject *__pyx_v_self, int __pyx_v_priority); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5child_2feed(struct PyGeventChildObject *__pyx_v_self, int __pyx_v_revents, PyObject *__pyx_v_callback, PyObject *__pyx_v_args); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5child_4start(struct PyGeventChildObject *__pyx_v_self, PyObject *__pyx_v_callback, PyObject *__pyx_v_args); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5child_6active___get__(struct PyGeventChildObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5child_7pending___get__(struct PyGeventChildObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_5child_6__init__(struct PyGeventChildObject *__pyx_v_self, struct PyGeventLoopObject *__pyx_v_loop, int __pyx_v_pid, int __pyx_v_trace, PyObject *__pyx_v_ref); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5child_8_format(struct PyGeventChildObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5child_3pid___get__(struct PyGeventChildObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5child_4rpid___get__(struct PyGeventChildObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_5child_4rpid_2__set__(struct PyGeventChildObject *__pyx_v_self, int __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5child_7rstatus___get__(struct PyGeventChildObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_5child_7rstatus_2__set__(struct PyGeventChildObject *__pyx_v_self, int __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5child_4loop___get__(struct PyGeventChildObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_5child_4loop_2__set__(struct PyGeventChildObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_5child_4loop_4__del__(struct PyGeventChildObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5child_4args___get__(struct PyGeventChildObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_5child_4args_2__set__(struct PyGeventChildObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_5child_4args_4__del__(struct PyGeventChildObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5child_6_flags___get__(struct PyGeventChildObject *__pyx_v_self); /* proto */ +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4stat_3ref___get__(struct PyGeventStatObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_4stat_3ref_2__set__(struct PyGeventStatObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4stat_8callback___get__(struct PyGeventStatObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_4stat_8callback_2__set__(struct PyGeventStatObject *__pyx_v_self, PyObject *__pyx_v_callback); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4stat_stop(struct PyGeventStatObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4stat_8priority___get__(struct PyGeventStatObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_4stat_8priority_2__set__(struct PyGeventStatObject *__pyx_v_self, int __pyx_v_priority); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4stat_2feed(struct PyGeventStatObject *__pyx_v_self, int __pyx_v_revents, PyObject *__pyx_v_callback, PyObject *__pyx_v_args); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4stat_4start(struct PyGeventStatObject *__pyx_v_self, PyObject *__pyx_v_callback, PyObject *__pyx_v_args); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4stat_6active___get__(struct PyGeventStatObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4stat_7pending___get__(struct PyGeventStatObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_4stat_6__init__(struct PyGeventStatObject *__pyx_v_self, struct PyGeventLoopObject *__pyx_v_loop, PyObject *__pyx_v_path, float __pyx_v_interval, PyObject *__pyx_v_ref, PyObject *__pyx_v_priority); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4stat_4attr___get__(struct PyGeventStatObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4stat_4prev___get__(struct PyGeventStatObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4stat_8interval___get__(struct PyGeventStatObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4stat_4loop___get__(struct PyGeventStatObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_4stat_4loop_2__set__(struct PyGeventStatObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_4stat_4loop_4__del__(struct PyGeventStatObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4stat_4args___get__(struct PyGeventStatObject *__pyx_v_self); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_4stat_4args_2__set__(struct PyGeventStatObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_6gevent_5libev_8corecext_4stat_4args_4__del__(struct PyGeventStatObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4stat_6_flags___get__(struct PyGeventStatObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4stat_4path___get__(struct PyGeventStatObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4stat_6_paths___get__(struct PyGeventStatObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6gevent_5libev_8corecext_20set_syserr_cb(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_callback); /* proto */ +static PyObject *__pyx_tp_new_6gevent_5libev_8corecext__EVENTSType(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_6gevent_5libev_8corecext_loop(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_6gevent_5libev_8corecext_callback(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_6gevent_5libev_8corecext_watcher(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_6gevent_5libev_8corecext_io(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_6gevent_5libev_8corecext_timer(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_6gevent_5libev_8corecext_signal(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_6gevent_5libev_8corecext_idle(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_6gevent_5libev_8corecext_prepare(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_6gevent_5libev_8corecext_check(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_6gevent_5libev_8corecext_fork(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_6gevent_5libev_8corecext_async(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_tp_new_6gevent_5libev_8corecext_child(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_tp_new_6gevent_5libev_8corecext_stat(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_6gevent_5libev_8corecext___pyx_scope_struct__genexpr(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_int_0; +static PyObject *__pyx_int_3; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_int_neg_1; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static int __pyx_k__9; +static PyObject *__pyx_tuple__2; +static PyObject *__pyx_tuple__6; +static PyObject *__pyx_tuple__7; +static PyObject *__pyx_tuple__8; +static PyObject *__pyx_tuple__10; +static PyObject *__pyx_tuple__11; +static PyObject *__pyx_tuple__12; +static PyObject *__pyx_tuple__13; +static PyObject *__pyx_tuple__14; +static PyObject *__pyx_tuple__15; +static PyObject *__pyx_tuple__16; +static PyObject *__pyx_tuple__17; +static PyObject *__pyx_tuple__18; +static PyObject *__pyx_tuple__19; +static PyObject *__pyx_tuple__20; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_tuple__22; +static PyObject *__pyx_tuple__23; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_tuple__24; +static PyObject *__pyx_tuple__25; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) +static PyObject *__pyx_tuple__26; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) +static PyObject *__pyx_tuple__27; +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_tuple__28; +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_tuple__29; +static PyObject *__pyx_tuple__30; +static PyObject *__pyx_tuple__31; +static PyObject *__pyx_tuple__32; +static PyObject *__pyx_tuple__33; +static PyObject *__pyx_tuple__34; +static PyObject *__pyx_tuple__35; +static PyObject *__pyx_tuple__36; +static PyObject *__pyx_tuple__37; +static PyObject *__pyx_tuple__38; +static PyObject *__pyx_tuple__39; +static PyObject *__pyx_tuple__40; +static PyObject *__pyx_tuple__41; +static PyObject *__pyx_tuple__42; +static PyObject *__pyx_tuple__43; +static PyObject *__pyx_tuple__44; +static PyObject *__pyx_tuple__45; +static PyObject *__pyx_tuple__46; +static PyObject *__pyx_tuple__47; +static PyObject *__pyx_tuple__48; +static PyObject *__pyx_tuple__49; +static PyObject *__pyx_tuple__50; +static PyObject *__pyx_tuple__51; +static PyObject *__pyx_tuple__52; +static PyObject *__pyx_tuple__53; +static PyObject *__pyx_tuple__54; +static PyObject *__pyx_tuple__55; +static PyObject *__pyx_tuple__56; +static PyObject *__pyx_tuple__57; +static PyObject *__pyx_tuple__58; +static PyObject *__pyx_tuple__59; +static PyObject *__pyx_tuple__60; +static PyObject *__pyx_tuple__61; +static PyObject *__pyx_tuple__62; +static PyObject *__pyx_tuple__63; +static PyObject *__pyx_tuple__64; +static PyObject *__pyx_tuple__65; +static PyObject *__pyx_tuple__66; +static PyObject *__pyx_tuple__67; +static PyObject *__pyx_tuple__68; +static PyObject *__pyx_tuple__69; +static PyObject *__pyx_tuple__70; +static PyObject *__pyx_tuple__71; +static PyObject *__pyx_tuple__72; +static PyObject *__pyx_tuple__73; +static PyObject *__pyx_tuple__74; +static PyObject *__pyx_tuple__75; +static PyObject *__pyx_tuple__76; +static PyObject *__pyx_tuple__77; +static PyObject *__pyx_tuple__78; +static PyObject *__pyx_tuple__79; +static PyObject *__pyx_tuple__80; +static PyObject *__pyx_tuple__81; +static PyObject *__pyx_tuple__82; +static PyObject *__pyx_tuple__83; +static PyObject *__pyx_tuple__84; +static PyObject *__pyx_tuple__85; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_tuple__86; +static PyObject *__pyx_tuple__87; +static PyObject *__pyx_tuple__88; +static PyObject *__pyx_tuple__89; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) +static PyObject *__pyx_tuple__90; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_tuple__91; +static PyObject *__pyx_tuple__92; +static PyObject *__pyx_tuple__93; +static PyObject *__pyx_tuple__94; +static PyObject *__pyx_tuple__95; +static PyObject *__pyx_tuple__96; +static PyObject *__pyx_tuple__97; +static PyObject *__pyx_codeobj__98; +static PyObject *__pyx_codeobj__99; +static PyObject *__pyx_codeobj__100; +static PyObject *__pyx_codeobj__101; +static PyObject *__pyx_codeobj__102; +static PyObject *__pyx_codeobj__103; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) +static PyObject *__pyx_codeobj__90; +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) +static PyObject *__pyx_codeobj__91; +static PyObject *__pyx_codeobj__92; +static PyObject *__pyx_codeobj__93; +static PyObject *__pyx_codeobj__94; +static PyObject *__pyx_codeobj__95; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_tuple__90; +static PyObject *__pyx_tuple__91; +static PyObject *__pyx_tuple__92; +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_codeobj__93; +static PyObject *__pyx_codeobj__94; +static PyObject *__pyx_codeobj__95; +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_codeobj__96; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_tuple__93; +static PyObject *__pyx_tuple__94; +static PyObject *__pyx_tuple__95; +static PyObject *__pyx_tuple__96; +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_codeobj__97; +static PyObject *__pyx_codeobj__98; +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) +static PyObject *__pyx_codeobj__86; +static PyObject *__pyx_codeobj__87; +static PyObject *__pyx_codeobj__88; +static PyObject *__pyx_codeobj__89; +static PyObject *__pyx_codeobj__90; +static PyObject *__pyx_codeobj__91; +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_codeobj__99; +static PyObject *__pyx_codeobj__100; +static PyObject *__pyx_codeobj__101; +static PyObject *__pyx_codeobj__102; +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_gb_6gevent_5libev_8corecext_24generator(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value); /* proto */ + + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_22genexpr(CYTHON_UNUSED PyObject *__pyx_self) { + struct __pyx_obj_6gevent_5libev_8corecext___pyx_scope_struct__genexpr *__pyx_cur_scope; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("genexpr", 0); + __pyx_cur_scope = (struct __pyx_obj_6gevent_5libev_8corecext___pyx_scope_struct__genexpr *)__pyx_tp_new_6gevent_5libev_8corecext___pyx_scope_struct__genexpr(__pyx_ptype_6gevent_5libev_8corecext___pyx_scope_struct__genexpr, __pyx_empty_tuple, NULL); + if (unlikely(!__pyx_cur_scope)) { + __pyx_cur_scope = ((struct __pyx_obj_6gevent_5libev_8corecext___pyx_scope_struct__genexpr *)Py_None); + __Pyx_INCREF(Py_None); + __PYX_ERR(0, 128, __pyx_L1_error) + } else { + __Pyx_GOTREF(__pyx_cur_scope); + } + { + __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_6gevent_5libev_8corecext_24generator, (PyObject *) __pyx_cur_scope, __pyx_n_s_genexpr, __pyx_n_s_genexpr, __pyx_n_s_gevent_libev_corecext); if (unlikely(!gen)) __PYX_ERR(0, 128, __pyx_L1_error) + __Pyx_DECREF(__pyx_cur_scope); + __Pyx_RefNannyFinishContext(); + return (PyObject *) gen; + } + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("gevent.libev.corecext.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_gb_6gevent_5libev_8corecext_24generator(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value) /* generator body */ +{ + struct __pyx_obj_6gevent_5libev_8corecext___pyx_scope_struct__genexpr *__pyx_cur_scope = ((struct __pyx_obj_6gevent_5libev_8corecext___pyx_scope_struct__genexpr *)__pyx_generator->closure); + PyObject *__pyx_r = NULL; + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + Py_ssize_t __pyx_t_3; + PyObject *(*__pyx_t_4)(PyObject *); + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *(*__pyx_t_8)(PyObject *); + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("None", 0); + switch (__pyx_generator->resume_label) { + case 0: goto __pyx_L3_first_run; + default: /* CPython raises the right error here */ + __Pyx_RefNannyFinishContext(); + return NULL; + } + __pyx_L3_first_run:; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 128, __pyx_L1_error) + __pyx_r = PyDict_New(); if (unlikely(!__pyx_r)) __PYX_ERR(0, 128, __pyx_L1_error) + __Pyx_GOTREF(__pyx_r); + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 128, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) { + __pyx_t_2 = __pyx_t_1; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; + __pyx_t_4 = NULL; + } else { + __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 128, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 128, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + for (;;) { + if (likely(!__pyx_t_4)) { + if (likely(PyList_CheckExact(__pyx_t_2))) { + if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_2)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_1); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 128, __pyx_L1_error) + #else + __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 128, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + #endif + } else { + if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_2)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_1); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 128, __pyx_L1_error) + #else + __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 128, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + #endif + } + } else { + __pyx_t_1 = __pyx_t_4(__pyx_t_2); + if (unlikely(!__pyx_t_1)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 128, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_1); + } + if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) { + PyObject* sequence = __pyx_t_1; + #if !CYTHON_COMPILING_IN_PYPY + Py_ssize_t size = Py_SIZE(sequence); + #else + Py_ssize_t size = PySequence_Size(sequence); + #endif + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 128, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_5 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_6 = PyTuple_GET_ITEM(sequence, 1); + } else { + __pyx_t_5 = PyList_GET_ITEM(sequence, 0); + __pyx_t_6 = PyList_GET_ITEM(sequence, 1); + } + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx_t_6); + #else + __pyx_t_5 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 128, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 128, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + #endif + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_7 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 128, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_8 = Py_TYPE(__pyx_t_7)->tp_iternext; + index = 0; __pyx_t_5 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_5)) goto __pyx_L6_unpacking_failed; + __Pyx_GOTREF(__pyx_t_5); + index = 1; __pyx_t_6 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_6)) goto __pyx_L6_unpacking_failed; + __Pyx_GOTREF(__pyx_t_6); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_7), 2) < 0) __PYX_ERR(0, 128, __pyx_L1_error) + __pyx_t_8 = NULL; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + goto __pyx_L7_unpacking_done; + __pyx_L6_unpacking_failed:; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_8 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 128, __pyx_L1_error) + __pyx_L7_unpacking_done:; + } + __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_flag); + __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_flag, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_5); + __pyx_t_5 = 0; + __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_string); + __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_string, __pyx_t_6); + __Pyx_GIVEREF(__pyx_t_6); + __pyx_t_6 = 0; + if (unlikely(PyDict_SetItem(__pyx_r, (PyObject*)__pyx_cur_scope->__pyx_v_string, (PyObject*)__pyx_cur_scope->__pyx_v_flag))) __PYX_ERR(0, 128, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_r); __pyx_r = 0; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __pyx_generator->resume_label = -1; + __Pyx_Coroutine_clear((PyObject*)__pyx_generator); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +PyObject *GEVENT_CORE_EVENTS = 0; + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_11_EVENTSType_1__repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_11_EVENTSType_1__repr__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_11_EVENTSType___repr__(((struct __pyx_obj_6gevent_5libev_8corecext__EVENTSType *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_11_EVENTSType___repr__(CYTHON_UNUSED struct __pyx_obj_6gevent_5libev_8corecext__EVENTSType *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__", 0); + + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_kp_s_gevent_core_EVENTS); + __pyx_r = __pyx_kp_s_gevent_core_EVENTS; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_1get_version(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyMethodDef __pyx_mdef_6gevent_5libev_8corecext_1get_version = {"get_version", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_1get_version, METH_NOARGS, 0}; +static PyObject *__pyx_pw_6gevent_5libev_8corecext_1get_version(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("get_version (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_get_version(__pyx_self); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_get_version(CYTHON_UNUSED PyObject *__pyx_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("get_version", 0); + + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(ev_version_major()); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 108, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyInt_From_int(ev_version_minor()); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 108, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 108, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_libev_d_02d, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 108, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("gevent.libev.corecext.get_version", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_3get_header_version(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyMethodDef __pyx_mdef_6gevent_5libev_8corecext_3get_header_version = {"get_header_version", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_3get_header_version, METH_NOARGS, 0}; +static PyObject *__pyx_pw_6gevent_5libev_8corecext_3get_header_version(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("get_header_version (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_2get_header_version(__pyx_self); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_2get_header_version(CYTHON_UNUSED PyObject *__pyx_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("get_header_version", 0); + + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(EV_VERSION_MAJOR); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 112, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyInt_From_int(EV_VERSION_MINOR); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 112, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 112, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_libev_d_02d, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 112, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("gevent.libev.corecext.get_header_version", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5_flags_to_list(PyObject *__pyx_self, PyObject *__pyx_arg_flags); /*proto*/ +static PyObject *__pyx_f_6gevent_5libev_8corecext__flags_to_list(unsigned int __pyx_v_flags, CYTHON_UNUSED int __pyx_skip_dispatch) { + PyObject *__pyx_v_result = 0; + PyObject *__pyx_v_code = NULL; + PyObject *__pyx_v_value = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + Py_ssize_t __pyx_t_3; + PyObject *(*__pyx_t_4)(PyObject *); + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *(*__pyx_t_8)(PyObject *); + int __pyx_t_9; + int __pyx_t_10; + unsigned int __pyx_t_11; + __Pyx_RefNannySetupContext("_flags_to_list", 0); + + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 150, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_result = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) { + __pyx_t_2 = __pyx_t_1; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; + __pyx_t_4 = NULL; + } else { + __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 151, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + for (;;) { + if (likely(!__pyx_t_4)) { + if (likely(PyList_CheckExact(__pyx_t_2))) { + if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_2)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_1); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 151, __pyx_L1_error) + #else + __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + #endif + } else { + if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_2)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_1); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 151, __pyx_L1_error) + #else + __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + #endif + } + } else { + __pyx_t_1 = __pyx_t_4(__pyx_t_2); + if (unlikely(!__pyx_t_1)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 151, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_1); + } + if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) { + PyObject* sequence = __pyx_t_1; + #if !CYTHON_COMPILING_IN_PYPY + Py_ssize_t size = Py_SIZE(sequence); + #else + Py_ssize_t size = PySequence_Size(sequence); + #endif + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 151, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_5 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_6 = PyTuple_GET_ITEM(sequence, 1); + } else { + __pyx_t_5 = PyList_GET_ITEM(sequence, 0); + __pyx_t_6 = PyList_GET_ITEM(sequence, 1); + } + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx_t_6); + #else + __pyx_t_5 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + #endif + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_7 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_8 = Py_TYPE(__pyx_t_7)->tp_iternext; + index = 0; __pyx_t_5 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_5)) goto __pyx_L5_unpacking_failed; + __Pyx_GOTREF(__pyx_t_5); + index = 1; __pyx_t_6 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_6)) goto __pyx_L5_unpacking_failed; + __Pyx_GOTREF(__pyx_t_6); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_7), 2) < 0) __PYX_ERR(0, 151, __pyx_L1_error) + __pyx_t_8 = NULL; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + goto __pyx_L6_unpacking_done; + __pyx_L5_unpacking_failed:; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_8 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 151, __pyx_L1_error) + __pyx_L6_unpacking_done:; + } + __Pyx_XDECREF_SET(__pyx_v_code, __pyx_t_5); + __pyx_t_5 = 0; + __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_6); + __pyx_t_6 = 0; + + __pyx_t_1 = __Pyx_PyInt_From_unsigned_int(__pyx_v_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 152, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = PyNumber_And(__pyx_t_1, __pyx_v_code); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 152, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 152, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (__pyx_t_9) { + + __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_result, __pyx_v_value); if (unlikely(__pyx_t_10 == -1)) __PYX_ERR(0, 153, __pyx_L1_error) + + } + + __pyx_t_6 = __Pyx_PyInt_From_unsigned_int(__pyx_v_flags); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_1 = PyNumber_Invert(__pyx_v_code); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = PyNumber_InPlaceAnd(__pyx_t_6, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_11 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_11 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 154, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_flags = __pyx_t_11; + + __pyx_t_9 = ((!(__pyx_v_flags != 0)) != 0); + if (__pyx_t_9) { + + goto __pyx_L4_break; + + } + + } + __pyx_L4_break:; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + __pyx_t_9 = (__pyx_v_flags != 0); + if (__pyx_t_9) { + + __pyx_t_2 = __Pyx_PyInt_From_unsigned_int(__pyx_v_flags); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 158, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_result, __pyx_t_2); if (unlikely(__pyx_t_10 == -1)) __PYX_ERR(0, 158, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + } + + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_result); + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("gevent.libev.corecext._flags_to_list", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XDECREF(__pyx_v_code); + __Pyx_XDECREF(__pyx_v_value); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5_flags_to_list(PyObject *__pyx_self, PyObject *__pyx_arg_flags); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5_flags_to_list(PyObject *__pyx_self, PyObject *__pyx_arg_flags) { + unsigned int __pyx_v_flags; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_flags_to_list (wrapper)", 0); + assert(__pyx_arg_flags); { + __pyx_v_flags = __Pyx_PyInt_As_unsigned_int(__pyx_arg_flags); if (unlikely((__pyx_v_flags == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 149, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.libev.corecext._flags_to_list", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4_flags_to_list(__pyx_self, ((unsigned int)__pyx_v_flags)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4_flags_to_list(CYTHON_UNUSED PyObject *__pyx_self, unsigned int __pyx_v_flags) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("_flags_to_list", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_6gevent_5libev_8corecext__flags_to_list(__pyx_v_flags, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext._flags_to_list", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +static PyObject *__pyx_pw_6gevent_5libev_8corecext_7_flags_to_int(PyObject *__pyx_self, PyObject *__pyx_v_flags); /*proto*/ +static unsigned int __pyx_f_6gevent_5libev_8corecext__flags_to_int(PyObject *__pyx_v_flags, CYTHON_UNUSED int __pyx_skip_dispatch) { + unsigned int __pyx_v_result; + PyObject *__pyx_v_value = NULL; + PyObject *__pyx_v_ex = NULL; + unsigned int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + unsigned int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + Py_ssize_t __pyx_t_9; + PyObject *(*__pyx_t_10)(PyObject *); + PyObject *__pyx_t_11 = NULL; + PyObject *__pyx_t_12 = NULL; + PyObject *__pyx_t_13 = NULL; + int __pyx_t_14; + PyObject *__pyx_t_15 = NULL; + PyObject *__pyx_t_16 = NULL; + int __pyx_t_17; + __Pyx_RefNannySetupContext("_flags_to_int", 0); + __Pyx_INCREF(__pyx_v_flags); + + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_flags); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 170, __pyx_L1_error) + __pyx_t_2 = ((!__pyx_t_1) != 0); + if (__pyx_t_2) { + + __pyx_r = 0; + goto __pyx_L0; + + } + + __pyx_t_3 = __pyx_v_6gevent_5libev_8corecext_integer_types; + __Pyx_INCREF(__pyx_t_3); + __pyx_t_2 = PyObject_IsInstance(__pyx_v_flags, __pyx_t_3); if (unlikely(__pyx_t_2 == -1)) __PYX_ERR(0, 172, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { + + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_flags); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 173, __pyx_L1_error) + __pyx_r = __pyx_t_4; + goto __pyx_L0; + + } + + __pyx_v_result = 0; + + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7); + __Pyx_XGOTREF(__pyx_t_5); + __Pyx_XGOTREF(__pyx_t_6); + __Pyx_XGOTREF(__pyx_t_7); + /*try:*/ { + + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_basestring); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 176, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyObject_IsInstance(__pyx_v_flags, __pyx_t_3); if (unlikely(__pyx_t_1 == -1)) __PYX_ERR(0, 176, __pyx_L5_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_flags, __pyx_n_s_split); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 177, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 177, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_flags, __pyx_t_8); + __pyx_t_8 = 0; + + } + + if (likely(PyList_CheckExact(__pyx_v_flags)) || PyTuple_CheckExact(__pyx_v_flags)) { + __pyx_t_8 = __pyx_v_flags; __Pyx_INCREF(__pyx_t_8); __pyx_t_9 = 0; + __pyx_t_10 = NULL; + } else { + __pyx_t_9 = -1; __pyx_t_8 = PyObject_GetIter(__pyx_v_flags); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 178, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_10 = Py_TYPE(__pyx_t_8)->tp_iternext; if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 178, __pyx_L5_error) + } + for (;;) { + if (likely(!__pyx_t_10)) { + if (likely(PyList_CheckExact(__pyx_t_8))) { + if (__pyx_t_9 >= PyList_GET_SIZE(__pyx_t_8)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyList_GET_ITEM(__pyx_t_8, __pyx_t_9); __Pyx_INCREF(__pyx_t_3); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 178, __pyx_L5_error) + #else + __pyx_t_3 = PySequence_ITEM(__pyx_t_8, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 178, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + } else { + if (__pyx_t_9 >= PyTuple_GET_SIZE(__pyx_t_8)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_8, __pyx_t_9); __Pyx_INCREF(__pyx_t_3); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 178, __pyx_L5_error) + #else + __pyx_t_3 = PySequence_ITEM(__pyx_t_8, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 178, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + } + } else { + __pyx_t_3 = __pyx_t_10(__pyx_t_8); + if (unlikely(!__pyx_t_3)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 178, __pyx_L5_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_3); + } + __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_3); + __pyx_t_3 = 0; + + __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_value, __pyx_n_s_strip); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 179, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_13 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_12))) { + __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_12); + if (likely(__pyx_t_13)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_12); + __Pyx_INCREF(__pyx_t_13); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_12, function); + } + } + if (__pyx_t_13) { + __pyx_t_11 = __Pyx_PyObject_CallOneArg(__pyx_t_12, __pyx_t_13); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 179, __pyx_L5_error) + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + } else { + __pyx_t_11 = __Pyx_PyObject_CallNoArg(__pyx_t_12); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 179, __pyx_L5_error) + } + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_11, __pyx_n_s_lower); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 179, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __pyx_t_11 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_12))) { + __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_12); + if (likely(__pyx_t_11)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_12); + __Pyx_INCREF(__pyx_t_11); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_12, function); + } + } + if (__pyx_t_11) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_12, __pyx_t_11); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 179, __pyx_L5_error) + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + } else { + __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_12); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 179, __pyx_L5_error) + } + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF_SET(__pyx_v_value, __pyx_t_3); + __pyx_t_3 = 0; + + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_value); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 180, __pyx_L5_error) + if (__pyx_t_2) { + + __pyx_t_3 = __Pyx_PyInt_From_unsigned_int(__pyx_v_result); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 181, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_12 = __Pyx_GetModuleGlobalName(__pyx_n_s_flags_str2int); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 181, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_11 = PyObject_GetItem(__pyx_t_12, __pyx_v_value); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 181, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_t_12 = PyNumber_InPlaceOr(__pyx_t_3, __pyx_t_11); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 181, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_12); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 181, __pyx_L5_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_v_result = __pyx_t_4; + + } + + } + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + + } + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + goto __pyx_L12_try_end; + __pyx_L5_error:; + __Pyx_PyThreadState_assign + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + + __pyx_t_14 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyError); + if (__pyx_t_14) { + __Pyx_AddTraceback("gevent.libev.corecext._flags_to_int", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_8, &__pyx_t_12, &__pyx_t_11) < 0) __PYX_ERR(0, 182, __pyx_L7_except_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GOTREF(__pyx_t_12); + __Pyx_GOTREF(__pyx_t_11); + __Pyx_INCREF(__pyx_t_12); + __pyx_v_ex = __pyx_t_12; + + __pyx_t_15 = __Pyx_GetModuleGlobalName(__pyx_n_s_flags_str2int); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 183, __pyx_L7_except_error) + __Pyx_GOTREF(__pyx_t_15); + __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_t_15, __pyx_n_s_keys); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 183, __pyx_L7_except_error) + __Pyx_GOTREF(__pyx_t_16); + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __pyx_t_15 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_16))) { + __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_16); + if (likely(__pyx_t_15)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_16); + __Pyx_INCREF(__pyx_t_15); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_16, function); + } + } + if (__pyx_t_15) { + __pyx_t_13 = __Pyx_PyObject_CallOneArg(__pyx_t_16, __pyx_t_15); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 183, __pyx_L7_except_error) + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + } else { + __pyx_t_13 = __Pyx_PyObject_CallNoArg(__pyx_t_16); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 183, __pyx_L7_except_error) + } + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __pyx_t_16 = PySequence_List(__pyx_t_13); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 183, __pyx_L7_except_error) + __Pyx_GOTREF(__pyx_t_16); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __pyx_t_3 = ((PyObject*)__pyx_t_16); + __pyx_t_16 = 0; + __pyx_t_17 = PyList_Sort(__pyx_t_3); if (unlikely(__pyx_t_17 == -1)) __PYX_ERR(0, 183, __pyx_L7_except_error) + __pyx_t_16 = __Pyx_PyString_Join(__pyx_kp_s__3, __pyx_t_3); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 183, __pyx_L7_except_error) + __Pyx_GOTREF(__pyx_t_16); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 183, __pyx_L7_except_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_v_ex); + __Pyx_GIVEREF(__pyx_v_ex); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_ex); + __Pyx_GIVEREF(__pyx_t_16); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_16); + __pyx_t_16 = 0; + __pyx_t_16 = __Pyx_PyString_Format(__pyx_kp_s_Invalid_backend_or_flag_s_Possib, __pyx_t_3); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 183, __pyx_L7_except_error) + __Pyx_GOTREF(__pyx_t_16); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 183, __pyx_L7_except_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_16); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_16); + __pyx_t_16 = 0; + __pyx_t_16 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 183, __pyx_L7_except_error) + __Pyx_GOTREF(__pyx_t_16); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_16, 0, 0, 0); + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __PYX_ERR(0, 183, __pyx_L7_except_error) + } + goto __pyx_L7_except_error; + __pyx_L7_except_error:; + + __Pyx_PyThreadState_assign + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_XGIVEREF(__pyx_t_6); + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_ExceptionReset(__pyx_t_5, __pyx_t_6, __pyx_t_7); + goto __pyx_L1_error; + __pyx_L12_try_end:; + } + + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_XDECREF(__pyx_t_13); + __Pyx_XDECREF(__pyx_t_15); + __Pyx_XDECREF(__pyx_t_16); + __Pyx_AddTraceback("gevent.libev.corecext._flags_to_int", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_value); + __Pyx_XDECREF(__pyx_v_ex); + __Pyx_XDECREF(__pyx_v_flags); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_7_flags_to_int(PyObject *__pyx_self, PyObject *__pyx_v_flags); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_7_flags_to_int(PyObject *__pyx_self, PyObject *__pyx_v_flags) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_flags_to_int (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_6_flags_to_int(__pyx_self, ((PyObject *)__pyx_v_flags)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_6_flags_to_int(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_flags) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + unsigned int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("_flags_to_int", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_6gevent_5libev_8corecext__flags_to_int(__pyx_v_flags, 0); if (unlikely(__pyx_t_1 == -1 && PyErr_Occurred())) __PYX_ERR(0, 168, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyInt_From_unsigned_int(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 168, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext._flags_to_int", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +static PyObject *__pyx_f_6gevent_5libev_8corecext__str_hex(PyObject *__pyx_v_flag) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + __Pyx_RefNannySetupContext("_str_hex", 0); + + __pyx_t_1 = __pyx_v_6gevent_5libev_8corecext_integer_types; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_2 = PyObject_IsInstance(__pyx_v_flag, __pyx_t_1); if (unlikely(__pyx_t_2 == -1)) __PYX_ERR(0, 188, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = (__pyx_t_2 != 0); + if (__pyx_t_3) { + + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 189, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_flag); + __Pyx_GIVEREF(__pyx_v_flag); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_flag); + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_hex, __pyx_t_1, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 189, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (!(likely(PyString_CheckExact(__pyx_t_4))||((__pyx_t_4) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "str", Py_TYPE(__pyx_t_4)->tp_name), 0))) __PYX_ERR(0, 189, __pyx_L1_error) + __pyx_r = ((PyObject*)__pyx_t_4); + __pyx_t_4 = 0; + goto __pyx_L0; + + } + + __Pyx_XDECREF(__pyx_r); + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 190, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_v_flag); + __Pyx_GIVEREF(__pyx_v_flag); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_flag); + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 190, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (!(likely(PyString_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "str", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(0, 190, __pyx_L1_error) + __pyx_r = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("gevent.libev.corecext._str_hex", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +static PyObject *__pyx_pw_6gevent_5libev_8corecext_9_check_flags(PyObject *__pyx_self, PyObject *__pyx_arg_flags); /*proto*/ +static PyObject *__pyx_f_6gevent_5libev_8corecext__check_flags(unsigned int __pyx_v_flags, CYTHON_UNUSED int __pyx_skip_dispatch) { + PyObject *__pyx_v_as_list = 0; + PyObject *__pyx_v_x = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + Py_ssize_t __pyx_t_5; + PyObject *(*__pyx_t_6)(PyObject *); + __Pyx_RefNannySetupContext("_check_flags", 0); + + __pyx_v_flags = (__pyx_v_flags & EVBACKEND_MASK); + + __pyx_t_1 = ((!(__pyx_v_flags != 0)) != 0); + if (__pyx_t_1) { + + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + } + + __pyx_t_1 = ((!((__pyx_v_flags & EVBACKEND_ALL) != 0)) != 0); + if (__pyx_t_1) { + + __pyx_t_2 = __Pyx_PyInt_From_unsigned_int(__pyx_v_flags); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 199, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_Invalid_value_for_backend_0x_x, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 199, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 199, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 199, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 199, __pyx_L1_error) + + } + + __pyx_t_1 = ((!((__pyx_v_flags & ev_supported_backends()) != 0)) != 0); + if (__pyx_t_1) { + + __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 201, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __pyx_f_6gevent_5libev_8corecext__flags_to_list(__pyx_v_flags, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 201, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (likely(PyList_CheckExact(__pyx_t_2)) || PyTuple_CheckExact(__pyx_t_2)) { + __pyx_t_4 = __pyx_t_2; __Pyx_INCREF(__pyx_t_4); __pyx_t_5 = 0; + __pyx_t_6 = NULL; + } else { + __pyx_t_5 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 201, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 201, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + for (;;) { + if (likely(!__pyx_t_6)) { + if (likely(PyList_CheckExact(__pyx_t_4))) { + if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_4)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_2 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_2); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 201, __pyx_L1_error) + #else + __pyx_t_2 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 201, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #endif + } else { + if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_4)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_2); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 201, __pyx_L1_error) + #else + __pyx_t_2 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 201, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #endif + } + } else { + __pyx_t_2 = __pyx_t_6(__pyx_t_4); + if (unlikely(!__pyx_t_2)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 201, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_XDECREF_SET(__pyx_v_x, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_2 = __pyx_f_6gevent_5libev_8corecext__str_hex(__pyx_v_x); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 201, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_3, (PyObject*)__pyx_t_2))) __PYX_ERR(0, 201, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_as_list = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + __pyx_t_3 = __Pyx_PyString_Join(__pyx_kp_s__4, __pyx_v_as_list); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 202, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Unsupported_backend_s, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 202, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 202, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 202, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(0, 202, __pyx_L1_error) + + } + + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("gevent.libev.corecext._check_flags", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_as_list); + __Pyx_XDECREF(__pyx_v_x); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_9_check_flags(PyObject *__pyx_self, PyObject *__pyx_arg_flags); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_9_check_flags(PyObject *__pyx_self, PyObject *__pyx_arg_flags) { + unsigned int __pyx_v_flags; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_check_flags (wrapper)", 0); + assert(__pyx_arg_flags); { + __pyx_v_flags = __Pyx_PyInt_As_unsigned_int(__pyx_arg_flags); if (unlikely((__pyx_v_flags == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 193, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.libev.corecext._check_flags", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_8_check_flags(__pyx_self, ((unsigned int)__pyx_v_flags)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_8_check_flags(CYTHON_UNUSED PyObject *__pyx_self, unsigned int __pyx_v_flags) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("_check_flags", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_6gevent_5libev_8corecext__check_flags(__pyx_v_flags, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 193, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext._check_flags", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +static PyObject *__pyx_pw_6gevent_5libev_8corecext_11_events_to_str(PyObject *__pyx_self, PyObject *__pyx_arg_events); /*proto*/ +static PyObject *__pyx_f_6gevent_5libev_8corecext__events_to_str(int __pyx_v_events, CYTHON_UNUSED int __pyx_skip_dispatch) { + PyObject *__pyx_v_result = 0; + int __pyx_v_c_flag; + PyObject *__pyx_v_flag = NULL; + PyObject *__pyx_v_string = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + Py_ssize_t __pyx_t_3; + PyObject *(*__pyx_t_4)(PyObject *); + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *(*__pyx_t_8)(PyObject *); + int __pyx_t_9; + int __pyx_t_10; + int __pyx_t_11; + __Pyx_RefNannySetupContext("_events_to_str", 0); + + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 206, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_result = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_events); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 208, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) { + __pyx_t_2 = __pyx_t_1; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; + __pyx_t_4 = NULL; + } else { + __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 208, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 208, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + for (;;) { + if (likely(!__pyx_t_4)) { + if (likely(PyList_CheckExact(__pyx_t_2))) { + if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_2)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_1); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 208, __pyx_L1_error) + #else + __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 208, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + #endif + } else { + if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_2)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_1); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 208, __pyx_L1_error) + #else + __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 208, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + #endif + } + } else { + __pyx_t_1 = __pyx_t_4(__pyx_t_2); + if (unlikely(!__pyx_t_1)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 208, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_1); + } + if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) { + PyObject* sequence = __pyx_t_1; + #if !CYTHON_COMPILING_IN_PYPY + Py_ssize_t size = Py_SIZE(sequence); + #else + Py_ssize_t size = PySequence_Size(sequence); + #endif + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 208, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_5 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_6 = PyTuple_GET_ITEM(sequence, 1); + } else { + __pyx_t_5 = PyList_GET_ITEM(sequence, 0); + __pyx_t_6 = PyList_GET_ITEM(sequence, 1); + } + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx_t_6); + #else + __pyx_t_5 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 208, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 208, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + #endif + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_7 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 208, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_8 = Py_TYPE(__pyx_t_7)->tp_iternext; + index = 0; __pyx_t_5 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_5)) goto __pyx_L5_unpacking_failed; + __Pyx_GOTREF(__pyx_t_5); + index = 1; __pyx_t_6 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_6)) goto __pyx_L5_unpacking_failed; + __Pyx_GOTREF(__pyx_t_6); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_7), 2) < 0) __PYX_ERR(0, 208, __pyx_L1_error) + __pyx_t_8 = NULL; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + goto __pyx_L6_unpacking_done; + __pyx_L5_unpacking_failed:; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_8 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 208, __pyx_L1_error) + __pyx_L6_unpacking_done:; + } + __Pyx_XDECREF_SET(__pyx_v_flag, __pyx_t_5); + __pyx_t_5 = 0; + __Pyx_XDECREF_SET(__pyx_v_string, __pyx_t_6); + __pyx_t_6 = 0; + + __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_v_flag); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 209, __pyx_L1_error) + __pyx_v_c_flag = __pyx_t_9; + + __pyx_t_10 = ((__pyx_v_events & __pyx_v_c_flag) != 0); + if (__pyx_t_10) { + + __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_result, __pyx_v_string); if (unlikely(__pyx_t_11 == -1)) __PYX_ERR(0, 211, __pyx_L1_error) + + __pyx_v_events = (__pyx_v_events & (~__pyx_v_c_flag)); + + } + + __pyx_t_10 = ((!(__pyx_v_events != 0)) != 0); + if (__pyx_t_10) { + + goto __pyx_L4_break; + + } + + } + __pyx_L4_break:; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + __pyx_t_10 = (__pyx_v_events != 0); + if (__pyx_t_10) { + + __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_events); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 216, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 216, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_hex, __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 216, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_result, __pyx_t_2); if (unlikely(__pyx_t_11 == -1)) __PYX_ERR(0, 216, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + } + + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyString_Join(__pyx_kp_s__4, __pyx_v_result); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 217, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("gevent.libev.corecext._events_to_str", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XDECREF(__pyx_v_flag); + __Pyx_XDECREF(__pyx_v_string); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_11_events_to_str(PyObject *__pyx_self, PyObject *__pyx_arg_events); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_11_events_to_str(PyObject *__pyx_self, PyObject *__pyx_arg_events) { + int __pyx_v_events; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_events_to_str (wrapper)", 0); + assert(__pyx_arg_events); { + __pyx_v_events = __Pyx_PyInt_As_int(__pyx_arg_events); if (unlikely((__pyx_v_events == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 205, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.libev.corecext._events_to_str", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_10_events_to_str(__pyx_self, ((int)__pyx_v_events)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_10_events_to_str(CYTHON_UNUSED PyObject *__pyx_self, int __pyx_v_events) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("_events_to_str", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_6gevent_5libev_8corecext__events_to_str(__pyx_v_events, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 205, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext._events_to_str", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_13supported_backends(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyMethodDef __pyx_mdef_6gevent_5libev_8corecext_13supported_backends = {"supported_backends", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_13supported_backends, METH_NOARGS, 0}; +static PyObject *__pyx_pw_6gevent_5libev_8corecext_13supported_backends(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("supported_backends (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_12supported_backends(__pyx_self); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_12supported_backends(CYTHON_UNUSED PyObject *__pyx_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("supported_backends", 0); + + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_6gevent_5libev_8corecext__flags_to_list(ev_supported_backends(), 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 221, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.supported_backends", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_15recommended_backends(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyMethodDef __pyx_mdef_6gevent_5libev_8corecext_15recommended_backends = {"recommended_backends", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_15recommended_backends, METH_NOARGS, 0}; +static PyObject *__pyx_pw_6gevent_5libev_8corecext_15recommended_backends(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("recommended_backends (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_14recommended_backends(__pyx_self); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_14recommended_backends(CYTHON_UNUSED PyObject *__pyx_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("recommended_backends", 0); + + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_6gevent_5libev_8corecext__flags_to_list(ev_recommended_backends(), 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 225, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.recommended_backends", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_17embeddable_backends(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyMethodDef __pyx_mdef_6gevent_5libev_8corecext_17embeddable_backends = {"embeddable_backends", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_17embeddable_backends, METH_NOARGS, 0}; +static PyObject *__pyx_pw_6gevent_5libev_8corecext_17embeddable_backends(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("embeddable_backends (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_16embeddable_backends(__pyx_self); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_16embeddable_backends(CYTHON_UNUSED PyObject *__pyx_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("embeddable_backends", 0); + + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_6gevent_5libev_8corecext__flags_to_list(ev_embeddable_backends(), 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.embeddable_backends", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_19time(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyMethodDef __pyx_mdef_6gevent_5libev_8corecext_19time = {"time", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_19time, METH_NOARGS, 0}; +static PyObject *__pyx_pw_6gevent_5libev_8corecext_19time(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("time (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_18time(__pyx_self); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_18time(CYTHON_UNUSED PyObject *__pyx_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("time", 0); + + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(ev_time()); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 233, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.time", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_4loop_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_4loop_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_flags = 0; + PyObject *__pyx_v_default = 0; + size_t __pyx_v_ptr; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_flags_2,&__pyx_n_s_default,&__pyx_n_s_ptr,0}; + PyObject* values[3] = {0,0,0}; + values[0] = ((PyObject *)Py_None); + values[1] = ((PyObject *)Py_None); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_flags_2); + if (value) { values[0] = value; kw_args--; } + } + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_default); + if (value) { values[1] = value; kw_args--; } + } + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ptr); + if (value) { values[2] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 256, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_flags = values[0]; + __pyx_v_default = values[1]; + if (values[2]) { + __pyx_v_ptr = __Pyx_PyInt_As_size_t(values[2]); if (unlikely((__pyx_v_ptr == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 256, __pyx_L3_error) + } else { + __pyx_v_ptr = ((size_t)0); + } + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 0, 0, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 256, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.libev.corecext.loop.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop___init__(((struct PyGeventLoopObject *)__pyx_v_self), __pyx_v_flags, __pyx_v_default, __pyx_v_ptr); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_4loop___init__(struct PyGeventLoopObject *__pyx_v_self, PyObject *__pyx_v_flags, PyObject *__pyx_v_default, size_t __pyx_v_ptr) { + unsigned int __pyx_v_c_flags; + CYTHON_UNUSED PyObject *__pyx_v_old_handler = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + unsigned int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + __Pyx_RefNannySetupContext("__init__", 0); + __Pyx_INCREF(__pyx_v_default); + + __Pyx_INCREF(Py_None); + __pyx_v_old_handler = Py_None; + + ev_prepare_init((&__pyx_v_self->_prepare), ((void *)gevent_run_callbacks)); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + ev_timer_init((&__pyx_v_self->_periodic_signal_checker), ((void *)gevent_periodic_signal_check), 0.3, 0.3); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + ev_timer_init((&__pyx_v_self->_timer0), ((void *)gevent_noop), 0.0, 0.0); + + __pyx_t_1 = (__pyx_v_ptr != 0); + if (__pyx_t_1) { + + __pyx_v_self->_ptr = ((struct ev_loop *)__pyx_v_ptr); + + goto __pyx_L3; + } + + /*else*/ { + __pyx_t_2 = __pyx_f_6gevent_5libev_8corecext__flags_to_int(__pyx_v_flags, 0); if (unlikely(__pyx_t_2 == -1 && PyErr_Occurred())) __PYX_ERR(0, 267, __pyx_L1_error) + __pyx_v_c_flags = __pyx_t_2; + + __pyx_t_3 = __pyx_f_6gevent_5libev_8corecext__check_flags(__pyx_v_c_flags, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 268, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + __pyx_v_c_flags = (__pyx_v_c_flags | EVFLAG_NOENV); + + __pyx_v_c_flags = (__pyx_v_c_flags | EVFLAG_FORKCHECK); + + __pyx_t_1 = (__pyx_v_default == Py_None); + __pyx_t_4 = (__pyx_t_1 != 0); + if (__pyx_t_4) { + + __Pyx_INCREF(Py_True); + __Pyx_DECREF_SET(__pyx_v_default, Py_True); + + __pyx_t_4 = (__pyx_v_6gevent_5libev_8corecext__default_loop_destroyed != 0); + if (__pyx_t_4) { + + __Pyx_INCREF(Py_False); + __Pyx_DECREF_SET(__pyx_v_default, Py_False); + + } + + } + + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_default); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 275, __pyx_L1_error) + if (__pyx_t_4) { + + __pyx_v_self->_ptr = gevent_ev_default_loop(__pyx_v_c_flags); + + __pyx_t_4 = ((!(__pyx_v_self->_ptr != 0)) != 0); + if (__pyx_t_4) { + + __pyx_t_3 = __Pyx_PyInt_From_unsigned_int(__pyx_v_c_flags); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 278, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 278, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_ev_default_loop_s_failed, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 278, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 278, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_SystemError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 278, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 278, __pyx_L1_error) + + } +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + + ev_timer_start(__pyx_v_self->_ptr, (&__pyx_v_self->_periodic_signal_checker)); + + ev_unref(__pyx_v_self->_ptr); +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + + goto __pyx_L6; + } + + /*else*/ { + __pyx_v_self->_ptr = ev_loop_new(__pyx_v_c_flags); + + __pyx_t_4 = ((!(__pyx_v_self->_ptr != 0)) != 0); + if (__pyx_t_4) { + + __pyx_t_3 = __Pyx_PyInt_From_unsigned_int(__pyx_v_c_flags); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 286, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 286, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_ev_loop_new_s_failed, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 286, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 286, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_SystemError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 286, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 286, __pyx_L1_error) + + } + } + __pyx_L6:; + + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_default); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 287, __pyx_L1_error) + if (!__pyx_t_1) { + } else { + __pyx_t_4 = __pyx_t_1; + goto __pyx_L10_bool_binop_done; + } + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_SYSERR_CALLBACK); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 287, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = (__pyx_t_3 == Py_None); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = (__pyx_t_1 != 0); + __pyx_t_4 = __pyx_t_6; + __pyx_L10_bool_binop_done:; + if (__pyx_t_4) { + + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_handle_syserr); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 288, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __pyx_f_6gevent_5libev_8corecext_set_syserr_cb(__pyx_t_3, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 288, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + } + + ev_prepare_start(__pyx_v_self->_ptr, (&__pyx_v_self->_prepare)); + + ev_unref(__pyx_v_self->_ptr); + } + __pyx_L3:; + + __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 291, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_v_self->_callbacks); + __Pyx_DECREF(__pyx_v_self->_callbacks); + __pyx_v_self->_callbacks = ((PyObject*)__pyx_t_5); + __pyx_t_5 = 0; + + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("gevent.libev.corecext.loop.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_old_handler); + __Pyx_XDECREF(__pyx_v_default); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +static PyObject *__pyx_f_6gevent_5libev_8corecext_4loop__run_callbacks(struct PyGeventLoopObject *__pyx_v_self) { + struct PyGeventCallbackObject *__pyx_v_cb = 0; + PyObject *__pyx_v_callbacks = 0; + int __pyx_v_count; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + Py_ssize_t __pyx_t_4; + PyObject *(*__pyx_t_5)(PyObject *); + PyObject *__pyx_t_6 = NULL; + __Pyx_RefNannySetupContext("_run_callbacks", 0); + + __pyx_v_count = 0x3E8; + + ev_timer_stop(__pyx_v_self->_ptr, (&__pyx_v_self->_timer0)); + + while (1) { + __pyx_t_2 = (__pyx_v_self->_callbacks != Py_None) && (PyList_GET_SIZE(__pyx_v_self->_callbacks) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L5_bool_binop_done; + } + __pyx_t_2 = ((__pyx_v_count > 0) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L5_bool_binop_done:; + if (!__pyx_t_1) break; + + __pyx_t_3 = __pyx_v_self->_callbacks; + __Pyx_INCREF(__pyx_t_3); + __Pyx_XDECREF_SET(__pyx_v_callbacks, __pyx_t_3); + __pyx_t_3 = 0; + + __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 300, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_v_self->_callbacks); + __Pyx_DECREF(__pyx_v_self->_callbacks); + __pyx_v_self->_callbacks = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + if (likely(PyList_CheckExact(__pyx_v_callbacks)) || PyTuple_CheckExact(__pyx_v_callbacks)) { + __pyx_t_3 = __pyx_v_callbacks; __Pyx_INCREF(__pyx_t_3); __pyx_t_4 = 0; + __pyx_t_5 = NULL; + } else { + __pyx_t_4 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_callbacks); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 301, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 301, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_5)) { + if (likely(PyList_CheckExact(__pyx_t_3))) { + if (__pyx_t_4 >= PyList_GET_SIZE(__pyx_t_3)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_6 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 301, __pyx_L1_error) + #else + __pyx_t_6 = PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 301, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + #endif + } else { + if (__pyx_t_4 >= PyTuple_GET_SIZE(__pyx_t_3)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_6 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 301, __pyx_L1_error) + #else + __pyx_t_6 = PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 301, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + #endif + } + } else { + __pyx_t_6 = __pyx_t_5(__pyx_t_3); + if (unlikely(!__pyx_t_6)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 301, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_6); + } + if (!(likely(((__pyx_t_6) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_6, __pyx_ptype_6gevent_5libev_8corecext_callback))))) __PYX_ERR(0, 301, __pyx_L1_error) + __Pyx_XDECREF_SET(__pyx_v_cb, ((struct PyGeventCallbackObject *)__pyx_t_6)); + __pyx_t_6 = 0; + + ev_unref(__pyx_v_self->_ptr); + + gevent_call(__pyx_v_self, __pyx_v_cb); + + __pyx_v_count = (__pyx_v_count - 1); + + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + + __pyx_t_1 = (__pyx_v_self->_callbacks != Py_None) && (PyList_GET_SIZE(__pyx_v_self->_callbacks) != 0); + if (__pyx_t_1) { + + ev_timer_start(__pyx_v_self->_ptr, (&__pyx_v_self->_timer0)); + + } + + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("gevent.libev.corecext.loop._run_callbacks", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_cb); + __Pyx_XDECREF(__pyx_v_callbacks); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_3_stop_watchers(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_3_stop_watchers(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_stop_watchers (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_2_stop_watchers(((struct PyGeventLoopObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_2_stop_watchers(struct PyGeventLoopObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("_stop_watchers", 0); + + __pyx_t_1 = (ev_is_active((&__pyx_v_self->_prepare)) != 0); + if (__pyx_t_1) { + + ev_ref(__pyx_v_self->_ptr); + + ev_prepare_stop(__pyx_v_self->_ptr, (&__pyx_v_self->_prepare)); +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + + } + + __pyx_t_1 = (ev_is_active((&__pyx_v_self->_periodic_signal_checker)) != 0); + if (__pyx_t_1) { + + ev_ref(__pyx_v_self->_ptr); + + ev_timer_stop(__pyx_v_self->_ptr, (&__pyx_v_self->_periodic_signal_checker)); +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + + } + + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_5destroy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_5destroy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("destroy (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_4destroy(((struct PyGeventLoopObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_4destroy(struct PyGeventLoopObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + __Pyx_RefNannySetupContext("destroy", 0); + + __pyx_t_1 = (__pyx_v_self->_ptr != 0); + if (__pyx_t_1) { + + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_stop_watchers); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 321, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 321, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 321, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_SYSERR_CALLBACK); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 322, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_handle_syserr); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 322, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_t_2, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 322, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 322, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_1) { + + __pyx_t_4 = __pyx_f_6gevent_5libev_8corecext_set_syserr_cb(Py_None, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 323, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + } + + __pyx_t_1 = (ev_is_default_loop(__pyx_v_self->_ptr) != 0); + if (__pyx_t_1) { + + __pyx_v_6gevent_5libev_8corecext__default_loop_destroyed = 1; + + } + + ev_loop_destroy(__pyx_v_self->_ptr); + + __pyx_v_self->_ptr = NULL; + + } + + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("gevent.libev.corecext.loop.destroy", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static void __pyx_pw_6gevent_5libev_8corecext_4loop_7__dealloc__(PyObject *__pyx_v_self); /*proto*/ +static void __pyx_pw_6gevent_5libev_8corecext_4loop_7__dealloc__(PyObject *__pyx_v_self) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_pf_6gevent_5libev_8corecext_4loop_6__dealloc__(((struct PyGeventLoopObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +static void __pyx_pf_6gevent_5libev_8corecext_4loop_6__dealloc__(struct PyGeventLoopObject *__pyx_v_self) { + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + __Pyx_RefNannySetupContext("__dealloc__", 0); + + __pyx_t_1 = (__pyx_v_self->_ptr != 0); + if (__pyx_t_1) { + + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_stop_watchers); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 331, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 331, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 331, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + __pyx_t_1 = ((!(ev_is_default_loop(__pyx_v_self->_ptr) != 0)) != 0); + if (__pyx_t_1) { + + ev_loop_destroy(__pyx_v_self->_ptr); + + } + + __pyx_v_self->_ptr = NULL; + + } + + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("gevent.libev.corecext.loop.__dealloc__", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_3ptr_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_3ptr_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_3ptr___get__(((struct PyGeventLoopObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_3ptr___get__(struct PyGeventLoopObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_FromSize_t(((size_t)__pyx_v_self->_ptr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 339, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.loop.ptr.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_11WatcherType_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_11WatcherType_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_11WatcherType___get__(((struct PyGeventLoopObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_11WatcherType___get__(CYTHON_UNUSED struct PyGeventLoopObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_ptype_6gevent_5libev_8corecext_watcher)); + __pyx_r = ((PyObject *)__pyx_ptype_6gevent_5libev_8corecext_watcher); + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_6MAXPRI_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_6MAXPRI_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_6MAXPRI___get__(((struct PyGeventLoopObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_6MAXPRI___get__(CYTHON_UNUSED struct PyGeventLoopObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(EV_MAXPRI); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 349, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.loop.MAXPRI.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_6MINPRI_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_6MINPRI_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_6MINPRI___get__(((struct PyGeventLoopObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_6MINPRI___get__(CYTHON_UNUSED struct PyGeventLoopObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(EV_MINPRI); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 354, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.loop.MINPRI.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_9_handle_syserr(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_9_handle_syserr(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_message = 0; + PyObject *__pyx_v_errno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_handle_syserr (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_message,&__pyx_n_s_errno,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_message)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_errno)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("_handle_syserr", 1, 2, 2, 1); __PYX_ERR(0, 356, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_handle_syserr") < 0)) __PYX_ERR(0, 356, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + } + __pyx_v_message = values[0]; + __pyx_v_errno = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("_handle_syserr", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 356, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.libev.corecext.loop._handle_syserr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_8_handle_syserr(((struct PyGeventLoopObject *)__pyx_v_self), __pyx_v_message, __pyx_v_errno); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_8_handle_syserr(struct PyGeventLoopObject *__pyx_v_self, PyObject *__pyx_v_message, PyObject *__pyx_v_errno) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + __Pyx_RefNannySetupContext("_handle_syserr", 0); + __Pyx_INCREF(__pyx_v_message); + + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_sys); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 357, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_version_info); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 357, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_GetItemInt(__pyx_t_2, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 357, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyObject_RichCompare(__pyx_t_1, __pyx_int_3, Py_GE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 357, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 357, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_3) { + + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_message, __pyx_n_s_decode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 358, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 358, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 358, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_message, __pyx_t_2); + __pyx_t_2 = 0; + + } + + __pyx_t_2 = PyNumber_Add(__pyx_v_message, __pyx_kp_s__5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 359, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_os); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 359, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_strerror); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 359, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + if (!__pyx_t_4) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_errno); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 359, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_errno}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 359, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_errno}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 359, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 359, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_INCREF(__pyx_v_errno); + __Pyx_GIVEREF(__pyx_v_errno); + PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_v_errno); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 359, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = PyNumber_Add(__pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 359, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 359, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_SystemError, __pyx_t_1, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 359, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = ((struct __pyx_vtabstruct_6gevent_5libev_8corecext_loop *)__pyx_v_self->__pyx_vtab)->handle_error(__pyx_v_self, Py_None, __pyx_builtin_SystemError, __pyx_t_5, Py_None, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 359, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("gevent.libev.corecext.loop._handle_syserr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_message); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_11handle_error(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_f_6gevent_5libev_8corecext_4loop_handle_error(struct PyGeventLoopObject *__pyx_v_self, PyObject *__pyx_v_context, PyObject *__pyx_v_type, PyObject *__pyx_v_value, PyObject *__pyx_v_tb, int __pyx_skip_dispatch) { + PyObject *__pyx_v_handle_error = 0; + PyObject *__pyx_v_error_handler = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + int __pyx_t_8; + __Pyx_RefNannySetupContext("handle_error", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_handle_error); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 361, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_4loop_11handle_error)) { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + __pyx_t_5 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[5] = {__pyx_t_4, __pyx_v_context, __pyx_v_type, __pyx_v_value, __pyx_v_tb}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 4+__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 361, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[5] = {__pyx_t_4, __pyx_v_context, __pyx_v_type, __pyx_v_value, __pyx_v_tb}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 4+__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 361, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + { + __pyx_t_6 = PyTuple_New(4+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 361, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (__pyx_t_4) { + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL; + } + __Pyx_INCREF(__pyx_v_context); + __Pyx_GIVEREF(__pyx_v_context); + PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_5, __pyx_v_context); + __Pyx_INCREF(__pyx_v_type); + __Pyx_GIVEREF(__pyx_v_type); + PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, __pyx_v_type); + __Pyx_INCREF(__pyx_v_value); + __Pyx_GIVEREF(__pyx_v_value); + PyTuple_SET_ITEM(__pyx_t_6, 2+__pyx_t_5, __pyx_v_value); + __Pyx_INCREF(__pyx_v_tb); + __Pyx_GIVEREF(__pyx_v_tb); + PyTuple_SET_ITEM(__pyx_t_6, 3+__pyx_t_5, __pyx_v_tb); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 361, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + __pyx_t_1 = __pyx_v_self->error_handler; + __Pyx_INCREF(__pyx_t_1); + __pyx_v_error_handler = __pyx_t_1; + __pyx_t_1 = 0; + + __pyx_t_7 = (__pyx_v_error_handler != Py_None); + __pyx_t_8 = (__pyx_t_7 != 0); + if (__pyx_t_8) { + + __pyx_t_1 = __Pyx_GetAttr3(__pyx_v_error_handler, __pyx_n_s_handle_error, __pyx_v_error_handler); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 366, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_handle_error = __pyx_t_1; + __pyx_t_1 = 0; + + __Pyx_INCREF(__pyx_v_handle_error); + __pyx_t_2 = __pyx_v_handle_error; __pyx_t_3 = NULL; + __pyx_t_5 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[5] = {__pyx_t_3, __pyx_v_context, __pyx_v_type, __pyx_v_value, __pyx_v_tb}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_5, 4+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 367, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[5] = {__pyx_t_3, __pyx_v_context, __pyx_v_type, __pyx_v_value, __pyx_v_tb}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_5, 4+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 367, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_6 = PyTuple_New(4+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 367, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (__pyx_t_3) { + __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_3); __pyx_t_3 = NULL; + } + __Pyx_INCREF(__pyx_v_context); + __Pyx_GIVEREF(__pyx_v_context); + PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_5, __pyx_v_context); + __Pyx_INCREF(__pyx_v_type); + __Pyx_GIVEREF(__pyx_v_type); + PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, __pyx_v_type); + __Pyx_INCREF(__pyx_v_value); + __Pyx_GIVEREF(__pyx_v_value); + PyTuple_SET_ITEM(__pyx_t_6, 2+__pyx_t_5, __pyx_v_value); + __Pyx_INCREF(__pyx_v_tb); + __Pyx_GIVEREF(__pyx_v_tb); + PyTuple_SET_ITEM(__pyx_t_6, 3+__pyx_t_5, __pyx_v_tb); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 367, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + goto __pyx_L3; + } + + /*else*/ { + __pyx_t_1 = ((struct __pyx_vtabstruct_6gevent_5libev_8corecext_loop *)__pyx_v_self->__pyx_vtab)->_default_handle_error(__pyx_v_self, __pyx_v_context, __pyx_v_type, __pyx_v_value, __pyx_v_tb, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 369, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __pyx_L3:; + + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("gevent.libev.corecext.loop.handle_error", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_handle_error); + __Pyx_XDECREF(__pyx_v_error_handler); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_11handle_error(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_11handle_error(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_context = 0; + PyObject *__pyx_v_type = 0; + PyObject *__pyx_v_value = 0; + PyObject *__pyx_v_tb = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("handle_error (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_context,&__pyx_n_s_type,&__pyx_n_s_value,&__pyx_n_s_tb,0}; + PyObject* values[4] = {0,0,0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_context)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_type)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("handle_error", 1, 4, 4, 1); __PYX_ERR(0, 361, __pyx_L3_error) + } + case 2: + if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_value)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("handle_error", 1, 4, 4, 2); __PYX_ERR(0, 361, __pyx_L3_error) + } + case 3: + if (likely((values[3] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_tb)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("handle_error", 1, 4, 4, 3); __PYX_ERR(0, 361, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "handle_error") < 0)) __PYX_ERR(0, 361, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 4) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + } + __pyx_v_context = values[0]; + __pyx_v_type = values[1]; + __pyx_v_value = values[2]; + __pyx_v_tb = values[3]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("handle_error", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 361, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.libev.corecext.loop.handle_error", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_10handle_error(((struct PyGeventLoopObject *)__pyx_v_self), __pyx_v_context, __pyx_v_type, __pyx_v_value, __pyx_v_tb); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_10handle_error(struct PyGeventLoopObject *__pyx_v_self, PyObject *__pyx_v_context, PyObject *__pyx_v_type, PyObject *__pyx_v_value, PyObject *__pyx_v_tb) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("handle_error", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_6gevent_5libev_8corecext_4loop_handle_error(__pyx_v_self, __pyx_v_context, __pyx_v_type, __pyx_v_value, __pyx_v_tb, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 361, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.loop.handle_error", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_13_default_handle_error(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_f_6gevent_5libev_8corecext_4loop__default_handle_error(struct PyGeventLoopObject *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_context, PyObject *__pyx_v_type, PyObject *__pyx_v_value, PyObject *__pyx_v_tb, int __pyx_skip_dispatch) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + __Pyx_RefNannySetupContext("_default_handle_error", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_default_handle_error); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 371, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_4loop_13_default_handle_error)) { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + __pyx_t_5 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[5] = {__pyx_t_4, __pyx_v_context, __pyx_v_type, __pyx_v_value, __pyx_v_tb}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 4+__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 371, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[5] = {__pyx_t_4, __pyx_v_context, __pyx_v_type, __pyx_v_value, __pyx_v_tb}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 4+__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 371, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + { + __pyx_t_6 = PyTuple_New(4+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 371, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (__pyx_t_4) { + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL; + } + __Pyx_INCREF(__pyx_v_context); + __Pyx_GIVEREF(__pyx_v_context); + PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_5, __pyx_v_context); + __Pyx_INCREF(__pyx_v_type); + __Pyx_GIVEREF(__pyx_v_type); + PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, __pyx_v_type); + __Pyx_INCREF(__pyx_v_value); + __Pyx_GIVEREF(__pyx_v_value); + PyTuple_SET_ITEM(__pyx_t_6, 2+__pyx_t_5, __pyx_v_value); + __Pyx_INCREF(__pyx_v_tb); + __Pyx_GIVEREF(__pyx_v_tb); + PyTuple_SET_ITEM(__pyx_t_6, 3+__pyx_t_5, __pyx_v_tb); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 371, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_traceback); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 374, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_print_exception); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 374, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + __pyx_t_5 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[4] = {__pyx_t_2, __pyx_v_type, __pyx_v_value, __pyx_v_tb}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 3+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 374, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[4] = {__pyx_t_2, __pyx_v_type, __pyx_v_value, __pyx_v_tb}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 3+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 374, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_6 = PyTuple_New(3+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 374, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (__pyx_t_2) { + __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_2); __pyx_t_2 = NULL; + } + __Pyx_INCREF(__pyx_v_type); + __Pyx_GIVEREF(__pyx_v_type); + PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_5, __pyx_v_type); + __Pyx_INCREF(__pyx_v_value); + __Pyx_GIVEREF(__pyx_v_value); + PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, __pyx_v_value); + __Pyx_INCREF(__pyx_v_tb); + __Pyx_GIVEREF(__pyx_v_tb); + PyTuple_SET_ITEM(__pyx_t_6, 2+__pyx_t_5, __pyx_v_tb); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 374, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + __pyx_t_7 = (__pyx_v_self->_ptr != 0); + if (__pyx_t_7) { + + ev_break(__pyx_v_self->_ptr, EVBREAK_ONE); + + } + + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("gevent.libev.corecext.loop._default_handle_error", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_13_default_handle_error(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_13_default_handle_error(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_context = 0; + PyObject *__pyx_v_type = 0; + PyObject *__pyx_v_value = 0; + PyObject *__pyx_v_tb = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_default_handle_error (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_context,&__pyx_n_s_type,&__pyx_n_s_value,&__pyx_n_s_tb,0}; + PyObject* values[4] = {0,0,0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_context)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_type)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("_default_handle_error", 1, 4, 4, 1); __PYX_ERR(0, 371, __pyx_L3_error) + } + case 2: + if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_value)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("_default_handle_error", 1, 4, 4, 2); __PYX_ERR(0, 371, __pyx_L3_error) + } + case 3: + if (likely((values[3] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_tb)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("_default_handle_error", 1, 4, 4, 3); __PYX_ERR(0, 371, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_default_handle_error") < 0)) __PYX_ERR(0, 371, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 4) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + } + __pyx_v_context = values[0]; + __pyx_v_type = values[1]; + __pyx_v_value = values[2]; + __pyx_v_tb = values[3]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("_default_handle_error", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 371, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.libev.corecext.loop._default_handle_error", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_12_default_handle_error(((struct PyGeventLoopObject *)__pyx_v_self), __pyx_v_context, __pyx_v_type, __pyx_v_value, __pyx_v_tb); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_12_default_handle_error(struct PyGeventLoopObject *__pyx_v_self, PyObject *__pyx_v_context, PyObject *__pyx_v_type, PyObject *__pyx_v_value, PyObject *__pyx_v_tb) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("_default_handle_error", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_6gevent_5libev_8corecext_4loop__default_handle_error(__pyx_v_self, __pyx_v_context, __pyx_v_type, __pyx_v_value, __pyx_v_tb, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 371, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.loop._default_handle_error", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_15run(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_15run(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_nowait = 0; + PyObject *__pyx_v_once = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("run (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_nowait,&__pyx_n_s_once,0}; + PyObject* values[2] = {0,0}; + values[0] = ((PyObject *)Py_False); + values[1] = ((PyObject *)Py_False); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_nowait); + if (value) { values[0] = value; kw_args--; } + } + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_once); + if (value) { values[1] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "run") < 0)) __PYX_ERR(0, 378, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_nowait = values[0]; + __pyx_v_once = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("run", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 378, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.libev.corecext.loop.run", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_14run(((struct PyGeventLoopObject *)__pyx_v_self), __pyx_v_nowait, __pyx_v_once); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_14run(struct PyGeventLoopObject *__pyx_v_self, PyObject *__pyx_v_nowait, PyObject *__pyx_v_once) { + unsigned int __pyx_v_flags; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("run", 0); + + __pyx_t_1 = ((!(__pyx_v_self->_ptr != 0)) != 0); + if (__pyx_t_1) { + + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 381, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 381, __pyx_L1_error) + + } + + __pyx_v_flags = 0; + + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_nowait); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 383, __pyx_L1_error) + if (__pyx_t_1) { + + __pyx_v_flags = (__pyx_v_flags | EVRUN_NOWAIT); + + } + + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_once); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 385, __pyx_L1_error) + if (__pyx_t_1) { + + __pyx_v_flags = (__pyx_v_flags | EVRUN_ONCE); + + } + + { + #ifdef WITH_THREAD + PyThreadState *_save; + Py_UNBLOCK_THREADS + #endif + /*try:*/ { + + ev_run(__pyx_v_self->_ptr, __pyx_v_flags); + } + + /*finally:*/ { + /*normal exit:*/{ + #ifdef WITH_THREAD + Py_BLOCK_THREADS + #endif + goto __pyx_L8; + } + __pyx_L8:; + } + } + + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.loop.run", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_17reinit(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_17reinit(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("reinit (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_16reinit(((struct PyGeventLoopObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_16reinit(struct PyGeventLoopObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("reinit", 0); + + __pyx_t_1 = (__pyx_v_self->_ptr != 0); + if (__pyx_t_1) { + + ev_loop_fork(__pyx_v_self->_ptr); + + } + + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_19ref(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_19ref(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("ref (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_18ref(((struct PyGeventLoopObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_18ref(struct PyGeventLoopObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("ref", 0); + + __pyx_t_1 = ((!(__pyx_v_self->_ptr != 0)) != 0); + if (__pyx_t_1) { + + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 397, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 397, __pyx_L1_error) + + } + + ev_ref(__pyx_v_self->_ptr); + + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.loop.ref", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_21unref(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_21unref(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("unref (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_20unref(((struct PyGeventLoopObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_20unref(struct PyGeventLoopObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("unref", 0); + + __pyx_t_1 = ((!(__pyx_v_self->_ptr != 0)) != 0); + if (__pyx_t_1) { + + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 403, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 403, __pyx_L1_error) + + } + + ev_unref(__pyx_v_self->_ptr); + + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.loop.unref", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_23break_(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_23break_(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + int __pyx_v_how; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("break_ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_how,0}; + PyObject* values[1] = {0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_how); + if (value) { values[0] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "break_") < 0)) __PYX_ERR(0, 406, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + if (values[0]) { + __pyx_v_how = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_how == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 406, __pyx_L3_error) + } else { + __pyx_v_how = __pyx_k__9; + } + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("break_", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 406, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.libev.corecext.loop.break_", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_22break_(((struct PyGeventLoopObject *)__pyx_v_self), __pyx_v_how); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_22break_(struct PyGeventLoopObject *__pyx_v_self, int __pyx_v_how) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("break_", 0); + + __pyx_t_1 = ((!(__pyx_v_self->_ptr != 0)) != 0); + if (__pyx_t_1) { + + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 409, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 409, __pyx_L1_error) + + } + + ev_break(__pyx_v_self->_ptr, __pyx_v_how); + + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.loop.break_", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_25verify(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_25verify(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("verify (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_24verify(((struct PyGeventLoopObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_24verify(struct PyGeventLoopObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("verify", 0); + + __pyx_t_1 = ((!(__pyx_v_self->_ptr != 0)) != 0); + if (__pyx_t_1) { + + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__11, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 415, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 415, __pyx_L1_error) + + } + + ev_verify(__pyx_v_self->_ptr); + + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.loop.verify", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_27now(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_27now(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("now (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_26now(((struct PyGeventLoopObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_26now(struct PyGeventLoopObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("now", 0); + + __pyx_t_1 = ((!(__pyx_v_self->_ptr != 0)) != 0); + if (__pyx_t_1) { + + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 421, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 421, __pyx_L1_error) + + } + + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = PyFloat_FromDouble(ev_now(__pyx_v_self->_ptr)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 422, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.loop.now", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_29update(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_29update(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("update (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_28update(((struct PyGeventLoopObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_28update(struct PyGeventLoopObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("update", 0); + + __pyx_t_1 = ((!(__pyx_v_self->_ptr != 0)) != 0); + if (__pyx_t_1) { + + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__13, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 427, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 427, __pyx_L1_error) + + } + + ev_now_update(__pyx_v_self->_ptr); + + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.loop.update", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_31__repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_31__repr__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_30__repr__(((struct PyGeventLoopObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_30__repr__(struct PyGeventLoopObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + __Pyx_RefNannySetupContext("__repr__", 0); + + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 431, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 431, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 431, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_self)); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_id, __pyx_t_1, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 431, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 431, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (__pyx_t_5) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 431, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else { + __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 431, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 431, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_1); + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_s_at_0x_x_s, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 431, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("gevent.libev.corecext.loop.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_7default_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_7default_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_7default___get__(((struct PyGeventLoopObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_7default___get__(struct PyGeventLoopObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __pyx_t_1 = ((!(__pyx_v_self->_ptr != 0)) != 0); + if (__pyx_t_1) { + + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__14, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 438, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 438, __pyx_L1_error) + + } + + __Pyx_XDECREF(__pyx_r); + if ((ev_is_default_loop(__pyx_v_self->_ptr) != 0)) { + __Pyx_INCREF(Py_True); + __pyx_t_2 = Py_True; + } else { + __Pyx_INCREF(Py_False); + __pyx_t_2 = Py_False; + } + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.loop.default.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_9iteration_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_9iteration_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_9iteration___get__(((struct PyGeventLoopObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_9iteration___get__(struct PyGeventLoopObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __pyx_t_1 = ((!(__pyx_v_self->_ptr != 0)) != 0); + if (__pyx_t_1) { + + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__15, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 446, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 446, __pyx_L1_error) + + } + + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyInt_From_unsigned_int(ev_iteration(__pyx_v_self->_ptr)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 447, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.loop.iteration.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_5depth_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_5depth_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_5depth___get__(((struct PyGeventLoopObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_5depth___get__(struct PyGeventLoopObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __pyx_t_1 = ((!(__pyx_v_self->_ptr != 0)) != 0); + if (__pyx_t_1) { + + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__16, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 454, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 454, __pyx_L1_error) + + } + + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyInt_From_unsigned_int(ev_depth(__pyx_v_self->_ptr)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 455, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.loop.depth.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_11backend_int_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_11backend_int_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_11backend_int___get__(((struct PyGeventLoopObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_11backend_int___get__(struct PyGeventLoopObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __pyx_t_1 = ((!(__pyx_v_self->_ptr != 0)) != 0); + if (__pyx_t_1) { + + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__17, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 462, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 462, __pyx_L1_error) + + } + + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyInt_From_unsigned_int(ev_backend(__pyx_v_self->_ptr)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 463, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.loop.backend_int.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_7backend_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_7backend_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_7backend___get__(((struct PyGeventLoopObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_7backend___get__(struct PyGeventLoopObject *__pyx_v_self) { + unsigned int __pyx_v_backend; + PyObject *__pyx_v_key = NULL; + PyObject *__pyx_v_value = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + Py_ssize_t __pyx_t_4; + PyObject *(*__pyx_t_5)(PyObject *); + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *(*__pyx_t_9)(PyObject *); + __Pyx_RefNannySetupContext("__get__", 0); + + __pyx_t_1 = ((!(__pyx_v_self->_ptr != 0)) != 0); + if (__pyx_t_1) { + + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__18, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 470, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 470, __pyx_L1_error) + + } + + __pyx_v_backend = ev_backend(__pyx_v_self->_ptr); + + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_flags); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 472, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (likely(PyList_CheckExact(__pyx_t_2)) || PyTuple_CheckExact(__pyx_t_2)) { + __pyx_t_3 = __pyx_t_2; __Pyx_INCREF(__pyx_t_3); __pyx_t_4 = 0; + __pyx_t_5 = NULL; + } else { + __pyx_t_4 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 472, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 472, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + for (;;) { + if (likely(!__pyx_t_5)) { + if (likely(PyList_CheckExact(__pyx_t_3))) { + if (__pyx_t_4 >= PyList_GET_SIZE(__pyx_t_3)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_2 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_4); __Pyx_INCREF(__pyx_t_2); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 472, __pyx_L1_error) + #else + __pyx_t_2 = PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 472, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #endif + } else { + if (__pyx_t_4 >= PyTuple_GET_SIZE(__pyx_t_3)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_4); __Pyx_INCREF(__pyx_t_2); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 472, __pyx_L1_error) + #else + __pyx_t_2 = PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 472, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #endif + } + } else { + __pyx_t_2 = __pyx_t_5(__pyx_t_3); + if (unlikely(!__pyx_t_2)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 472, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_2); + } + if ((likely(PyTuple_CheckExact(__pyx_t_2))) || (PyList_CheckExact(__pyx_t_2))) { + PyObject* sequence = __pyx_t_2; + #if !CYTHON_COMPILING_IN_PYPY + Py_ssize_t size = Py_SIZE(sequence); + #else + Py_ssize_t size = PySequence_Size(sequence); + #endif + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 472, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_6 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_7 = PyTuple_GET_ITEM(sequence, 1); + } else { + __pyx_t_6 = PyList_GET_ITEM(sequence, 0); + __pyx_t_7 = PyList_GET_ITEM(sequence, 1); + } + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + #else + __pyx_t_6 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 472, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 472, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + #endif + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_8 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 472, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_9 = Py_TYPE(__pyx_t_8)->tp_iternext; + index = 0; __pyx_t_6 = __pyx_t_9(__pyx_t_8); if (unlikely(!__pyx_t_6)) goto __pyx_L6_unpacking_failed; + __Pyx_GOTREF(__pyx_t_6); + index = 1; __pyx_t_7 = __pyx_t_9(__pyx_t_8); if (unlikely(!__pyx_t_7)) goto __pyx_L6_unpacking_failed; + __Pyx_GOTREF(__pyx_t_7); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_9(__pyx_t_8), 2) < 0) __PYX_ERR(0, 472, __pyx_L1_error) + __pyx_t_9 = NULL; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + goto __pyx_L7_unpacking_done; + __pyx_L6_unpacking_failed:; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_9 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 472, __pyx_L1_error) + __pyx_L7_unpacking_done:; + } + __Pyx_XDECREF_SET(__pyx_v_key, __pyx_t_6); + __pyx_t_6 = 0; + __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_7); + __pyx_t_7 = 0; + + __pyx_t_2 = __Pyx_PyInt_From_unsigned_int(__pyx_v_backend); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 473, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = PyObject_RichCompare(__pyx_v_key, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 473, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 473, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (__pyx_t_1) { + + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_value); + __pyx_r = __pyx_v_value; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L0; + + } + + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = __Pyx_PyInt_From_unsigned_int(__pyx_v_backend); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 475, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("gevent.libev.corecext.loop.backend.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_key); + __Pyx_XDECREF(__pyx_v_value); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_10pendingcnt_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_10pendingcnt_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_10pendingcnt___get__(((struct PyGeventLoopObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_10pendingcnt___get__(struct PyGeventLoopObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __pyx_t_1 = ((!(__pyx_v_self->_ptr != 0)) != 0); + if (__pyx_t_1) { + + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__19, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 482, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 482, __pyx_L1_error) + + } + + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyInt_From_unsigned_int(ev_pending_count(__pyx_v_self->_ptr)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 483, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.loop.pendingcnt.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_33io(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_33io(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + vfd_socket_t __pyx_v_fd; +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + int __pyx_v_fd; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + vfd_socket_t __pyx_v_fd; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + int __pyx_v_events; + PyObject *__pyx_v_ref = 0; + PyObject *__pyx_v_priority = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("io (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_fd,&__pyx_n_s_events_2,&__pyx_n_s_ref,&__pyx_n_s_priority,0}; + PyObject* values[4] = {0,0,0,0}; + values[2] = ((PyObject *)Py_True); + values[3] = ((PyObject *)Py_None); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_fd)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_events_2)) != 0)) kw_args--; + else { +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __Pyx_RaiseArgtupleInvalid("io", 0, 2, 4, 1); __PYX_ERR(0, 486, __pyx_L3_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_RaiseArgtupleInvalid("io", 0, 2, 4, 1); __PYX_ERR(0, 489, __pyx_L3_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __Pyx_RaiseArgtupleInvalid("io", 0, 2, 4, 1); __PYX_ERR(0, 486, __pyx_L3_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + } + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ref); + if (value) { values[2] = value; kw_args--; } + } + case 3: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_priority); + if (value) { values[3] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "io") < 0)) __PYX_ERR(0, 486, __pyx_L3_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "io") < 0)) __PYX_ERR(0, 489, __pyx_L3_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "io") < 0)) __PYX_ERR(0, 486, __pyx_L3_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_v_fd = __Pyx_PyInt_As_vfd_socket_t(values[0]); if (unlikely((__pyx_v_fd == ((vfd_socket_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 486, __pyx_L3_error) + __pyx_v_events = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_events == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 486, __pyx_L3_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_v_fd = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_fd == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 489, __pyx_L3_error) + __pyx_v_events = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_events == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 489, __pyx_L3_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_v_fd = __Pyx_PyInt_As_vfd_socket_t(values[0]); if (unlikely((__pyx_v_fd == ((vfd_socket_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 486, __pyx_L3_error) + __pyx_v_events = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_events == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 486, __pyx_L3_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_v_ref = values[2]; + __pyx_v_priority = values[3]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __Pyx_RaiseArgtupleInvalid("io", 0, 2, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 486, __pyx_L3_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_RaiseArgtupleInvalid("io", 0, 2, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 489, __pyx_L3_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __Pyx_RaiseArgtupleInvalid("io", 0, 2, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 486, __pyx_L3_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.libev.corecext.loop.io", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_32io(((struct PyGeventLoopObject *)__pyx_v_self), __pyx_v_fd, __pyx_v_events, __pyx_v_ref, __pyx_v_priority); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_32io(struct PyGeventLoopObject *__pyx_v_self, vfd_socket_t __pyx_v_fd, int __pyx_v_events, PyObject *__pyx_v_ref, PyObject *__pyx_v_priority) { +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_32io(struct PyGeventLoopObject *__pyx_v_self, int __pyx_v_fd, int __pyx_v_events, PyObject *__pyx_v_ref, PyObject *__pyx_v_priority) { +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_32io(struct PyGeventLoopObject *__pyx_v_self, vfd_socket_t __pyx_v_fd, int __pyx_v_events, PyObject *__pyx_v_ref, PyObject *__pyx_v_priority) { +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("io", 0); + + __Pyx_XDECREF(__pyx_r); +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_1 = __Pyx_PyInt_From_vfd_socket_t(__pyx_v_fd); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 487, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_fd); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 490, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_1 = __Pyx_PyInt_From_vfd_socket_t(__pyx_v_fd); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 487, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_1); +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_events); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 487, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_events); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 490, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_events); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 487, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_3 = PyTuple_New(5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 487, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_3 = PyTuple_New(5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 490, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_3 = PyTuple_New(5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 487, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2); + __Pyx_INCREF(__pyx_v_ref); + __Pyx_GIVEREF(__pyx_v_ref); + PyTuple_SET_ITEM(__pyx_t_3, 3, __pyx_v_ref); + __Pyx_INCREF(__pyx_v_priority); + __Pyx_GIVEREF(__pyx_v_priority); + PyTuple_SET_ITEM(__pyx_t_3, 4, __pyx_v_priority); + __pyx_t_1 = 0; + __pyx_t_2 = 0; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6gevent_5libev_8corecext_io), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 487, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6gevent_5libev_8corecext_io), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 490, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6gevent_5libev_8corecext_io), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 487, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("gevent.libev.corecext.loop.io", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_35timer(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_35timer(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + double __pyx_v_after; + double __pyx_v_repeat; + PyObject *__pyx_v_ref = 0; + PyObject *__pyx_v_priority = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("timer (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_after,&__pyx_n_s_repeat,&__pyx_n_s_ref,&__pyx_n_s_priority,0}; + PyObject* values[4] = {0,0,0,0}; + values[2] = ((PyObject *)Py_True); + values[3] = ((PyObject *)Py_None); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_after)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_repeat); + if (value) { values[1] = value; kw_args--; } + } + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ref); + if (value) { values[2] = value; kw_args--; } + } + case 3: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_priority); + if (value) { values[3] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "timer") < 0)) __PYX_ERR(0, 493, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_after = __pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_after == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 493, __pyx_L3_error) + if (values[1]) { + __pyx_v_repeat = __pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_repeat == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 493, __pyx_L3_error) + } else { + __pyx_v_repeat = ((double)0.0); + } + __pyx_v_ref = values[2]; + __pyx_v_priority = values[3]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("timer", 0, 1, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 493, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.libev.corecext.loop.timer", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_34timer(((struct PyGeventLoopObject *)__pyx_v_self), __pyx_v_after, __pyx_v_repeat, __pyx_v_ref, __pyx_v_priority); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_34timer(struct PyGeventLoopObject *__pyx_v_self, double __pyx_v_after, double __pyx_v_repeat, PyObject *__pyx_v_ref, PyObject *__pyx_v_priority) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("timer", 0); + + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_after); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 494, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyFloat_FromDouble(__pyx_v_repeat); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 494, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 494, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2); + __Pyx_INCREF(__pyx_v_ref); + __Pyx_GIVEREF(__pyx_v_ref); + PyTuple_SET_ITEM(__pyx_t_3, 3, __pyx_v_ref); + __Pyx_INCREF(__pyx_v_priority); + __Pyx_GIVEREF(__pyx_v_priority); + PyTuple_SET_ITEM(__pyx_t_3, 4, __pyx_v_priority); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6gevent_5libev_8corecext_timer), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 494, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("gevent.libev.corecext.loop.timer", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_37signal(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_37signal(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + int __pyx_v_signum; + PyObject *__pyx_v_ref = 0; + PyObject *__pyx_v_priority = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("signal (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_signum,&__pyx_n_s_ref,&__pyx_n_s_priority,0}; + PyObject* values[3] = {0,0,0}; + values[1] = ((PyObject *)Py_True); + values[2] = ((PyObject *)Py_None); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_signum)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ref); + if (value) { values[1] = value; kw_args--; } + } + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_priority); + if (value) { values[2] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "signal") < 0)) __PYX_ERR(0, 496, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_signum = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_signum == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 496, __pyx_L3_error) + __pyx_v_ref = values[1]; + __pyx_v_priority = values[2]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("signal", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 496, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.libev.corecext.loop.signal", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_36signal(((struct PyGeventLoopObject *)__pyx_v_self), __pyx_v_signum, __pyx_v_ref, __pyx_v_priority); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_36signal(struct PyGeventLoopObject *__pyx_v_self, int __pyx_v_signum, PyObject *__pyx_v_ref, PyObject *__pyx_v_priority) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("signal", 0); + + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_signum); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 497, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyTuple_New(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 497, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + PyTuple_SET_ITEM(__pyx_t_2, 0, ((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_1); + __Pyx_INCREF(__pyx_v_ref); + __Pyx_GIVEREF(__pyx_v_ref); + PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_v_ref); + __Pyx_INCREF(__pyx_v_priority); + __Pyx_GIVEREF(__pyx_v_priority); + PyTuple_SET_ITEM(__pyx_t_2, 3, __pyx_v_priority); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6gevent_5libev_8corecext_signal), __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 497, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.loop.signal", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_39idle(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_39idle(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_ref = 0; + PyObject *__pyx_v_priority = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("idle (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ref,&__pyx_n_s_priority,0}; + PyObject* values[2] = {0,0}; + values[0] = ((PyObject *)Py_True); + values[1] = ((PyObject *)Py_None); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ref); + if (value) { values[0] = value; kw_args--; } + } + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_priority); + if (value) { values[1] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "idle") < 0)) __PYX_ERR(0, 499, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_ref = values[0]; + __pyx_v_priority = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("idle", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 499, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.libev.corecext.loop.idle", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_38idle(((struct PyGeventLoopObject *)__pyx_v_self), __pyx_v_ref, __pyx_v_priority); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_38idle(struct PyGeventLoopObject *__pyx_v_self, PyObject *__pyx_v_ref, PyObject *__pyx_v_priority) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("idle", 0); + + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 500, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_self)); + __Pyx_INCREF(__pyx_v_ref); + __Pyx_GIVEREF(__pyx_v_ref); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_ref); + __Pyx_INCREF(__pyx_v_priority); + __Pyx_GIVEREF(__pyx_v_priority); + PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_priority); + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6gevent_5libev_8corecext_idle), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 500, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.loop.idle", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_41prepare(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_41prepare(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_ref = 0; + PyObject *__pyx_v_priority = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("prepare (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ref,&__pyx_n_s_priority,0}; + PyObject* values[2] = {0,0}; + values[0] = ((PyObject *)Py_True); + values[1] = ((PyObject *)Py_None); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ref); + if (value) { values[0] = value; kw_args--; } + } + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_priority); + if (value) { values[1] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "prepare") < 0)) __PYX_ERR(0, 502, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_ref = values[0]; + __pyx_v_priority = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("prepare", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 502, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.libev.corecext.loop.prepare", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_40prepare(((struct PyGeventLoopObject *)__pyx_v_self), __pyx_v_ref, __pyx_v_priority); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_40prepare(struct PyGeventLoopObject *__pyx_v_self, PyObject *__pyx_v_ref, PyObject *__pyx_v_priority) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("prepare", 0); + + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 503, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_self)); + __Pyx_INCREF(__pyx_v_ref); + __Pyx_GIVEREF(__pyx_v_ref); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_ref); + __Pyx_INCREF(__pyx_v_priority); + __Pyx_GIVEREF(__pyx_v_priority); + PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_priority); + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6gevent_5libev_8corecext_prepare), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 503, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.loop.prepare", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_43check(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_43check(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_ref = 0; + PyObject *__pyx_v_priority = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("check (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ref,&__pyx_n_s_priority,0}; + PyObject* values[2] = {0,0}; + values[0] = ((PyObject *)Py_True); + values[1] = ((PyObject *)Py_None); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ref); + if (value) { values[0] = value; kw_args--; } + } + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_priority); + if (value) { values[1] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "check") < 0)) __PYX_ERR(0, 505, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_ref = values[0]; + __pyx_v_priority = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("check", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 505, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.libev.corecext.loop.check", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_42check(((struct PyGeventLoopObject *)__pyx_v_self), __pyx_v_ref, __pyx_v_priority); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_42check(struct PyGeventLoopObject *__pyx_v_self, PyObject *__pyx_v_ref, PyObject *__pyx_v_priority) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("check", 0); + + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 506, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_self)); + __Pyx_INCREF(__pyx_v_ref); + __Pyx_GIVEREF(__pyx_v_ref); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_ref); + __Pyx_INCREF(__pyx_v_priority); + __Pyx_GIVEREF(__pyx_v_priority); + PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_priority); + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6gevent_5libev_8corecext_check), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 506, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.loop.check", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_45fork(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_45fork(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_ref = 0; + PyObject *__pyx_v_priority = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("fork (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ref,&__pyx_n_s_priority,0}; + PyObject* values[2] = {0,0}; + values[0] = ((PyObject *)Py_True); + values[1] = ((PyObject *)Py_None); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ref); + if (value) { values[0] = value; kw_args--; } + } + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_priority); + if (value) { values[1] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "fork") < 0)) __PYX_ERR(0, 508, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_ref = values[0]; + __pyx_v_priority = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("fork", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 508, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.libev.corecext.loop.fork", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_44fork(((struct PyGeventLoopObject *)__pyx_v_self), __pyx_v_ref, __pyx_v_priority); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_44fork(struct PyGeventLoopObject *__pyx_v_self, PyObject *__pyx_v_ref, PyObject *__pyx_v_priority) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("fork", 0); + + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 509, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_self)); + __Pyx_INCREF(__pyx_v_ref); + __Pyx_GIVEREF(__pyx_v_ref); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_ref); + __Pyx_INCREF(__pyx_v_priority); + __Pyx_GIVEREF(__pyx_v_priority); + PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_priority); + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6gevent_5libev_8corecext_fork), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 509, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.loop.fork", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_47async(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_47async(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_ref = 0; + PyObject *__pyx_v_priority = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("async (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ref,&__pyx_n_s_priority,0}; + PyObject* values[2] = {0,0}; + values[0] = ((PyObject *)Py_True); + values[1] = ((PyObject *)Py_None); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ref); + if (value) { values[0] = value; kw_args--; } + } + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_priority); + if (value) { values[1] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "async") < 0)) __PYX_ERR(0, 511, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_ref = values[0]; + __pyx_v_priority = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("async", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 511, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.libev.corecext.loop.async", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_46async(((struct PyGeventLoopObject *)__pyx_v_self), __pyx_v_ref, __pyx_v_priority); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_46async(struct PyGeventLoopObject *__pyx_v_self, PyObject *__pyx_v_ref, PyObject *__pyx_v_priority) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("async", 0); + + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 512, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_self)); + __Pyx_INCREF(__pyx_v_ref); + __Pyx_GIVEREF(__pyx_v_ref); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_ref); + __Pyx_INCREF(__pyx_v_priority); + __Pyx_GIVEREF(__pyx_v_priority); + PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_priority); + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6gevent_5libev_8corecext_async), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 512, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.loop.async", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_49stat(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_49stat(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_49child(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_49child(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + int __pyx_v_pid; + int __pyx_v_trace; + PyObject *__pyx_v_ref = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("child (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pid,&__pyx_n_s_trace,&__pyx_n_s_ref,0}; + PyObject* values[3] = {0,0,0}; + values[2] = ((PyObject *)Py_True); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pid)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_trace); + if (value) { values[1] = value; kw_args--; } + } + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ref); + if (value) { values[2] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "child") < 0)) __PYX_ERR(0, 517, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_pid = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_pid == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 517, __pyx_L3_error) + if (values[1]) { + __pyx_v_trace = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_trace == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 517, __pyx_L3_error) + } else { + __pyx_v_trace = ((int)0); + } + __pyx_v_ref = values[2]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("child", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 517, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.libev.corecext.loop.child", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_48child(((struct PyGeventLoopObject *)__pyx_v_self), __pyx_v_pid, __pyx_v_trace, __pyx_v_ref); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_48child(struct PyGeventLoopObject *__pyx_v_self, int __pyx_v_pid, int __pyx_v_trace, PyObject *__pyx_v_ref) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("child", 0); + + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_pid); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 518, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_trace); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 518, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 518, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2); + __Pyx_INCREF(__pyx_v_ref); + __Pyx_GIVEREF(__pyx_v_ref); + PyTuple_SET_ITEM(__pyx_t_3, 3, __pyx_v_ref); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6gevent_5libev_8corecext_child), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 518, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("gevent.libev.corecext.loop.child", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_51install_sigchld(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_51install_sigchld(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("install_sigchld (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_50install_sigchld(((struct PyGeventLoopObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_50install_sigchld(CYTHON_UNUSED struct PyGeventLoopObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("install_sigchld", 0); + + gevent_install_sigchld_handler(); + + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_53reset_sigchld(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_53reset_sigchld(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("reset_sigchld (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_52reset_sigchld(((struct PyGeventLoopObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_52reset_sigchld(CYTHON_UNUSED struct PyGeventLoopObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("reset_sigchld", 0); + + gevent_reset_sigchld_handler(); + + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_55stat(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_55stat(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_49stat(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_49stat(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + PyObject *__pyx_v_path = 0; + float __pyx_v_interval; + PyObject *__pyx_v_ref = 0; + PyObject *__pyx_v_priority = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("stat (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_path,&__pyx_n_s_interval,&__pyx_n_s_ref,&__pyx_n_s_priority,0}; + PyObject* values[4] = {0,0,0,0}; + values[2] = ((PyObject *)Py_True); + values[3] = ((PyObject *)Py_None); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_path)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_interval); + if (value) { values[1] = value; kw_args--; } + } + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ref); + if (value) { values[2] = value; kw_args--; } + } + case 3: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_priority); + if (value) { values[3] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stat") < 0)) __PYX_ERR(0, 528, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_path = ((PyObject*)values[0]); + if (values[1]) { + __pyx_v_interval = __pyx_PyFloat_AsFloat(values[1]); if (unlikely((__pyx_v_interval == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 528, __pyx_L3_error) + } else { + __pyx_v_interval = ((float)0.0); + } + __pyx_v_ref = values[2]; + __pyx_v_priority = values[3]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("stat", 0, 1, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 528, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.libev.corecext.loop.stat", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_path), (&PyString_Type), 1, "path", 1))) __PYX_ERR(0, 528, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_48stat(((struct PyGeventLoopObject *)__pyx_v_self), __pyx_v_path, __pyx_v_interval, __pyx_v_ref, __pyx_v_priority); +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_54stat(((struct PyGeventLoopObject *)__pyx_v_self), __pyx_v_path, __pyx_v_interval, __pyx_v_ref, __pyx_v_priority); +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_48stat(((struct PyGeventLoopObject *)__pyx_v_self), __pyx_v_path, __pyx_v_interval, __pyx_v_ref, __pyx_v_priority); +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_48stat(struct PyGeventLoopObject *__pyx_v_self, PyObject *__pyx_v_path, float __pyx_v_interval, PyObject *__pyx_v_ref, PyObject *__pyx_v_priority) { +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_54stat(struct PyGeventLoopObject *__pyx_v_self, PyObject *__pyx_v_path, float __pyx_v_interval, PyObject *__pyx_v_ref, PyObject *__pyx_v_priority) { +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_48stat(struct PyGeventLoopObject *__pyx_v_self, PyObject *__pyx_v_path, float __pyx_v_interval, PyObject *__pyx_v_ref, PyObject *__pyx_v_priority) { +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("stat", 0); + + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_interval); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 529, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyTuple_New(5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 529, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + PyTuple_SET_ITEM(__pyx_t_2, 0, ((PyObject *)__pyx_v_self)); + __Pyx_INCREF(__pyx_v_path); + __Pyx_GIVEREF(__pyx_v_path); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_path); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_t_1); + __Pyx_INCREF(__pyx_v_ref); + __Pyx_GIVEREF(__pyx_v_ref); + PyTuple_SET_ITEM(__pyx_t_2, 3, __pyx_v_ref); + __Pyx_INCREF(__pyx_v_priority); + __Pyx_GIVEREF(__pyx_v_priority); + PyTuple_SET_ITEM(__pyx_t_2, 4, __pyx_v_priority); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6gevent_5libev_8corecext_stat), __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 529, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.loop.stat", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_51run_callback(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_51run_callback(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_57run_callback(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_57run_callback(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_51run_callback(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_51run_callback(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + PyObject *__pyx_v_func = 0; + PyObject *__pyx_v_args = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("run_callback (wrapper)", 0); + if (PyTuple_GET_SIZE(__pyx_args) > 1) { + __pyx_v_args = PyTuple_GetSlice(__pyx_args, 1, PyTuple_GET_SIZE(__pyx_args)); + if (unlikely(!__pyx_v_args)) { + __Pyx_RefNannyFinishContext(); + return NULL; + } + __Pyx_GOTREF(__pyx_v_args); + } else { + __pyx_v_args = __pyx_empty_tuple; __Pyx_INCREF(__pyx_empty_tuple); + } + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_func,0}; + PyObject* values[1] = {0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + default: + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_func)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t used_pos_args = (pos_args < 1) ? pos_args : 1; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, used_pos_args, "run_callback") < 0)) __PYX_ERR(0, 531, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) < 1) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + } + __pyx_v_func = values[0]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("run_callback", 0, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 531, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0; + __Pyx_AddTraceback("gevent.libev.corecext.loop.run_callback", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_50run_callback(((struct PyGeventLoopObject *)__pyx_v_self), __pyx_v_func, __pyx_v_args); +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_56run_callback(((struct PyGeventLoopObject *)__pyx_v_self), __pyx_v_func, __pyx_v_args); +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_50run_callback(((struct PyGeventLoopObject *)__pyx_v_self), __pyx_v_func, __pyx_v_args); +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + + /* function exit code */ + __Pyx_XDECREF(__pyx_v_args); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_50run_callback(struct PyGeventLoopObject *__pyx_v_self, PyObject *__pyx_v_func, PyObject *__pyx_v_args) { +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_56run_callback(struct PyGeventLoopObject *__pyx_v_self, PyObject *__pyx_v_func, PyObject *__pyx_v_args) { +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_50run_callback(struct PyGeventLoopObject *__pyx_v_self, PyObject *__pyx_v_func, PyObject *__pyx_v_args) { +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + struct PyGeventCallbackObject *__pyx_v_cb = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + __Pyx_RefNannySetupContext("run_callback", 0); + + __pyx_t_1 = ((!(__pyx_v_self->_ptr != 0)) != 0); + if (__pyx_t_1) { + + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__20, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 534, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 534, __pyx_L1_error) + + } + + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 535, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_v_func); + __Pyx_GIVEREF(__pyx_v_func); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_func); + __Pyx_INCREF(__pyx_v_args); + __Pyx_GIVEREF(__pyx_v_args); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_args); + __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6gevent_5libev_8corecext_callback), __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 535, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_cb = ((struct PyGeventCallbackObject *)__pyx_t_3); + __pyx_t_3 = 0; + + if (unlikely(__pyx_v_self->_callbacks == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "append"); + __PYX_ERR(0, 536, __pyx_L1_error) + } + __pyx_t_4 = __Pyx_PyList_Append(__pyx_v_self->_callbacks, ((PyObject *)__pyx_v_cb)); if (unlikely(__pyx_t_4 == -1)) __PYX_ERR(0, 536, __pyx_L1_error) + + ev_ref(__pyx_v_self->_ptr); + + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_cb)); + __pyx_r = ((PyObject *)__pyx_v_cb); + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("gevent.libev.corecext.loop.run_callback", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_cb); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_53_format(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_53_format(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_59_format(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_59_format(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_53_format(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_53_format(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_format (wrapper)", 0); +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_52_format(((struct PyGeventLoopObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_52_format(struct PyGeventLoopObject *__pyx_v_self) { +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_58_format(((struct PyGeventLoopObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_58_format(struct PyGeventLoopObject *__pyx_v_self) { +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_52_format(((struct PyGeventLoopObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_52_format(struct PyGeventLoopObject *__pyx_v_self) { +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + PyObject *__pyx_v_msg = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + PyObject *__pyx_t_4 = NULL; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_RefNannySetupContext("_format", 0); + + __pyx_t_1 = ((!(__pyx_v_self->_ptr != 0)) != 0); + if (__pyx_t_1) { + + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_n_s_destroyed); + __pyx_r = __pyx_n_s_destroyed; + goto __pyx_L0; + + } + + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_backend); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 543, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_msg = __pyx_t_2; + __pyx_t_2 = 0; + + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_default); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 544, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 544, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_1) { + + __pyx_t_2 = PyNumber_InPlaceAdd(__pyx_v_msg, __pyx_kp_s_default_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 545, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF_SET(__pyx_v_msg, __pyx_t_2); + __pyx_t_2 = 0; + + } + + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_pendingcnt); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 546, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_pending_s, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 546, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyNumber_InPlaceAdd(__pyx_v_msg, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 546, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_msg, __pyx_t_2); + __pyx_t_2 = 0; + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_format_details); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 548, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 548, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 548, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_msg, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 548, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF_SET(__pyx_v_msg, __pyx_t_3); + __pyx_t_3 = 0; + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_msg); + __pyx_r = __pyx_v_msg; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_XDECREF(__pyx_t_4); +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_AddTraceback("gevent.libev.corecext.loop._format", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_msg); +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_55_format_details(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_55_format_details(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_61_format_details(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_61_format_details(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_55_format_details(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_55_format_details(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_format_details (wrapper)", 0); +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_54_format_details(((struct PyGeventLoopObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_54_format_details(struct PyGeventLoopObject *__pyx_v_self) { +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_60_format_details(((struct PyGeventLoopObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_60_format_details(struct PyGeventLoopObject *__pyx_v_self) { +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_54_format_details(((struct PyGeventLoopObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_54_format_details(struct PyGeventLoopObject *__pyx_v_self) { +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + PyObject *__pyx_v_msg = 0; + PyObject *__pyx_v_fileno = 0; + PyObject *__pyx_v_sigfd = 0; + PyObject *__pyx_v_activecnt = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + int __pyx_t_8; + int __pyx_t_9; + int __pyx_t_10; + __Pyx_RefNannySetupContext("_format_details", 0); + + __Pyx_INCREF(__pyx_kp_s__21); + __pyx_v_msg = __pyx_kp_s__21; + + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_fileno); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 556, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (__pyx_t_3) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 556, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 556, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_fileno = __pyx_t_1; + __pyx_t_1 = 0; + + __Pyx_INCREF(Py_None); + __pyx_v_sigfd = Py_None; + + __Pyx_INCREF(Py_None); + __pyx_v_activecnt = Py_None; + + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_4, &__pyx_t_5, &__pyx_t_6); + __Pyx_XGOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_t_5); + __Pyx_XGOTREF(__pyx_t_6); + /*try:*/ { + + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_sigfd); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 560, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_sigfd, __pyx_t_1); + __pyx_t_1 = 0; + + } + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + goto __pyx_L10_try_end; + __pyx_L3_error:; + __Pyx_PyThreadState_assign + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + + __pyx_t_7 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_AttributeError); + if (__pyx_t_7) { + __Pyx_AddTraceback("gevent.libev.corecext.loop._format_details", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3) < 0) __PYX_ERR(0, 561, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_t_3); + + __Pyx_INCREF(Py_None); + __Pyx_DECREF_SET(__pyx_v_sigfd, Py_None); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L4_exception_handled; + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; + + __Pyx_PyThreadState_assign + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_XGIVEREF(__pyx_t_6); + __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6); + goto __pyx_L1_error; + __pyx_L4_exception_handled:; + __Pyx_PyThreadState_assign + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_XGIVEREF(__pyx_t_6); + __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6); + __pyx_L10_try_end:; + } + + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_6, &__pyx_t_5, &__pyx_t_4); + __Pyx_XGOTREF(__pyx_t_6); + __Pyx_XGOTREF(__pyx_t_5); + __Pyx_XGOTREF(__pyx_t_4); + /*try:*/ { + + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_activecnt); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 564, __pyx_L13_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF_SET(__pyx_v_activecnt, __pyx_t_3); + __pyx_t_3 = 0; + + } + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + goto __pyx_L20_try_end; + __pyx_L13_error:; + __Pyx_PyThreadState_assign + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + + __pyx_t_7 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_AttributeError); + if (__pyx_t_7) { + __Pyx_ErrRestore(0,0,0); + goto __pyx_L14_exception_handled; + } + goto __pyx_L15_except_error; + __pyx_L15_except_error:; + + __Pyx_PyThreadState_assign + __Pyx_XGIVEREF(__pyx_t_6); + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_5, __pyx_t_4); + goto __pyx_L1_error; + __pyx_L14_exception_handled:; + __Pyx_PyThreadState_assign + __Pyx_XGIVEREF(__pyx_t_6); + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_5, __pyx_t_4); + __pyx_L20_try_end:; + } + + __pyx_t_8 = (__pyx_v_activecnt != Py_None); + __pyx_t_9 = (__pyx_t_8 != 0); + if (__pyx_t_9) { + + __pyx_t_3 = PyObject_Repr(__pyx_v_activecnt); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 568, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = PyNumber_Add(__pyx_kp_s_ref_2, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 568, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_msg, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 568, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF_SET(__pyx_v_msg, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + } + + __pyx_t_9 = (__pyx_v_fileno != Py_None); + __pyx_t_8 = (__pyx_t_9 != 0); + if (__pyx_t_8) { + + __pyx_t_3 = PyObject_Repr(__pyx_v_fileno); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 570, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = PyNumber_Add(__pyx_kp_s_fileno_2, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 570, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_msg, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 570, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF_SET(__pyx_v_msg, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + } + + __pyx_t_9 = (__pyx_v_sigfd != Py_None); + __pyx_t_10 = (__pyx_t_9 != 0); + if (__pyx_t_10) { + } else { + __pyx_t_8 = __pyx_t_10; + goto __pyx_L24_bool_binop_done; + } + __pyx_t_3 = PyObject_RichCompare(__pyx_v_sigfd, __pyx_int_neg_1, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 571, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_10 < 0)) __PYX_ERR(0, 571, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_8 = __pyx_t_10; + __pyx_L24_bool_binop_done:; + if (__pyx_t_8) { + + __pyx_t_3 = PyObject_Repr(__pyx_v_sigfd); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 572, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = PyNumber_Add(__pyx_kp_s_sigfd_2, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 572, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_msg, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 572, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF_SET(__pyx_v_msg, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + } + + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_msg); + __pyx_r = __pyx_v_msg; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("gevent.libev.corecext.loop._format_details", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_msg); + __Pyx_XDECREF(__pyx_v_fileno); + __Pyx_XDECREF(__pyx_v_sigfd); + __Pyx_XDECREF(__pyx_v_activecnt); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_57fileno(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_57fileno(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_63fileno(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_63fileno(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_57fileno(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_57fileno(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("fileno (wrapper)", 0); +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_56fileno(((struct PyGeventLoopObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_56fileno(struct PyGeventLoopObject *__pyx_v_self) { +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_62fileno(((struct PyGeventLoopObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_62fileno(struct PyGeventLoopObject *__pyx_v_self) { +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_56fileno(((struct PyGeventLoopObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_56fileno(struct PyGeventLoopObject *__pyx_v_self) { +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + int __pyx_v_fd; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("fileno", 0); + + __pyx_t_1 = (__pyx_v_self->_ptr != 0); + if (__pyx_t_1) { + + __pyx_t_2 = __pyx_v_self->_ptr->backend_fd; + __pyx_v_fd = __pyx_t_2; + + __pyx_t_1 = ((__pyx_v_fd >= 0) != 0); + if (__pyx_t_1) { + + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_fd); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 580, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + } + + } + + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("gevent.libev.corecext.loop.fileno", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_9activecnt_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_9activecnt_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_9activecnt___get__(((struct PyGeventLoopObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_9activecnt___get__(struct PyGeventLoopObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __pyx_t_1 = ((!(__pyx_v_self->_ptr != 0)) != 0); + if (__pyx_t_1) { + + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__22, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 587, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 587, __pyx_L1_error) + + } + + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->_ptr->activecnt); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 588, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.loop.activecnt.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_11sig_pending_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_11sig_pending_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_11sig_pending___get__(((struct PyGeventLoopObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_11sig_pending___get__(struct PyGeventLoopObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __pyx_t_1 = ((!(__pyx_v_self->_ptr != 0)) != 0); + if (__pyx_t_1) { + + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__23, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 595, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 595, __pyx_L1_error) + + } + + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->_ptr->sig_pending); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 596, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.loop.sig_pending.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_5sigfd_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_5sigfd_1__get__(PyObject *__pyx_v_self) { +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_9origflags_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_9origflags_1__get__(PyObject *__pyx_v_self) { +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_5sigfd___get__(((struct PyGeventLoopObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_5sigfd___get__(struct PyGeventLoopObject *__pyx_v_self) { +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_9origflags___get__(((struct PyGeventLoopObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_9origflags___get__(struct PyGeventLoopObject *__pyx_v_self) { +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __pyx_t_1 = ((!(__pyx_v_self->_ptr != 0)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__24, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 604, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 604, __pyx_L1_error) + + } + + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->_ptr->sigfd); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 605, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.loop.sigfd.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_9origflags_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_9origflags_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_9origflags___get__(((struct PyGeventLoopObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_9origflags___get__(struct PyGeventLoopObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __pyx_t_1 = ((!(__pyx_v_self->_ptr != 0)) != 0); + if (__pyx_t_1) { + + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__25, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 613, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__24, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 613, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 613, __pyx_L1_error) + + } + + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __pyx_f_6gevent_5libev_8corecext__flags_to_list(__pyx_v_self->_ptr->origflags, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 614, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.loop.origflags.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_13origflags_int_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_13origflags_int_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_13origflags_int___get__(((struct PyGeventLoopObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_13origflags_int___get__(struct PyGeventLoopObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __pyx_t_1 = ((!(__pyx_v_self->_ptr != 0)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__26, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 621, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__25, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 621, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 621, __pyx_L1_error) + + } + + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyInt_From_unsigned_int(__pyx_v_self->_ptr->origflags); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 622, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.loop.origflags_int.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_13error_handler_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_13error_handler_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_13error_handler___get__(((struct PyGeventLoopObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_13error_handler___get__(struct PyGeventLoopObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->error_handler); + __pyx_r = __pyx_v_self->error_handler; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_4loop_13error_handler_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_4loop_13error_handler_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_13error_handler_2__set__(((struct PyGeventLoopObject *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_4loop_13error_handler_2__set__(struct PyGeventLoopObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __Pyx_INCREF(__pyx_v_value); + __Pyx_GIVEREF(__pyx_v_value); + __Pyx_GOTREF(__pyx_v_self->error_handler); + __Pyx_DECREF(__pyx_v_self->error_handler); + __pyx_v_self->error_handler = __pyx_v_value; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_4loop_13error_handler_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_4loop_13error_handler_5__del__(PyObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_13error_handler_4__del__(((struct PyGeventLoopObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_4loop_13error_handler_4__del__(struct PyGeventLoopObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 0); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->error_handler); + __Pyx_DECREF(__pyx_v_self->error_handler); + __pyx_v_self->error_handler = Py_None; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_10_callbacks_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4loop_10_callbacks_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_10_callbacks___get__(((struct PyGeventLoopObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4loop_10_callbacks___get__(struct PyGeventLoopObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->_callbacks); + __pyx_r = __pyx_v_self->_callbacks; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_4loop_10_callbacks_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_4loop_10_callbacks_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_10_callbacks_2__set__(((struct PyGeventLoopObject *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_4loop_10_callbacks_2__set__(struct PyGeventLoopObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__set__", 0); + if (!(likely(PyList_CheckExact(__pyx_v_value))||((__pyx_v_value) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_v_value)->tp_name), 0))) __PYX_ERR(0, 250, __pyx_L1_error) + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->_callbacks); + __Pyx_DECREF(__pyx_v_self->_callbacks); + __pyx_v_self->_callbacks = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.loop._callbacks.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_4loop_10_callbacks_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_4loop_10_callbacks_5__del__(PyObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4loop_10_callbacks_4__del__(((struct PyGeventLoopObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_4loop_10_callbacks_4__del__(struct PyGeventLoopObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 0); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->_callbacks); + __Pyx_DECREF(__pyx_v_self->_callbacks); + __pyx_v_self->_callbacks = ((PyObject*)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_8callback_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_8callback_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_callback = 0; + PyObject *__pyx_v_args = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_callback,&__pyx_n_s_args,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_callback)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_args)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, 1); __PYX_ERR(0, 631, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 631, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + } + __pyx_v_callback = values[0]; + __pyx_v_args = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 631, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.libev.corecext.callback.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_8callback___init__(((struct PyGeventCallbackObject *)__pyx_v_self), __pyx_v_callback, __pyx_v_args); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_8callback___init__(struct PyGeventCallbackObject *__pyx_v_self, PyObject *__pyx_v_callback, PyObject *__pyx_v_args) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__init__", 0); + + __Pyx_INCREF(__pyx_v_callback); + __Pyx_GIVEREF(__pyx_v_callback); + __Pyx_GOTREF(__pyx_v_self->callback); + __Pyx_DECREF(__pyx_v_self->callback); + __pyx_v_self->callback = __pyx_v_callback; + + if (!(likely(PyTuple_CheckExact(__pyx_v_args))||((__pyx_v_args) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v_args)->tp_name), 0))) __PYX_ERR(0, 633, __pyx_L1_error) + __pyx_t_1 = __pyx_v_args; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.callback.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_8callback_3stop(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_8callback_3stop(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("stop (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_8callback_2stop(((struct PyGeventCallbackObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_8callback_2stop(struct PyGeventCallbackObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("stop", 0); + + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->callback); + __Pyx_DECREF(__pyx_v_self->callback); + __pyx_v_self->callback = Py_None; + + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = ((PyObject*)Py_None); + + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_8callback_5__nonzero__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_8callback_5__nonzero__(PyObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__nonzero__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_8callback_4__nonzero__(((struct PyGeventCallbackObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_8callback_4__nonzero__(struct PyGeventCallbackObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("__nonzero__", 0); + + __pyx_t_1 = (__pyx_v_self->args != ((PyObject*)Py_None)); + __pyx_r = __pyx_t_1; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_8callback_7pending_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_8callback_7pending_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_8callback_7pending___get__(((struct PyGeventCallbackObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_8callback_7pending___get__(struct PyGeventCallbackObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = (__pyx_v_self->callback != Py_None); + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 651, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.callback.pending.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_8callback_7__repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_8callback_7__repr__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_8callback_6__repr__(((struct PyGeventCallbackObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_8callback_6__repr__(struct PyGeventCallbackObject *__pyx_v_self) { + PyObject *__pyx_v_format = NULL; + PyObject *__pyx_v_result = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_t_7; + int __pyx_t_8; + char const *__pyx_t_9; + PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11 = NULL; + PyObject *__pyx_t_12 = NULL; + PyObject *__pyx_t_13 = NULL; + PyObject *__pyx_t_14 = NULL; + PyObject *__pyx_t_15 = NULL; + __Pyx_RefNannySetupContext("__repr__", 0); + + __pyx_t_1 = ((Py_ReprEnter(((PyObject*)__pyx_v_self)) != 0) != 0); + if (__pyx_t_1) { + + __Pyx_XDECREF(__pyx_r); +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __Pyx_INCREF(__pyx_kp_s__27); + __pyx_r = __pyx_kp_s__27; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __Pyx_INCREF(__pyx_kp_s__21); + __pyx_r = __pyx_kp_s__21; +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_INCREF(__pyx_kp_s__26); + __pyx_r = __pyx_kp_s__26; +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + goto __pyx_L0; + + } + + /*try:*/ { + + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 657, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 657, __pyx_L5_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 657, __pyx_L5_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_format = __pyx_t_2; + __pyx_t_2 = 0; + + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 658, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 658, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 658, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + PyTuple_SET_ITEM(__pyx_t_2, 0, ((PyObject *)__pyx_v_self)); + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_id, __pyx_t_2, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 658, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 658, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_4); + __Pyx_INCREF(__pyx_v_format); + __Pyx_GIVEREF(__pyx_v_format); + PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_v_format); + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_s_at_0x_x_s_2, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 658, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_result = ((PyObject*)__pyx_t_4); + __pyx_t_4 = 0; + + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_pending); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 659, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 659, __pyx_L5_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_1) { + + __pyx_t_4 = PyNumber_InPlaceAdd(__pyx_v_result, __pyx_kp_s_pending_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 660, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF_SET(__pyx_v_result, ((PyObject*)__pyx_t_4)); + __pyx_t_4 = 0; + + } + + __pyx_t_1 = (__pyx_v_self->callback != Py_None); + __pyx_t_5 = (__pyx_t_1 != 0); + if (__pyx_t_5) { + + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 662, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_v_self->callback); + __Pyx_GIVEREF(__pyx_v_self->callback); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_self->callback); + __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_callback_r, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 662, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyNumber_InPlaceAdd(__pyx_v_result, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 662, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF_SET(__pyx_v_result, ((PyObject*)__pyx_t_4)); + __pyx_t_4 = 0; + + } + + __pyx_t_5 = (__pyx_v_self->args != ((PyObject*)Py_None)); + __pyx_t_1 = (__pyx_t_5 != 0); + if (__pyx_t_1) { + + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 664, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_v_self->args); + __Pyx_GIVEREF(__pyx_v_self->args); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_self->args); + __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_args_r, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 664, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyNumber_InPlaceAdd(__pyx_v_result, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 664, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF_SET(__pyx_v_result, ((PyObject*)__pyx_t_4)); + __pyx_t_4 = 0; + + } + + __pyx_t_5 = (__pyx_v_self->callback == Py_None); + __pyx_t_6 = (__pyx_t_5 != 0); + if (__pyx_t_6) { + } else { + __pyx_t_1 = __pyx_t_6; + goto __pyx_L11_bool_binop_done; + } + __pyx_t_6 = (__pyx_v_self->args == ((PyObject*)Py_None)); + __pyx_t_5 = (__pyx_t_6 != 0); + __pyx_t_1 = __pyx_t_5; + __pyx_L11_bool_binop_done:; + if (__pyx_t_1) { + + __pyx_t_4 = PyNumber_InPlaceAdd(__pyx_v_result, __pyx_kp_s_stopped); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 666, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF_SET(__pyx_v_result, ((PyObject*)__pyx_t_4)); + __pyx_t_4 = 0; + + } + + __Pyx_XDECREF(__pyx_r); +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_4 = PyNumber_Add(__pyx_v_result, __pyx_kp_s__28); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 667, __pyx_L5_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_4 = PyNumber_Add(__pyx_v_result, __pyx_kp_s__22); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 667, __pyx_L5_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_4 = PyNumber_Add(__pyx_v_result, __pyx_kp_s__27); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 667, __pyx_L5_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_4); + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L4_return; + } + + /*finally:*/ { + /*exception exit:*/{ + __Pyx_PyThreadState_declare + __pyx_L5_error:; + __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; + __Pyx_PyThreadState_assign + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_13, &__pyx_t_14, &__pyx_t_15); + if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_10, &__pyx_t_11, &__pyx_t_12) < 0)) __Pyx_ErrFetch(&__pyx_t_10, &__pyx_t_11, &__pyx_t_12); + __Pyx_XGOTREF(__pyx_t_10); + __Pyx_XGOTREF(__pyx_t_11); + __Pyx_XGOTREF(__pyx_t_12); + __Pyx_XGOTREF(__pyx_t_13); + __Pyx_XGOTREF(__pyx_t_14); + __Pyx_XGOTREF(__pyx_t_15); + __pyx_t_7 = __pyx_lineno; __pyx_t_8 = __pyx_clineno; __pyx_t_9 = __pyx_filename; + { + Py_ReprLeave(((PyObject*)__pyx_v_self)); + } + __Pyx_PyThreadState_assign + if (PY_MAJOR_VERSION >= 3) { + __Pyx_XGIVEREF(__pyx_t_13); + __Pyx_XGIVEREF(__pyx_t_14); + __Pyx_XGIVEREF(__pyx_t_15); + __Pyx_ExceptionReset(__pyx_t_13, __pyx_t_14, __pyx_t_15); + } + __Pyx_XGIVEREF(__pyx_t_10); + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_XGIVEREF(__pyx_t_12); + __Pyx_ErrRestore(__pyx_t_10, __pyx_t_11, __pyx_t_12); + __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; + __pyx_lineno = __pyx_t_7; __pyx_clineno = __pyx_t_8; __pyx_filename = __pyx_t_9; + goto __pyx_L1_error; + } + __pyx_L4_return: { + __pyx_t_15 = __pyx_r; + __pyx_r = 0; + Py_ReprLeave(((PyObject*)__pyx_v_self)); + __pyx_r = __pyx_t_15; + __pyx_t_15 = 0; + goto __pyx_L0; + } + } + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("gevent.libev.corecext.callback.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_format); + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_8callback_9_format(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_8callback_9_format(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_format (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_8callback_8_format(((struct PyGeventCallbackObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_8callback_8_format(CYTHON_UNUSED struct PyGeventCallbackObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_format", 0); + + __Pyx_XDECREF(__pyx_r); +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __Pyx_INCREF(__pyx_kp_s__23); + __pyx_r = __pyx_kp_s__23; +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_INCREF(__pyx_kp_s__21); + __pyx_r = __pyx_kp_s__21; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_8callback_8callback_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_8callback_8callback_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_8callback_8callback___get__(((struct PyGeventCallbackObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_8callback_8callback___get__(struct PyGeventCallbackObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->callback); + __pyx_r = __pyx_v_self->callback; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_8callback_8callback_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_8callback_8callback_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_8callback_8callback_2__set__(((struct PyGeventCallbackObject *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_8callback_8callback_2__set__(struct PyGeventCallbackObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __Pyx_INCREF(__pyx_v_value); + __Pyx_GIVEREF(__pyx_v_value); + __Pyx_GOTREF(__pyx_v_self->callback); + __Pyx_DECREF(__pyx_v_self->callback); + __pyx_v_self->callback = __pyx_v_value; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_8callback_8callback_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_8callback_8callback_5__del__(PyObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_8callback_8callback_4__del__(((struct PyGeventCallbackObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_8callback_8callback_4__del__(struct PyGeventCallbackObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 0); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->callback); + __Pyx_DECREF(__pyx_v_self->callback); + __pyx_v_self->callback = Py_None; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_8callback_4args_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_8callback_4args_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_8callback_4args___get__(((struct PyGeventCallbackObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_8callback_4args___get__(struct PyGeventCallbackObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->args); + __pyx_r = __pyx_v_self->args; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_8callback_4args_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_8callback_4args_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_8callback_4args_2__set__(((struct PyGeventCallbackObject *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_8callback_4args_2__set__(struct PyGeventCallbackObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__set__", 0); + if (!(likely(PyTuple_CheckExact(__pyx_v_value))||((__pyx_v_value) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v_value)->tp_name), 0))) __PYX_ERR(0, 629, __pyx_L1_error) + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.callback.args.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_8callback_4args_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_8callback_4args_5__del__(PyObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_8callback_4args_4__del__(((struct PyGeventCallbackObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_8callback_4args_4__del__(struct PyGeventCallbackObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 0); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = ((PyObject*)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_7watcher_1__repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_7watcher_1__repr__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_7watcher___repr__(((struct PyGeventWatcherObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_7watcher___repr__(struct PyGeventWatcherObject *__pyx_v_self) { + PyObject *__pyx_v_format = NULL; + PyObject *__pyx_v_result = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_t_7; + char const *__pyx_t_8; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11 = NULL; + PyObject *__pyx_t_12 = NULL; + PyObject *__pyx_t_13 = NULL; + PyObject *__pyx_t_14 = NULL; + __Pyx_RefNannySetupContext("__repr__", 0); + + __pyx_t_1 = ((Py_ReprEnter(((PyObject*)__pyx_v_self)) != 0) != 0); + if (__pyx_t_1) { + + __Pyx_XDECREF(__pyx_r); +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __Pyx_INCREF(__pyx_kp_s__27); + __pyx_r = __pyx_kp_s__27; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __Pyx_INCREF(__pyx_kp_s__21); + __pyx_r = __pyx_kp_s__21; +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_INCREF(__pyx_kp_s__26); + __pyx_r = __pyx_kp_s__26; +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + goto __pyx_L0; + + } + + /*try:*/ { + + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 702, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 702, __pyx_L5_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 702, __pyx_L5_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_format = __pyx_t_2; + __pyx_t_2 = 0; + + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 703, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 703, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 703, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + PyTuple_SET_ITEM(__pyx_t_2, 0, ((PyObject *)__pyx_v_self)); + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_id, __pyx_t_2, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 703, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 703, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_4); + __Pyx_INCREF(__pyx_v_format); + __Pyx_GIVEREF(__pyx_v_format); + PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_v_format); + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_s_at_0x_x_s_2, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 703, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_result = ((PyObject*)__pyx_t_4); + __pyx_t_4 = 0; + + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_active); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 704, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 704, __pyx_L5_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_1) { + + __pyx_t_4 = PyNumber_InPlaceAdd(__pyx_v_result, __pyx_kp_s_active_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 705, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF_SET(__pyx_v_result, ((PyObject*)__pyx_t_4)); + __pyx_t_4 = 0; + + } + + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_pending); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 706, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 706, __pyx_L5_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_1) { + + __pyx_t_4 = PyNumber_InPlaceAdd(__pyx_v_result, __pyx_kp_s_pending_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 707, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF_SET(__pyx_v_result, ((PyObject*)__pyx_t_4)); + __pyx_t_4 = 0; + + } + + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_callback); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 708, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = (__pyx_t_4 != Py_None); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_5 = (__pyx_t_1 != 0); + if (__pyx_t_5) { + + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_callback); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 709, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 709, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_callback_r, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 709, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyNumber_InPlaceAdd(__pyx_v_result, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 709, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF_SET(__pyx_v_result, ((PyObject*)__pyx_t_2)); + __pyx_t_2 = 0; + + } + + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_args); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 710, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = (__pyx_t_2 != Py_None); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_1 = (__pyx_t_5 != 0); + if (__pyx_t_1) { + + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_args); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 711, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 711, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_args_r, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 711, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyNumber_InPlaceAdd(__pyx_v_result, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 711, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF_SET(__pyx_v_result, ((PyObject*)__pyx_t_4)); + __pyx_t_4 = 0; + + } + + __Pyx_XDECREF(__pyx_r); +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_4 = PyNumber_Add(__pyx_v_result, __pyx_kp_s__28); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 712, __pyx_L5_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_4 = PyNumber_Add(__pyx_v_result, __pyx_kp_s__22); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 712, __pyx_L5_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_4 = PyNumber_Add(__pyx_v_result, __pyx_kp_s__27); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 712, __pyx_L5_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_4); + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L4_return; + } + + /*finally:*/ { + /*exception exit:*/{ + __Pyx_PyThreadState_declare + __pyx_L5_error:; + __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; + __Pyx_PyThreadState_assign + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14); + if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11) < 0)) __Pyx_ErrFetch(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); + __Pyx_XGOTREF(__pyx_t_9); + __Pyx_XGOTREF(__pyx_t_10); + __Pyx_XGOTREF(__pyx_t_11); + __Pyx_XGOTREF(__pyx_t_12); + __Pyx_XGOTREF(__pyx_t_13); + __Pyx_XGOTREF(__pyx_t_14); + __pyx_t_6 = __pyx_lineno; __pyx_t_7 = __pyx_clineno; __pyx_t_8 = __pyx_filename; + { + Py_ReprLeave(((PyObject*)__pyx_v_self)); + } + __Pyx_PyThreadState_assign + if (PY_MAJOR_VERSION >= 3) { + __Pyx_XGIVEREF(__pyx_t_12); + __Pyx_XGIVEREF(__pyx_t_13); + __Pyx_XGIVEREF(__pyx_t_14); + __Pyx_ExceptionReset(__pyx_t_12, __pyx_t_13, __pyx_t_14); + } + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_XGIVEREF(__pyx_t_10); + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_ErrRestore(__pyx_t_9, __pyx_t_10, __pyx_t_11); + __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; + __pyx_lineno = __pyx_t_6; __pyx_clineno = __pyx_t_7; __pyx_filename = __pyx_t_8; + goto __pyx_L1_error; + } + __pyx_L4_return: { + __pyx_t_14 = __pyx_r; + __pyx_r = 0; + Py_ReprLeave(((PyObject*)__pyx_v_self)); + __pyx_r = __pyx_t_14; + __pyx_t_14 = 0; + goto __pyx_L0; + } + } + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("gevent.libev.corecext.watcher.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_format); + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_7watcher_3_format(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_7watcher_3_format(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_format (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_7watcher_2_format(((struct PyGeventWatcherObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_7watcher_2_format(CYTHON_UNUSED struct PyGeventWatcherObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_format", 0); + + __Pyx_XDECREF(__pyx_r); +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __Pyx_INCREF(__pyx_kp_s__23); + __pyx_r = __pyx_kp_s__23; +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_INCREF(__pyx_kp_s__21); + __pyx_r = __pyx_kp_s__21; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_2io_3ref_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_2io_3ref_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_2io_3ref___get__(((struct PyGeventIOObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_2io_3ref___get__(struct PyGeventIOObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + if (((__pyx_v_self->_flags & 4) != 0)) { + __Pyx_INCREF(Py_False); + __pyx_t_1 = Py_False; + } else { + __Pyx_INCREF(Py_True); + __pyx_t_1 = Py_True; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_2io_3ref_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_2io_3ref_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_2io_3ref_2__set__(((struct PyGeventIOObject *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_2io_3ref_2__set__(struct PyGeventIOObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + __Pyx_RefNannySetupContext("__set__", 0); + + __pyx_t_1 = ((!(__pyx_v_self->loop->_ptr != 0)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__29, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 737, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__24, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 737, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__28, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 737, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 737, __pyx_L1_error) + + } + + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_value); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 738, __pyx_L1_error) + if (__pyx_t_1) { + + __pyx_t_1 = ((!((__pyx_v_self->_flags & 4) != 0)) != 0); + if (__pyx_t_1) { + + __pyx_r = 0; + goto __pyx_L0; + + } + + __pyx_t_1 = ((__pyx_v_self->_flags & 2) != 0); + if (__pyx_t_1) { + + ev_ref(__pyx_v_self->loop->_ptr); + + } + + __pyx_v_self->_flags = (__pyx_v_self->_flags & (~6)); + + goto __pyx_L4; + } + + /*else*/ { + __pyx_t_1 = ((__pyx_v_self->_flags & 4) != 0); + if (__pyx_t_1) { + + __pyx_r = 0; + goto __pyx_L0; + + } + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 4); + + __pyx_t_3 = ((!((__pyx_v_self->_flags & 2) != 0)) != 0); + if (__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L9_bool_binop_done; + } + __pyx_t_3 = (ev_is_active((&__pyx_v_self->_watcher)) != 0); + __pyx_t_1 = __pyx_t_3; + __pyx_L9_bool_binop_done:; + if (__pyx_t_1) { + + ev_unref(__pyx_v_self->loop->_ptr); + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 2); + + } + } + __pyx_L4:; + + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.io.ref.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_2io_8callback_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_2io_8callback_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_2io_8callback___get__(((struct PyGeventIOObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_2io_8callback___get__(struct PyGeventIOObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->_callback); + __pyx_r = __pyx_v_self->_callback; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_2io_8callback_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_callback); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_2io_8callback_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_callback) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_2io_8callback_2__set__(((struct PyGeventIOObject *)__pyx_v_self), ((PyObject *)__pyx_v_callback)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_2io_8callback_2__set__(struct PyGeventIOObject *__pyx_v_self, PyObject *__pyx_v_callback) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + __Pyx_RefNannySetupContext("__set__", 0); + + __pyx_t_2 = ((!(PyCallable_Check(((PyObject*)__pyx_v_callback)) != 0)) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_2 = (__pyx_v_callback != Py_None); + __pyx_t_3 = (__pyx_t_2 != 0); + __pyx_t_1 = __pyx_t_3; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { + + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 759, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_v_callback); + __Pyx_GIVEREF(__pyx_v_callback); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_callback); + __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_Expected_callable_not_r, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 759, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 759, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 759, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_5, 0, 0, 0); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __PYX_ERR(0, 759, __pyx_L1_error) + + } + + __Pyx_INCREF(__pyx_v_callback); + __Pyx_GIVEREF(__pyx_v_callback); + __Pyx_GOTREF(__pyx_v_self->_callback); + __Pyx_DECREF(__pyx_v_self->_callback); + __pyx_v_self->_callback = __pyx_v_callback; + + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("gevent.libev.corecext.io.callback.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_2io_1stop(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_2io_1stop(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("stop (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_2io_stop(((struct PyGeventIOObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_2io_stop(struct PyGeventIOObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("stop", 0); + + __pyx_t_1 = ((!(__pyx_v_self->loop->_ptr != 0)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__30, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 765, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__25, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 765, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__29, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 765, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 765, __pyx_L1_error) + + } + + __pyx_t_1 = ((__pyx_v_self->_flags & 2) != 0); + if (__pyx_t_1) { + + ev_ref(__pyx_v_self->loop->_ptr); + + __pyx_v_self->_flags = (__pyx_v_self->_flags & (~2)); + + } + + ev_io_stop(__pyx_v_self->loop->_ptr, (&__pyx_v_self->_watcher)); + + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->_callback); + __Pyx_DECREF(__pyx_v_self->_callback); + __pyx_v_self->_callback = Py_None; + + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = ((PyObject*)Py_None); + + __pyx_t_1 = ((__pyx_v_self->_flags & 1) != 0); + if (__pyx_t_1) { + + Py_DECREF(((PyObject*)__pyx_v_self)); + + __pyx_v_self->_flags = (__pyx_v_self->_flags & (~1)); + + } + + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.io.stop", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_2io_8priority_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_2io_8priority_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_2io_8priority___get__(((struct PyGeventIOObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_2io_8priority___get__(struct PyGeventIOObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(ev_priority((&__pyx_v_self->_watcher))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 779, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.io.priority.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_2io_8priority_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_priority); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_2io_8priority_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_priority) { + int __pyx_v_priority; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_priority); { + __pyx_v_priority = __Pyx_PyInt_As_int(__pyx_arg_priority); if (unlikely((__pyx_v_priority == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 781, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.libev.corecext.io.priority.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_2io_8priority_2__set__(((struct PyGeventIOObject *)__pyx_v_self), ((int)__pyx_v_priority)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_2io_8priority_2__set__(struct PyGeventIOObject *__pyx_v_self, int __pyx_v_priority) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("__set__", 0); + + __pyx_t_1 = (ev_is_active((&__pyx_v_self->_watcher)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__31, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 783, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__26, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 783, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__30, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 783, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 783, __pyx_L1_error) + + } + + ev_set_priority((&__pyx_v_self->_watcher), __pyx_v_priority); + + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.io.priority.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_2io_3feed(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_2io_3feed(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + int __pyx_v_revents; + PyObject *__pyx_v_callback = 0; + PyObject *__pyx_v_args = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("feed (wrapper)", 0); + if (PyTuple_GET_SIZE(__pyx_args) > 2) { + __pyx_v_args = PyTuple_GetSlice(__pyx_args, 2, PyTuple_GET_SIZE(__pyx_args)); + if (unlikely(!__pyx_v_args)) { + __Pyx_RefNannyFinishContext(); + return NULL; + } + __Pyx_GOTREF(__pyx_v_args); + } else { + __pyx_v_args = __pyx_empty_tuple; __Pyx_INCREF(__pyx_empty_tuple); + } + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_revents,&__pyx_n_s_callback,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + default: + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_revents)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_callback)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("feed", 0, 2, 2, 1); __PYX_ERR(0, 786, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t used_pos_args = (pos_args < 2) ? pos_args : 2; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, used_pos_args, "feed") < 0)) __PYX_ERR(0, 786, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) < 2) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + } + __pyx_v_revents = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_revents == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 786, __pyx_L3_error) + __pyx_v_callback = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("feed", 0, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 786, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0; + __Pyx_AddTraceback("gevent.libev.corecext.io.feed", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_2io_2feed(((struct PyGeventIOObject *)__pyx_v_self), __pyx_v_revents, __pyx_v_callback, __pyx_v_args); + + /* function exit code */ + __Pyx_XDECREF(__pyx_v_args); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_2io_2feed(struct PyGeventIOObject *__pyx_v_self, int __pyx_v_revents, PyObject *__pyx_v_callback, PyObject *__pyx_v_args) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("feed", 0); + + __pyx_t_1 = ((!(__pyx_v_self->loop->_ptr != 0)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__32, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 789, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__27, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 789, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__31, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 789, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 789, __pyx_L1_error) + + } + + if (__Pyx_PyObject_SetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_callback, __pyx_v_callback) < 0) __PYX_ERR(0, 790, __pyx_L1_error) + + __Pyx_INCREF(__pyx_v_args); + __Pyx_GIVEREF(__pyx_v_args); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = __pyx_v_args; + + __pyx_t_1 = (((__pyx_v_self->_flags & 6) == 4) != 0); + if (__pyx_t_1) { + + ev_unref(__pyx_v_self->loop->_ptr); + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 2); + + } + + ev_feed_event(__pyx_v_self->loop->_ptr, (&__pyx_v_self->_watcher), __pyx_v_revents); + + __pyx_t_1 = ((!((__pyx_v_self->_flags & 1) != 0)) != 0); + if (__pyx_t_1) { + + Py_INCREF(((PyObject*)__pyx_v_self)); + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 1); + + } + + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.io.feed", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_2io_5start(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_2io_5start(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_callback = 0; + PyObject *__pyx_v_pass_events = 0; + PyObject *__pyx_v_args = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("start (wrapper)", 0); + if (PyTuple_GET_SIZE(__pyx_args) > 1) { + __pyx_v_args = PyTuple_GetSlice(__pyx_args, 1, PyTuple_GET_SIZE(__pyx_args)); + if (unlikely(!__pyx_v_args)) { + __Pyx_RefNannyFinishContext(); + return NULL; + } + __Pyx_GOTREF(__pyx_v_args); + } else { + __pyx_v_args = __pyx_empty_tuple; __Pyx_INCREF(__pyx_empty_tuple); + } + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_callback,&__pyx_n_s_pass_events,0}; + PyObject* values[2] = {0,0}; + values[1] = ((PyObject *)Py_False); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + default: + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_callback)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + } + if (kw_args == 1) { + const Py_ssize_t index = 1; + PyObject* value = PyDict_GetItem(__pyx_kwds, *__pyx_pyargnames[index]); + if (value) { values[index] = value; kw_args--; } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t used_pos_args = (pos_args < 1) ? pos_args : 1; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, used_pos_args, "start") < 0)) __PYX_ERR(0, 800, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) < 1) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + } + __pyx_v_callback = values[0]; + __pyx_v_pass_events = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("start", 0, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 800, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0; + __Pyx_AddTraceback("gevent.libev.corecext.io.start", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_2io_4start(((struct PyGeventIOObject *)__pyx_v_self), __pyx_v_callback, __pyx_v_pass_events, __pyx_v_args); + + /* function exit code */ + __Pyx_XDECREF(__pyx_v_args); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_2io_4start(struct PyGeventIOObject *__pyx_v_self, PyObject *__pyx_v_callback, PyObject *__pyx_v_pass_events, PyObject *__pyx_v_args) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + __Pyx_RefNannySetupContext("start", 0); + + __pyx_t_1 = ((!(__pyx_v_self->loop->_ptr != 0)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__33, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 803, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__28, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 803, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__32, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 803, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 803, __pyx_L1_error) + + } + + __pyx_t_1 = (__pyx_v_callback == Py_None); + __pyx_t_3 = (__pyx_t_1 != 0); + if (__pyx_t_3) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__34, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 805, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__29, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 805, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__33, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 805, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 805, __pyx_L1_error) + + } + + if (__Pyx_PyObject_SetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_callback, __pyx_v_callback) < 0) __PYX_ERR(0, 806, __pyx_L1_error) + + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_pass_events); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 807, __pyx_L1_error) + if (__pyx_t_3) { + + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 808, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(GEVENT_CORE_EVENTS); + __Pyx_GIVEREF(GEVENT_CORE_EVENTS); + PyTuple_SET_ITEM(__pyx_t_2, 0, GEVENT_CORE_EVENTS); + __pyx_t_4 = PyNumber_Add(__pyx_t_2, __pyx_v_args); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 808, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GIVEREF(__pyx_t_4); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = ((PyObject*)__pyx_t_4); + __pyx_t_4 = 0; + + goto __pyx_L5; + } + + /*else*/ { + __Pyx_INCREF(__pyx_v_args); + __Pyx_GIVEREF(__pyx_v_args); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = __pyx_v_args; + } + __pyx_L5:; + + __pyx_t_3 = (((__pyx_v_self->_flags & 6) == 4) != 0); + if (__pyx_t_3) { + + ev_unref(__pyx_v_self->loop->_ptr); + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 2); + + } + + ev_io_start(__pyx_v_self->loop->_ptr, (&__pyx_v_self->_watcher)); + + __pyx_t_3 = ((!((__pyx_v_self->_flags & 1) != 0)) != 0); + if (__pyx_t_3) { + + Py_INCREF(((PyObject*)__pyx_v_self)); + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 1); + + } + + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("gevent.libev.corecext.io.start", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_2io_6active_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_2io_6active_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_2io_6active___get__(((struct PyGeventIOObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_2io_6active___get__(struct PyGeventIOObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + if ((ev_is_active((&__pyx_v_self->_watcher)) != 0)) { + __Pyx_INCREF(Py_True); + __pyx_t_1 = Py_True; + } else { + __Pyx_INCREF(Py_False); + __pyx_t_1 = Py_False; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_2io_7pending_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_2io_7pending_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_2io_7pending___get__(((struct PyGeventIOObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_2io_7pending___get__(struct PyGeventIOObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + if ((ev_is_pending((&__pyx_v_self->_watcher)) != 0)) { + __Pyx_INCREF(Py_True); + __pyx_t_1 = Py_True; + } else { + __Pyx_INCREF(Py_False); + __pyx_t_1 = Py_False; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_2io_7__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_2io_7__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + struct PyGeventLoopObject *__pyx_v_loop = 0; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + vfd_socket_t __pyx_v_fd; +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + int __pyx_v_fd; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + vfd_socket_t __pyx_v_fd; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + int __pyx_v_events; + PyObject *__pyx_v_ref = 0; + PyObject *__pyx_v_priority = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_loop,&__pyx_n_s_fd,&__pyx_n_s_events_2,&__pyx_n_s_ref,&__pyx_n_s_priority,0}; + PyObject* values[5] = {0,0,0,0,0}; + values[3] = ((PyObject *)Py_True); + values[4] = ((PyObject *)Py_None); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_loop)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_fd)) != 0)) kw_args--; + else { +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __Pyx_RaiseArgtupleInvalid("__init__", 0, 3, 5, 1); __PYX_ERR(0, 832, __pyx_L3_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_RaiseArgtupleInvalid("__init__", 0, 3, 5, 1); __PYX_ERR(0, 848, __pyx_L3_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __Pyx_RaiseArgtupleInvalid("__init__", 0, 3, 5, 1); __PYX_ERR(0, 832, __pyx_L3_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + } + case 2: + if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_events_2)) != 0)) kw_args--; + else { +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __Pyx_RaiseArgtupleInvalid("__init__", 0, 3, 5, 2); __PYX_ERR(0, 832, __pyx_L3_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_RaiseArgtupleInvalid("__init__", 0, 3, 5, 2); __PYX_ERR(0, 848, __pyx_L3_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __Pyx_RaiseArgtupleInvalid("__init__", 0, 3, 5, 2); __PYX_ERR(0, 832, __pyx_L3_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + } + case 3: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ref); + if (value) { values[3] = value; kw_args--; } + } + case 4: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_priority); + if (value) { values[4] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 832, __pyx_L3_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 848, __pyx_L3_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 832, __pyx_L3_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_loop = ((struct PyGeventLoopObject *)values[0]); +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_v_fd = __Pyx_PyInt_As_vfd_socket_t(values[1]); if (unlikely((__pyx_v_fd == ((vfd_socket_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 832, __pyx_L3_error) + __pyx_v_events = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_events == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 832, __pyx_L3_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_v_fd = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_fd == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 848, __pyx_L3_error) + __pyx_v_events = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_events == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 848, __pyx_L3_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_v_fd = __Pyx_PyInt_As_vfd_socket_t(values[1]); if (unlikely((__pyx_v_fd == ((vfd_socket_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 832, __pyx_L3_error) + __pyx_v_events = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_events == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 832, __pyx_L3_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_v_ref = values[3]; + __pyx_v_priority = values[4]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __Pyx_RaiseArgtupleInvalid("__init__", 0, 3, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 832, __pyx_L3_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_RaiseArgtupleInvalid("__init__", 0, 3, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 848, __pyx_L3_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __Pyx_RaiseArgtupleInvalid("__init__", 0, 3, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 832, __pyx_L3_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.libev.corecext.io.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_loop), __pyx_ptype_6gevent_5libev_8corecext_loop, 1, "loop", 0))) __PYX_ERR(0, 832, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_loop), __pyx_ptype_6gevent_5libev_8corecext_loop, 1, "loop", 0))) __PYX_ERR(0, 848, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_loop), __pyx_ptype_6gevent_5libev_8corecext_loop, 1, "loop", 0))) __PYX_ERR(0, 832, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_2io_6__init__(((struct PyGeventIOObject *)__pyx_v_self), __pyx_v_loop, __pyx_v_fd, __pyx_v_events, __pyx_v_ref, __pyx_v_priority); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) +static int __pyx_pf_6gevent_5libev_8corecext_2io_6__init__(struct PyGeventIOObject *__pyx_v_self, struct PyGeventLoopObject *__pyx_v_loop, int __pyx_v_fd, int __pyx_v_events, PyObject *__pyx_v_ref, PyObject *__pyx_v_priority) { +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) +static int __pyx_pf_6gevent_5libev_8corecext_2io_6__init__(struct PyGeventIOObject *__pyx_v_self, struct PyGeventLoopObject *__pyx_v_loop, vfd_socket_t __pyx_v_fd, int __pyx_v_events, PyObject *__pyx_v_ref, PyObject *__pyx_v_priority) { + int __pyx_v_vfd; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static int __pyx_pf_6gevent_5libev_8corecext_2io_6__init__(struct PyGeventIOObject *__pyx_v_self, struct PyGeventLoopObject *__pyx_v_loop, int __pyx_v_fd, int __pyx_v_events, PyObject *__pyx_v_ref, PyObject *__pyx_v_priority) { +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + __Pyx_RefNannySetupContext("__init__", 0); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_1 = ((__pyx_v_events & (~((EV__IOFDSET | EV_READ) | EV_WRITE))) != 0); +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_1 = ((__pyx_v_fd < 0) != 0); +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_1 = ((__pyx_v_events & (~((EV__IOFDSET | EV_READ) | EV_WRITE))) != 0); +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_events); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 834, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_fd); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 850, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_events); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 834, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_illegal_event_mask_r, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 834, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_fd_must_be_non_negative_r, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 850, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_illegal_event_mask_r, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 834, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 834, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 850, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 834, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3); + __pyx_t_3 = 0; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 834, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 850, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 834, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __PYX_ERR(0, 834, __pyx_L1_error) + + } + + __pyx_t_4 = vfd_open(__pyx_v_fd); if (unlikely(__pyx_t_4 == -1)) __PYX_ERR(0, 835, __pyx_L1_error) + __pyx_v_vfd = __pyx_t_4; + + vfd_free(__pyx_v_self->_watcher.fd); + + ev_io_init((&__pyx_v_self->_watcher), ((void *)gevent_callback_io), __pyx_v_vfd, __pyx_v_events); +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __PYX_ERR(0, 850, __pyx_L1_error) + + } + + __pyx_t_1 = ((__pyx_v_events & (~((EV__IOFDSET | EV_READ) | EV_WRITE))) != 0); + if (__pyx_t_1) { + + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_events); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 852, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_illegal_event_mask_r, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 852, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 852, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 852, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 852, __pyx_L1_error) + + } + + ev_io_init((&__pyx_v_self->_watcher), ((void *)gevent_callback_io), __pyx_v_fd, __pyx_v_events); +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __PYX_ERR(0, 834, __pyx_L1_error) + + } + + __pyx_t_4 = vfd_open(__pyx_v_fd); if (unlikely(__pyx_t_4 == -1)) __PYX_ERR(0, 835, __pyx_L1_error) + __pyx_v_vfd = __pyx_t_4; + + vfd_free(__pyx_v_self->_watcher.fd); + + ev_io_init((&__pyx_v_self->_watcher), ((void *)gevent_callback_io), __pyx_v_vfd, __pyx_v_events); +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + + __Pyx_INCREF(((PyObject *)__pyx_v_loop)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_loop)); + __Pyx_GOTREF(__pyx_v_self->loop); + __Pyx_DECREF(((PyObject *)__pyx_v_self->loop)); + __pyx_v_self->loop = __pyx_v_loop; + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_ref); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 839, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_ref); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 855, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_ref); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 839, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + if (__pyx_t_1) { + + __pyx_v_self->_flags = 0; + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + goto __pyx_L4; +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + goto __pyx_L5; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + goto __pyx_L4; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + } + + /*else*/ { + __pyx_v_self->_flags = 4; + } +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_L4:; +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_L5:; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_L4:; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + + __pyx_t_1 = (__pyx_v_priority != Py_None); +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_5 = (__pyx_t_1 != 0); + if (__pyx_t_5) { + + __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_v_priority); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 844, __pyx_L1_error) + ev_set_priority((&__pyx_v_self->_watcher), __pyx_t_4); +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_4 = (__pyx_t_1 != 0); + if (__pyx_t_4) { + + __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_v_priority); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 860, __pyx_L1_error) + ev_set_priority((&__pyx_v_self->_watcher), __pyx_t_5); +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_5 = (__pyx_t_1 != 0); + if (__pyx_t_5) { + + __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_v_priority); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 844, __pyx_L1_error) + ev_set_priority((&__pyx_v_self->_watcher), __pyx_t_4); +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + + } + + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("gevent.libev.corecext.io.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_2io_2fd_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_2io_2fd_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_2io_2fd___get__(((struct PyGeventIOObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_2io_2fd___get__(struct PyGeventIOObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(vfd_get(__pyx_v_self->_watcher.fd)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 867, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.io.fd.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_2io_2fd_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_fd); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_2io_2fd_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_fd) { + long __pyx_v_fd; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_fd); { + __pyx_v_fd = __Pyx_PyInt_As_long(__pyx_arg_fd); if (unlikely((__pyx_v_fd == (long)-1) && PyErr_Occurred())) __PYX_ERR(0, 869, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.libev.corecext.io.fd.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_2io_2fd_2__set__(((struct PyGeventIOObject *)__pyx_v_self), ((long)__pyx_v_fd)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_2io_2fd_2__set__(struct PyGeventIOObject *__pyx_v_self, long __pyx_v_fd) { + int __pyx_v_vfd; + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + __Pyx_RefNannySetupContext("__set__", 0); + + __pyx_t_1 = (ev_is_active((&__pyx_v_self->_watcher)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__35, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 871, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__30, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 871, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__34, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 871, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 871, __pyx_L1_error) + + } + + __pyx_t_3 = vfd_open(__pyx_v_fd); if (unlikely(__pyx_t_3 == -1)) __PYX_ERR(0, 872, __pyx_L1_error) + __pyx_v_vfd = __pyx_t_3; + + vfd_free(__pyx_v_self->_watcher.fd); + + ev_io_init((&__pyx_v_self->_watcher), ((void *)gevent_callback_io), __pyx_v_vfd, __pyx_v_self->_watcher.events); + + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.io.fd.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_2io_6events_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_2io_6events_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_2io_6events___get__(((struct PyGeventIOObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_2io_6events___get__(struct PyGeventIOObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->_watcher.events); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 879, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.io.events.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_2io_6events_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_events); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_2io_6events_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_events) { + int __pyx_v_events; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_events); { + __pyx_v_events = __Pyx_PyInt_As_int(__pyx_arg_events); if (unlikely((__pyx_v_events == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 881, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.libev.corecext.io.events.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_2io_6events_2__set__(((struct PyGeventIOObject *)__pyx_v_self), ((int)__pyx_v_events)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_2io_6events_2__set__(struct PyGeventIOObject *__pyx_v_self, int __pyx_v_events) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("__set__", 0); + + __pyx_t_1 = (ev_is_active((&__pyx_v_self->_watcher)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__36, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 883, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__31, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 883, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__35, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 883, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 883, __pyx_L1_error) + + } + + ev_io_init((&__pyx_v_self->_watcher), ((void *)gevent_callback_io), __pyx_v_self->_watcher.fd, __pyx_v_events); + + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.io.events.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_2io_10events_str_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_2io_10events_str_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_2io_10events_str___get__(((struct PyGeventIOObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_2io_10events_str___get__(struct PyGeventIOObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_6gevent_5libev_8corecext__events_to_str(__pyx_v_self->_watcher.events, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 889, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.io.events_str.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_2io_9_format(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_2io_9_format(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_format (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_2io_8_format(((struct PyGeventIOObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_2io_8_format(struct PyGeventIOObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("_format", 0); + + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_fd); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 892, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_events_str); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 892, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 892, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_fd_s_events_s, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 892, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("gevent.libev.corecext.io._format", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) +} + + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_2io_11__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_2io_11__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) { + __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;} + if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_2io_10__cinit__(((struct PyGeventIOObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_2io_10__cinit__(struct PyGeventIOObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__", 0); + + __pyx_v_self->_watcher.fd = -1; + + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static void __pyx_pw_6gevent_5libev_8corecext_2io_13__dealloc__(PyObject *__pyx_v_self); /*proto*/ +static void __pyx_pw_6gevent_5libev_8corecext_2io_13__dealloc__(PyObject *__pyx_v_self) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_pf_6gevent_5libev_8corecext_2io_12__dealloc__(((struct PyGeventIOObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +static void __pyx_pf_6gevent_5libev_8corecext_2io_12__dealloc__(struct PyGeventIOObject *__pyx_v_self) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__dealloc__", 0); + + vfd_free(__pyx_v_self->_watcher.fd); + + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_2io_4loop_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_2io_4loop_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_2io_4loop___get__(((struct PyGeventIOObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_2io_4loop___get__(struct PyGeventIOObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self->loop)); + __pyx_r = ((PyObject *)__pyx_v_self->loop); + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_2io_4loop_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_2io_4loop_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_2io_4loop_2__set__(((struct PyGeventIOObject *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_2io_4loop_2__set__(struct PyGeventIOObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__set__", 0); + if (!(likely(((__pyx_v_value) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_value, __pyx_ptype_6gevent_5libev_8corecext_loop))))) __PYX_ERR(0, 723, __pyx_L1_error) + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->loop); + __Pyx_DECREF(((PyObject *)__pyx_v_self->loop)); + __pyx_v_self->loop = ((struct PyGeventLoopObject *)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.io.loop.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_2io_4loop_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_2io_4loop_5__del__(PyObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_2io_4loop_4__del__(((struct PyGeventIOObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_2io_4loop_4__del__(struct PyGeventIOObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 0); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->loop); + __Pyx_DECREF(((PyObject *)__pyx_v_self->loop)); + __pyx_v_self->loop = ((struct PyGeventLoopObject *)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_2io_4args_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_2io_4args_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_2io_4args___get__(((struct PyGeventIOObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_2io_4args___get__(struct PyGeventIOObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->args); + __pyx_r = __pyx_v_self->args; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_2io_4args_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_2io_4args_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_2io_4args_2__set__(((struct PyGeventIOObject *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_2io_4args_2__set__(struct PyGeventIOObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__set__", 0); + if (!(likely(PyTuple_CheckExact(__pyx_v_value))||((__pyx_v_value) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v_value)->tp_name), 0))) __PYX_ERR(0, 725, __pyx_L1_error) + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.io.args.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_2io_4args_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_2io_4args_5__del__(PyObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_2io_4args_4__del__(((struct PyGeventIOObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_2io_4args_4__del__(struct PyGeventIOObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 0); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = ((PyObject*)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_2io_6_flags_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_2io_6_flags_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_2io_6_flags___get__(((struct PyGeventIOObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_2io_6_flags___get__(struct PyGeventIOObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 726, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.io._flags.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5timer_3ref_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5timer_3ref_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5timer_3ref___get__(((struct PyGeventTimerObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5timer_3ref___get__(struct PyGeventTimerObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + if (((__pyx_v_self->_flags & 4) != 0)) { + __Pyx_INCREF(Py_False); + __pyx_t_1 = Py_False; + } else { + __Pyx_INCREF(Py_True); + __pyx_t_1 = Py_True; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_5timer_3ref_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_5timer_3ref_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5timer_3ref_2__set__(((struct PyGeventTimerObject *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_5timer_3ref_2__set__(struct PyGeventTimerObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + __Pyx_RefNannySetupContext("__set__", 0); + + __pyx_t_1 = ((!(__pyx_v_self->loop->_ptr != 0)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__37, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 922, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__32, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 922, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__36, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 922, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 922, __pyx_L1_error) + + } + + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_value); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 923, __pyx_L1_error) + if (__pyx_t_1) { + + __pyx_t_1 = ((!((__pyx_v_self->_flags & 4) != 0)) != 0); + if (__pyx_t_1) { + + __pyx_r = 0; + goto __pyx_L0; + + } + + __pyx_t_1 = ((__pyx_v_self->_flags & 2) != 0); + if (__pyx_t_1) { + + ev_ref(__pyx_v_self->loop->_ptr); + + } + + __pyx_v_self->_flags = (__pyx_v_self->_flags & (~6)); + + goto __pyx_L4; + } + + /*else*/ { + __pyx_t_1 = ((__pyx_v_self->_flags & 4) != 0); + if (__pyx_t_1) { + + __pyx_r = 0; + goto __pyx_L0; + + } + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 4); + + __pyx_t_3 = ((!((__pyx_v_self->_flags & 2) != 0)) != 0); + if (__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L9_bool_binop_done; + } + __pyx_t_3 = (ev_is_active((&__pyx_v_self->_watcher)) != 0); + __pyx_t_1 = __pyx_t_3; + __pyx_L9_bool_binop_done:; + if (__pyx_t_1) { + + ev_unref(__pyx_v_self->loop->_ptr); + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 2); + + } + } + __pyx_L4:; + + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.timer.ref.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5timer_8callback_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5timer_8callback_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5timer_8callback___get__(((struct PyGeventTimerObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5timer_8callback___get__(struct PyGeventTimerObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->_callback); + __pyx_r = __pyx_v_self->_callback; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_5timer_8callback_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_callback); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_5timer_8callback_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_callback) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5timer_8callback_2__set__(((struct PyGeventTimerObject *)__pyx_v_self), ((PyObject *)__pyx_v_callback)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_5timer_8callback_2__set__(struct PyGeventTimerObject *__pyx_v_self, PyObject *__pyx_v_callback) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + __Pyx_RefNannySetupContext("__set__", 0); + + __pyx_t_2 = ((!(PyCallable_Check(((PyObject*)__pyx_v_callback)) != 0)) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_2 = (__pyx_v_callback != Py_None); + __pyx_t_3 = (__pyx_t_2 != 0); + __pyx_t_1 = __pyx_t_3; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { + + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 944, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_v_callback); + __Pyx_GIVEREF(__pyx_v_callback); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_callback); + __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_Expected_callable_not_r, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 944, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 944, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 944, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_5, 0, 0, 0); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __PYX_ERR(0, 944, __pyx_L1_error) + + } + + __Pyx_INCREF(__pyx_v_callback); + __Pyx_GIVEREF(__pyx_v_callback); + __Pyx_GOTREF(__pyx_v_self->_callback); + __Pyx_DECREF(__pyx_v_self->_callback); + __pyx_v_self->_callback = __pyx_v_callback; + + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("gevent.libev.corecext.timer.callback.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5timer_1stop(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5timer_1stop(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("stop (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5timer_stop(((struct PyGeventTimerObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5timer_stop(struct PyGeventTimerObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("stop", 0); + + __pyx_t_1 = ((!(__pyx_v_self->loop->_ptr != 0)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__38, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 950, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__33, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 950, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__37, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 950, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 950, __pyx_L1_error) + + } + + __pyx_t_1 = ((__pyx_v_self->_flags & 2) != 0); + if (__pyx_t_1) { + + ev_ref(__pyx_v_self->loop->_ptr); + + __pyx_v_self->_flags = (__pyx_v_self->_flags & (~2)); + + } + + ev_timer_stop(__pyx_v_self->loop->_ptr, (&__pyx_v_self->_watcher)); + + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->_callback); + __Pyx_DECREF(__pyx_v_self->_callback); + __pyx_v_self->_callback = Py_None; + + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = ((PyObject*)Py_None); + + __pyx_t_1 = ((__pyx_v_self->_flags & 1) != 0); + if (__pyx_t_1) { + + Py_DECREF(((PyObject*)__pyx_v_self)); + + __pyx_v_self->_flags = (__pyx_v_self->_flags & (~1)); + + } + + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.timer.stop", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5timer_8priority_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5timer_8priority_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5timer_8priority___get__(((struct PyGeventTimerObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5timer_8priority___get__(struct PyGeventTimerObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(ev_priority((&__pyx_v_self->_watcher))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 964, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.timer.priority.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_5timer_8priority_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_priority); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_5timer_8priority_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_priority) { + int __pyx_v_priority; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_priority); { + __pyx_v_priority = __Pyx_PyInt_As_int(__pyx_arg_priority); if (unlikely((__pyx_v_priority == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 966, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.libev.corecext.timer.priority.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5timer_8priority_2__set__(((struct PyGeventTimerObject *)__pyx_v_self), ((int)__pyx_v_priority)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_5timer_8priority_2__set__(struct PyGeventTimerObject *__pyx_v_self, int __pyx_v_priority) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("__set__", 0); + + __pyx_t_1 = (ev_is_active((&__pyx_v_self->_watcher)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__39, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 968, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__34, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 968, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__38, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 968, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 968, __pyx_L1_error) + + } + + ev_set_priority((&__pyx_v_self->_watcher), __pyx_v_priority); + + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.timer.priority.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5timer_3feed(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5timer_3feed(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + int __pyx_v_revents; + PyObject *__pyx_v_callback = 0; + PyObject *__pyx_v_args = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("feed (wrapper)", 0); + if (PyTuple_GET_SIZE(__pyx_args) > 2) { + __pyx_v_args = PyTuple_GetSlice(__pyx_args, 2, PyTuple_GET_SIZE(__pyx_args)); + if (unlikely(!__pyx_v_args)) { + __Pyx_RefNannyFinishContext(); + return NULL; + } + __Pyx_GOTREF(__pyx_v_args); + } else { + __pyx_v_args = __pyx_empty_tuple; __Pyx_INCREF(__pyx_empty_tuple); + } + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_revents,&__pyx_n_s_callback,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + default: + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_revents)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_callback)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("feed", 0, 2, 2, 1); __PYX_ERR(0, 971, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t used_pos_args = (pos_args < 2) ? pos_args : 2; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, used_pos_args, "feed") < 0)) __PYX_ERR(0, 971, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) < 2) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + } + __pyx_v_revents = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_revents == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 971, __pyx_L3_error) + __pyx_v_callback = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("feed", 0, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 971, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0; + __Pyx_AddTraceback("gevent.libev.corecext.timer.feed", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5timer_2feed(((struct PyGeventTimerObject *)__pyx_v_self), __pyx_v_revents, __pyx_v_callback, __pyx_v_args); + + /* function exit code */ + __Pyx_XDECREF(__pyx_v_args); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5timer_2feed(struct PyGeventTimerObject *__pyx_v_self, int __pyx_v_revents, PyObject *__pyx_v_callback, PyObject *__pyx_v_args) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("feed", 0); + + __pyx_t_1 = ((!(__pyx_v_self->loop->_ptr != 0)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__40, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 974, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__35, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 974, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__39, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 974, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 974, __pyx_L1_error) + + } + + if (__Pyx_PyObject_SetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_callback, __pyx_v_callback) < 0) __PYX_ERR(0, 975, __pyx_L1_error) + + __Pyx_INCREF(__pyx_v_args); + __Pyx_GIVEREF(__pyx_v_args); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = __pyx_v_args; + + __pyx_t_1 = (((__pyx_v_self->_flags & 6) == 4) != 0); + if (__pyx_t_1) { + + ev_unref(__pyx_v_self->loop->_ptr); + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 2); + + } + + ev_feed_event(__pyx_v_self->loop->_ptr, (&__pyx_v_self->_watcher), __pyx_v_revents); + + __pyx_t_1 = ((!((__pyx_v_self->_flags & 1) != 0)) != 0); + if (__pyx_t_1) { + + Py_INCREF(((PyObject*)__pyx_v_self)); + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 1); + + } + + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.timer.feed", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5timer_5start(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5timer_5start(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_callback = 0; + PyObject *__pyx_v_update = 0; + PyObject *__pyx_v_args = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("start (wrapper)", 0); + if (PyTuple_GET_SIZE(__pyx_args) > 1) { + __pyx_v_args = PyTuple_GetSlice(__pyx_args, 1, PyTuple_GET_SIZE(__pyx_args)); + if (unlikely(!__pyx_v_args)) { + __Pyx_RefNannyFinishContext(); + return NULL; + } + __Pyx_GOTREF(__pyx_v_args); + } else { + __pyx_v_args = __pyx_empty_tuple; __Pyx_INCREF(__pyx_empty_tuple); + } + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_callback,&__pyx_n_s_update,0}; + PyObject* values[2] = {0,0}; + values[1] = ((PyObject *)Py_True); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + default: + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_callback)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + } + if (kw_args == 1) { + const Py_ssize_t index = 1; + PyObject* value = PyDict_GetItem(__pyx_kwds, *__pyx_pyargnames[index]); + if (value) { values[index] = value; kw_args--; } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t used_pos_args = (pos_args < 1) ? pos_args : 1; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, used_pos_args, "start") < 0)) __PYX_ERR(0, 985, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) < 1) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + } + __pyx_v_callback = values[0]; + __pyx_v_update = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("start", 0, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 985, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0; + __Pyx_AddTraceback("gevent.libev.corecext.timer.start", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5timer_4start(((struct PyGeventTimerObject *)__pyx_v_self), __pyx_v_callback, __pyx_v_update, __pyx_v_args); + + /* function exit code */ + __Pyx_XDECREF(__pyx_v_args); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5timer_4start(struct PyGeventTimerObject *__pyx_v_self, PyObject *__pyx_v_callback, PyObject *__pyx_v_update, PyObject *__pyx_v_args) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + __Pyx_RefNannySetupContext("start", 0); + + __pyx_t_1 = ((!(__pyx_v_self->loop->_ptr != 0)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__41, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 988, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__36, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 988, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__40, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 988, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 988, __pyx_L1_error) + + } + + __pyx_t_1 = (__pyx_v_callback == Py_None); + __pyx_t_3 = (__pyx_t_1 != 0); + if (__pyx_t_3) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__42, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 990, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__37, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 990, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__41, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 990, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 990, __pyx_L1_error) + + } + + if (__Pyx_PyObject_SetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_callback, __pyx_v_callback) < 0) __PYX_ERR(0, 991, __pyx_L1_error) + + __Pyx_INCREF(__pyx_v_args); + __Pyx_GIVEREF(__pyx_v_args); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = __pyx_v_args; + + __pyx_t_3 = (((__pyx_v_self->_flags & 6) == 4) != 0); + if (__pyx_t_3) { + + ev_unref(__pyx_v_self->loop->_ptr); + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 2); + + } + + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_update); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 996, __pyx_L1_error) + if (__pyx_t_3) { + + ev_now_update(__pyx_v_self->loop->_ptr); + + } + + ev_timer_start(__pyx_v_self->loop->_ptr, (&__pyx_v_self->_watcher)); + + __pyx_t_3 = ((!((__pyx_v_self->_flags & 1) != 0)) != 0); + if (__pyx_t_3) { + + Py_INCREF(((PyObject*)__pyx_v_self)); + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 1); + + } + + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.timer.start", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5timer_6active_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5timer_6active_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5timer_6active___get__(((struct PyGeventTimerObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5timer_6active___get__(struct PyGeventTimerObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + if ((ev_is_active((&__pyx_v_self->_watcher)) != 0)) { + __Pyx_INCREF(Py_True); + __pyx_t_1 = Py_True; + } else { + __Pyx_INCREF(Py_False); + __pyx_t_1 = Py_False; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5timer_7pending_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5timer_7pending_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5timer_7pending___get__(((struct PyGeventTimerObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5timer_7pending___get__(struct PyGeventTimerObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + if ((ev_is_pending((&__pyx_v_self->_watcher)) != 0)) { + __Pyx_INCREF(Py_True); + __pyx_t_1 = Py_True; + } else { + __Pyx_INCREF(Py_False); + __pyx_t_1 = Py_False; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_5timer_7__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_5timer_7__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + struct PyGeventLoopObject *__pyx_v_loop = 0; + double __pyx_v_after; + double __pyx_v_repeat; + PyObject *__pyx_v_ref = 0; + PyObject *__pyx_v_priority = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_loop,&__pyx_n_s_after,&__pyx_n_s_repeat,&__pyx_n_s_ref,&__pyx_n_s_priority,0}; + PyObject* values[5] = {0,0,0,0,0}; + values[3] = ((PyObject *)Py_True); + values[4] = ((PyObject *)Py_None); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_loop)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_after); + if (value) { values[1] = value; kw_args--; } + } + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_repeat); + if (value) { values[2] = value; kw_args--; } + } + case 3: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ref); + if (value) { values[3] = value; kw_args--; } + } + case 4: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_priority); + if (value) { values[4] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 1014, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_loop = ((struct PyGeventLoopObject *)values[0]); + if (values[1]) { + __pyx_v_after = __pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_after == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1014, __pyx_L3_error) + } else { + __pyx_v_after = ((double)0.0); + } + if (values[2]) { + __pyx_v_repeat = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_repeat == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1014, __pyx_L3_error) + } else { + __pyx_v_repeat = ((double)0.0); + } + __pyx_v_ref = values[3]; + __pyx_v_priority = values[4]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 0, 1, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1014, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.libev.corecext.timer.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_loop), __pyx_ptype_6gevent_5libev_8corecext_loop, 1, "loop", 0))) __PYX_ERR(0, 1014, __pyx_L1_error) + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5timer_6__init__(((struct PyGeventTimerObject *)__pyx_v_self), __pyx_v_loop, __pyx_v_after, __pyx_v_repeat, __pyx_v_ref, __pyx_v_priority); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_5timer_6__init__(struct PyGeventTimerObject *__pyx_v_self, struct PyGeventLoopObject *__pyx_v_loop, double __pyx_v_after, double __pyx_v_repeat, PyObject *__pyx_v_ref, PyObject *__pyx_v_priority) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + __Pyx_RefNannySetupContext("__init__", 0); + + __pyx_t_1 = ((__pyx_v_repeat < 0.0) != 0); + if (__pyx_t_1) { + + __pyx_t_2 = PyFloat_FromDouble(__pyx_v_repeat); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1016, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_repeat_must_be_positive_or_zero, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1016, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1016, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1016, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 1016, __pyx_L1_error) + + } + + ev_timer_init((&__pyx_v_self->_watcher), ((void *)gevent_callback_timer), __pyx_v_after, __pyx_v_repeat); + + __Pyx_INCREF(((PyObject *)__pyx_v_loop)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_loop)); + __Pyx_GOTREF(__pyx_v_self->loop); + __Pyx_DECREF(((PyObject *)__pyx_v_self->loop)); + __pyx_v_self->loop = __pyx_v_loop; + + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_ref); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1019, __pyx_L1_error) + if (__pyx_t_1) { + + __pyx_v_self->_flags = 0; + + goto __pyx_L4; + } + + /*else*/ { + __pyx_v_self->_flags = 4; + } + __pyx_L4:; + + __pyx_t_1 = (__pyx_v_priority != Py_None); + __pyx_t_4 = (__pyx_t_1 != 0); + if (__pyx_t_4) { + + __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_v_priority); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1024, __pyx_L1_error) + ev_set_priority((&__pyx_v_self->_watcher), __pyx_t_5); + + } + + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("gevent.libev.corecext.timer.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5timer_2at_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5timer_2at_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5timer_2at___get__(((struct PyGeventTimerObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5timer_2at___get__(struct PyGeventTimerObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->_watcher.at); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1029, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.timer.at.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5timer_9again(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5timer_9again(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_callback = 0; + PyObject *__pyx_v_update = 0; + PyObject *__pyx_v_args = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("again (wrapper)", 0); + if (PyTuple_GET_SIZE(__pyx_args) > 1) { + __pyx_v_args = PyTuple_GetSlice(__pyx_args, 1, PyTuple_GET_SIZE(__pyx_args)); + if (unlikely(!__pyx_v_args)) { + __Pyx_RefNannyFinishContext(); + return NULL; + } + __Pyx_GOTREF(__pyx_v_args); + } else { + __pyx_v_args = __pyx_empty_tuple; __Pyx_INCREF(__pyx_empty_tuple); + } + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_callback,&__pyx_n_s_update,0}; + PyObject* values[2] = {0,0}; + values[1] = ((PyObject *)Py_True); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + default: + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_callback)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + } + if (kw_args == 1) { + const Py_ssize_t index = 1; + PyObject* value = PyDict_GetItem(__pyx_kwds, *__pyx_pyargnames[index]); + if (value) { values[index] = value; kw_args--; } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t used_pos_args = (pos_args < 1) ? pos_args : 1; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, used_pos_args, "again") < 0)) __PYX_ERR(0, 1033, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) < 1) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + } + __pyx_v_callback = values[0]; + __pyx_v_update = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("again", 0, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1033, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0; + __Pyx_AddTraceback("gevent.libev.corecext.timer.again", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5timer_8again(((struct PyGeventTimerObject *)__pyx_v_self), __pyx_v_callback, __pyx_v_update, __pyx_v_args); + + /* function exit code */ + __Pyx_XDECREF(__pyx_v_args); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5timer_8again(struct PyGeventTimerObject *__pyx_v_self, PyObject *__pyx_v_callback, PyObject *__pyx_v_update, PyObject *__pyx_v_args) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("again", 0); + + __pyx_t_1 = ((!(__pyx_v_self->loop->_ptr != 0)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__43, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1036, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__38, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1036, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__42, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1036, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1036, __pyx_L1_error) + + } + + if (__Pyx_PyObject_SetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_callback, __pyx_v_callback) < 0) __PYX_ERR(0, 1037, __pyx_L1_error) + + __Pyx_INCREF(__pyx_v_args); + __Pyx_GIVEREF(__pyx_v_args); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = __pyx_v_args; + + __pyx_t_1 = (((__pyx_v_self->_flags & 6) == 4) != 0); + if (__pyx_t_1) { + + ev_unref(__pyx_v_self->loop->_ptr); + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 2); + + } + + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_update); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1042, __pyx_L1_error) + if (__pyx_t_1) { + + ev_now_update(__pyx_v_self->loop->_ptr); + + } + + ev_timer_again(__pyx_v_self->loop->_ptr, (&__pyx_v_self->_watcher)); + + __pyx_t_1 = ((!((__pyx_v_self->_flags & 1) != 0)) != 0); + if (__pyx_t_1) { + + Py_INCREF(((PyObject*)__pyx_v_self)); + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 1); + + } + + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.timer.again", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5timer_4loop_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5timer_4loop_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5timer_4loop___get__(((struct PyGeventTimerObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5timer_4loop___get__(struct PyGeventTimerObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self->loop)); + __pyx_r = ((PyObject *)__pyx_v_self->loop); + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_5timer_4loop_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_5timer_4loop_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5timer_4loop_2__set__(((struct PyGeventTimerObject *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_5timer_4loop_2__set__(struct PyGeventTimerObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__set__", 0); + if (!(likely(((__pyx_v_value) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_value, __pyx_ptype_6gevent_5libev_8corecext_loop))))) __PYX_ERR(0, 908, __pyx_L1_error) + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->loop); + __Pyx_DECREF(((PyObject *)__pyx_v_self->loop)); + __pyx_v_self->loop = ((struct PyGeventLoopObject *)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.timer.loop.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_5timer_4loop_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_5timer_4loop_5__del__(PyObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5timer_4loop_4__del__(((struct PyGeventTimerObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_5timer_4loop_4__del__(struct PyGeventTimerObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 0); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->loop); + __Pyx_DECREF(((PyObject *)__pyx_v_self->loop)); + __pyx_v_self->loop = ((struct PyGeventLoopObject *)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5timer_4args_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5timer_4args_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5timer_4args___get__(((struct PyGeventTimerObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5timer_4args___get__(struct PyGeventTimerObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->args); + __pyx_r = __pyx_v_self->args; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_5timer_4args_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_5timer_4args_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5timer_4args_2__set__(((struct PyGeventTimerObject *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_5timer_4args_2__set__(struct PyGeventTimerObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__set__", 0); + if (!(likely(PyTuple_CheckExact(__pyx_v_value))||((__pyx_v_value) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v_value)->tp_name), 0))) __PYX_ERR(0, 910, __pyx_L1_error) + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.timer.args.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_5timer_4args_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_5timer_4args_5__del__(PyObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5timer_4args_4__del__(((struct PyGeventTimerObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_5timer_4args_4__del__(struct PyGeventTimerObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 0); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = ((PyObject*)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5timer_6_flags_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5timer_6_flags_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5timer_6_flags___get__(((struct PyGeventTimerObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5timer_6_flags___get__(struct PyGeventTimerObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 911, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.timer._flags.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_6signal_3ref_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_6signal_3ref_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_6signal_3ref___get__(((struct PyGeventSignalObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_6signal_3ref___get__(struct PyGeventSignalObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + if (((__pyx_v_self->_flags & 4) != 0)) { + __Pyx_INCREF(Py_False); + __pyx_t_1 = Py_False; + } else { + __Pyx_INCREF(Py_True); + __pyx_t_1 = Py_True; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_6signal_3ref_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_6signal_3ref_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_6signal_3ref_2__set__(((struct PyGeventSignalObject *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_6signal_3ref_2__set__(struct PyGeventSignalObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + __Pyx_RefNannySetupContext("__set__", 0); + + __pyx_t_1 = ((!(__pyx_v_self->loop->_ptr != 0)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__44, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1067, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__39, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1067, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__43, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1067, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1067, __pyx_L1_error) + + } + + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_value); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1068, __pyx_L1_error) + if (__pyx_t_1) { + + __pyx_t_1 = ((!((__pyx_v_self->_flags & 4) != 0)) != 0); + if (__pyx_t_1) { + + __pyx_r = 0; + goto __pyx_L0; + + } + + __pyx_t_1 = ((__pyx_v_self->_flags & 2) != 0); + if (__pyx_t_1) { + + ev_ref(__pyx_v_self->loop->_ptr); + + } + + __pyx_v_self->_flags = (__pyx_v_self->_flags & (~6)); + + goto __pyx_L4; + } + + /*else*/ { + __pyx_t_1 = ((__pyx_v_self->_flags & 4) != 0); + if (__pyx_t_1) { + + __pyx_r = 0; + goto __pyx_L0; + + } + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 4); + + __pyx_t_3 = ((!((__pyx_v_self->_flags & 2) != 0)) != 0); + if (__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L9_bool_binop_done; + } + __pyx_t_3 = (ev_is_active((&__pyx_v_self->_watcher)) != 0); + __pyx_t_1 = __pyx_t_3; + __pyx_L9_bool_binop_done:; + if (__pyx_t_1) { + + ev_unref(__pyx_v_self->loop->_ptr); + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 2); + + } + } + __pyx_L4:; + + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.signal.ref.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_6signal_8callback_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_6signal_8callback_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_6signal_8callback___get__(((struct PyGeventSignalObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_6signal_8callback___get__(struct PyGeventSignalObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->_callback); + __pyx_r = __pyx_v_self->_callback; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_6signal_8callback_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_callback); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_6signal_8callback_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_callback) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_6signal_8callback_2__set__(((struct PyGeventSignalObject *)__pyx_v_self), ((PyObject *)__pyx_v_callback)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_6signal_8callback_2__set__(struct PyGeventSignalObject *__pyx_v_self, PyObject *__pyx_v_callback) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + __Pyx_RefNannySetupContext("__set__", 0); + + __pyx_t_2 = ((!(PyCallable_Check(((PyObject*)__pyx_v_callback)) != 0)) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_2 = (__pyx_v_callback != Py_None); + __pyx_t_3 = (__pyx_t_2 != 0); + __pyx_t_1 = __pyx_t_3; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { + + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1089, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_v_callback); + __Pyx_GIVEREF(__pyx_v_callback); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_callback); + __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_Expected_callable_not_r, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1089, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1089, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1089, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_5, 0, 0, 0); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __PYX_ERR(0, 1089, __pyx_L1_error) + + } + + __Pyx_INCREF(__pyx_v_callback); + __Pyx_GIVEREF(__pyx_v_callback); + __Pyx_GOTREF(__pyx_v_self->_callback); + __Pyx_DECREF(__pyx_v_self->_callback); + __pyx_v_self->_callback = __pyx_v_callback; + + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("gevent.libev.corecext.signal.callback.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_6signal_1stop(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_6signal_1stop(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("stop (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_6signal_stop(((struct PyGeventSignalObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_6signal_stop(struct PyGeventSignalObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("stop", 0); + + __pyx_t_1 = ((!(__pyx_v_self->loop->_ptr != 0)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__45, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1095, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__40, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1095, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__44, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1095, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1095, __pyx_L1_error) + + } + + __pyx_t_1 = ((__pyx_v_self->_flags & 2) != 0); + if (__pyx_t_1) { + + ev_ref(__pyx_v_self->loop->_ptr); + + __pyx_v_self->_flags = (__pyx_v_self->_flags & (~2)); + + } + + ev_signal_stop(__pyx_v_self->loop->_ptr, (&__pyx_v_self->_watcher)); + + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->_callback); + __Pyx_DECREF(__pyx_v_self->_callback); + __pyx_v_self->_callback = Py_None; + + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = ((PyObject*)Py_None); + + __pyx_t_1 = ((__pyx_v_self->_flags & 1) != 0); + if (__pyx_t_1) { + + Py_DECREF(((PyObject*)__pyx_v_self)); + + __pyx_v_self->_flags = (__pyx_v_self->_flags & (~1)); + + } + + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.signal.stop", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_6signal_8priority_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_6signal_8priority_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_6signal_8priority___get__(((struct PyGeventSignalObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_6signal_8priority___get__(struct PyGeventSignalObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(ev_priority((&__pyx_v_self->_watcher))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1109, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.signal.priority.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_6signal_8priority_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_priority); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_6signal_8priority_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_priority) { + int __pyx_v_priority; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_priority); { + __pyx_v_priority = __Pyx_PyInt_As_int(__pyx_arg_priority); if (unlikely((__pyx_v_priority == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1111, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.libev.corecext.signal.priority.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_6signal_8priority_2__set__(((struct PyGeventSignalObject *)__pyx_v_self), ((int)__pyx_v_priority)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_6signal_8priority_2__set__(struct PyGeventSignalObject *__pyx_v_self, int __pyx_v_priority) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("__set__", 0); + + __pyx_t_1 = (ev_is_active((&__pyx_v_self->_watcher)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__46, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1113, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__41, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1113, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__45, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1113, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1113, __pyx_L1_error) + + } + + ev_set_priority((&__pyx_v_self->_watcher), __pyx_v_priority); + + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.signal.priority.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_6signal_3feed(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_6signal_3feed(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + int __pyx_v_revents; + PyObject *__pyx_v_callback = 0; + PyObject *__pyx_v_args = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("feed (wrapper)", 0); + if (PyTuple_GET_SIZE(__pyx_args) > 2) { + __pyx_v_args = PyTuple_GetSlice(__pyx_args, 2, PyTuple_GET_SIZE(__pyx_args)); + if (unlikely(!__pyx_v_args)) { + __Pyx_RefNannyFinishContext(); + return NULL; + } + __Pyx_GOTREF(__pyx_v_args); + } else { + __pyx_v_args = __pyx_empty_tuple; __Pyx_INCREF(__pyx_empty_tuple); + } + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_revents,&__pyx_n_s_callback,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + default: + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_revents)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_callback)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("feed", 0, 2, 2, 1); __PYX_ERR(0, 1116, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t used_pos_args = (pos_args < 2) ? pos_args : 2; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, used_pos_args, "feed") < 0)) __PYX_ERR(0, 1116, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) < 2) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + } + __pyx_v_revents = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_revents == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1116, __pyx_L3_error) + __pyx_v_callback = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("feed", 0, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1116, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0; + __Pyx_AddTraceback("gevent.libev.corecext.signal.feed", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_6signal_2feed(((struct PyGeventSignalObject *)__pyx_v_self), __pyx_v_revents, __pyx_v_callback, __pyx_v_args); + + /* function exit code */ + __Pyx_XDECREF(__pyx_v_args); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_6signal_2feed(struct PyGeventSignalObject *__pyx_v_self, int __pyx_v_revents, PyObject *__pyx_v_callback, PyObject *__pyx_v_args) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("feed", 0); + + __pyx_t_1 = ((!(__pyx_v_self->loop->_ptr != 0)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__47, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1119, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__42, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1119, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__46, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1119, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1119, __pyx_L1_error) + + } + + if (__Pyx_PyObject_SetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_callback, __pyx_v_callback) < 0) __PYX_ERR(0, 1120, __pyx_L1_error) + + __Pyx_INCREF(__pyx_v_args); + __Pyx_GIVEREF(__pyx_v_args); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = __pyx_v_args; + + __pyx_t_1 = (((__pyx_v_self->_flags & 6) == 4) != 0); + if (__pyx_t_1) { + + ev_unref(__pyx_v_self->loop->_ptr); + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 2); + + } + + ev_feed_event(__pyx_v_self->loop->_ptr, (&__pyx_v_self->_watcher), __pyx_v_revents); + + __pyx_t_1 = ((!((__pyx_v_self->_flags & 1) != 0)) != 0); + if (__pyx_t_1) { + + Py_INCREF(((PyObject*)__pyx_v_self)); + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 1); + + } + + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.signal.feed", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_6signal_5start(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_6signal_5start(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_callback = 0; + PyObject *__pyx_v_args = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("start (wrapper)", 0); + if (PyTuple_GET_SIZE(__pyx_args) > 1) { + __pyx_v_args = PyTuple_GetSlice(__pyx_args, 1, PyTuple_GET_SIZE(__pyx_args)); + if (unlikely(!__pyx_v_args)) { + __Pyx_RefNannyFinishContext(); + return NULL; + } + __Pyx_GOTREF(__pyx_v_args); + } else { + __pyx_v_args = __pyx_empty_tuple; __Pyx_INCREF(__pyx_empty_tuple); + } + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_callback,0}; + PyObject* values[1] = {0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + default: + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_callback)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t used_pos_args = (pos_args < 1) ? pos_args : 1; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, used_pos_args, "start") < 0)) __PYX_ERR(0, 1130, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) < 1) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + } + __pyx_v_callback = values[0]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("start", 0, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1130, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0; + __Pyx_AddTraceback("gevent.libev.corecext.signal.start", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_6signal_4start(((struct PyGeventSignalObject *)__pyx_v_self), __pyx_v_callback, __pyx_v_args); + + /* function exit code */ + __Pyx_XDECREF(__pyx_v_args); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_6signal_4start(struct PyGeventSignalObject *__pyx_v_self, PyObject *__pyx_v_callback, PyObject *__pyx_v_args) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + __Pyx_RefNannySetupContext("start", 0); + + __pyx_t_1 = ((!(__pyx_v_self->loop->_ptr != 0)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__48, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1133, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__43, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1133, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__47, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1133, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1133, __pyx_L1_error) + + } + + __pyx_t_1 = (__pyx_v_callback == Py_None); + __pyx_t_3 = (__pyx_t_1 != 0); + if (__pyx_t_3) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__49, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1135, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__44, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1135, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__48, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1135, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1135, __pyx_L1_error) + + } + + if (__Pyx_PyObject_SetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_callback, __pyx_v_callback) < 0) __PYX_ERR(0, 1136, __pyx_L1_error) + + __Pyx_INCREF(__pyx_v_args); + __Pyx_GIVEREF(__pyx_v_args); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = __pyx_v_args; + + __pyx_t_3 = (((__pyx_v_self->_flags & 6) == 4) != 0); + if (__pyx_t_3) { + + ev_unref(__pyx_v_self->loop->_ptr); + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 2); + + } + + ev_signal_start(__pyx_v_self->loop->_ptr, (&__pyx_v_self->_watcher)); + + __pyx_t_3 = ((!((__pyx_v_self->_flags & 1) != 0)) != 0); + if (__pyx_t_3) { + + Py_INCREF(((PyObject*)__pyx_v_self)); + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 1); + + } + + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.signal.start", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_6signal_6active_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_6signal_6active_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_6signal_6active___get__(((struct PyGeventSignalObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_6signal_6active___get__(struct PyGeventSignalObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + if ((ev_is_active((&__pyx_v_self->_watcher)) != 0)) { + __Pyx_INCREF(Py_True); + __pyx_t_1 = Py_True; + } else { + __Pyx_INCREF(Py_False); + __pyx_t_1 = Py_False; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_6signal_7pending_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_6signal_7pending_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_6signal_7pending___get__(((struct PyGeventSignalObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_6signal_7pending___get__(struct PyGeventSignalObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + if ((ev_is_pending((&__pyx_v_self->_watcher)) != 0)) { + __Pyx_INCREF(Py_True); + __pyx_t_1 = Py_True; + } else { + __Pyx_INCREF(Py_False); + __pyx_t_1 = Py_False; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_6signal_7__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_6signal_7__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + struct PyGeventLoopObject *__pyx_v_loop = 0; + int __pyx_v_signalnum; + PyObject *__pyx_v_ref = 0; + PyObject *__pyx_v_priority = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_loop,&__pyx_n_s_signalnum,&__pyx_n_s_ref,&__pyx_n_s_priority,0}; + PyObject* values[4] = {0,0,0,0}; + values[2] = ((PyObject *)Py_True); + values[3] = ((PyObject *)Py_None); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_loop)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_signalnum)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__init__", 0, 2, 4, 1); __PYX_ERR(0, 1157, __pyx_L3_error) + } + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ref); + if (value) { values[2] = value; kw_args--; } + } + case 3: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_priority); + if (value) { values[3] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 1157, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_loop = ((struct PyGeventLoopObject *)values[0]); + __pyx_v_signalnum = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_signalnum == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1157, __pyx_L3_error) + __pyx_v_ref = values[2]; + __pyx_v_priority = values[3]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 0, 2, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1157, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.libev.corecext.signal.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_loop), __pyx_ptype_6gevent_5libev_8corecext_loop, 1, "loop", 0))) __PYX_ERR(0, 1157, __pyx_L1_error) + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_6signal_6__init__(((struct PyGeventSignalObject *)__pyx_v_self), __pyx_v_loop, __pyx_v_signalnum, __pyx_v_ref, __pyx_v_priority); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_6signal_6__init__(struct PyGeventSignalObject *__pyx_v_self, struct PyGeventLoopObject *__pyx_v_loop, int __pyx_v_signalnum, PyObject *__pyx_v_ref, PyObject *__pyx_v_priority) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + __Pyx_RefNannySetupContext("__init__", 0); + + __pyx_t_2 = ((__pyx_v_signalnum < 1) != 0); + if (!__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_signalnum); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1158, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_signalmodule); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1158, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_NSIG); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1158, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_t_5, Py_GE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1158, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 1158, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_1 = __pyx_t_2; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { + + __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_signalnum); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1159, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_illegal_signal_number_r, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1159, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1159, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1159, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_5, 0, 0, 0); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __PYX_ERR(0, 1159, __pyx_L1_error) + + } + + ev_signal_init((&__pyx_v_self->_watcher), ((void *)gevent_callback_signal), __pyx_v_signalnum); + + __Pyx_INCREF(((PyObject *)__pyx_v_loop)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_loop)); + __Pyx_GOTREF(__pyx_v_self->loop); + __Pyx_DECREF(((PyObject *)__pyx_v_self->loop)); + __pyx_v_self->loop = __pyx_v_loop; + + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_ref); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1167, __pyx_L1_error) + if (__pyx_t_1) { + + __pyx_v_self->_flags = 0; + + goto __pyx_L6; + } + + /*else*/ { + __pyx_v_self->_flags = 4; + } + __pyx_L6:; + + __pyx_t_1 = (__pyx_v_priority != Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_v_priority); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1172, __pyx_L1_error) + ev_set_priority((&__pyx_v_self->_watcher), __pyx_t_6); + + } + + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("gevent.libev.corecext.signal.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_6signal_4loop_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_6signal_4loop_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_6signal_4loop___get__(((struct PyGeventSignalObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_6signal_4loop___get__(struct PyGeventSignalObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self->loop)); + __pyx_r = ((PyObject *)__pyx_v_self->loop); + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_6signal_4loop_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_6signal_4loop_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_6signal_4loop_2__set__(((struct PyGeventSignalObject *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_6signal_4loop_2__set__(struct PyGeventSignalObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__set__", 0); + if (!(likely(((__pyx_v_value) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_value, __pyx_ptype_6gevent_5libev_8corecext_loop))))) __PYX_ERR(0, 1053, __pyx_L1_error) + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->loop); + __Pyx_DECREF(((PyObject *)__pyx_v_self->loop)); + __pyx_v_self->loop = ((struct PyGeventLoopObject *)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.signal.loop.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_6signal_4loop_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_6signal_4loop_5__del__(PyObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_6signal_4loop_4__del__(((struct PyGeventSignalObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_6signal_4loop_4__del__(struct PyGeventSignalObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 0); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->loop); + __Pyx_DECREF(((PyObject *)__pyx_v_self->loop)); + __pyx_v_self->loop = ((struct PyGeventLoopObject *)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_6signal_4args_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_6signal_4args_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_6signal_4args___get__(((struct PyGeventSignalObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_6signal_4args___get__(struct PyGeventSignalObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->args); + __pyx_r = __pyx_v_self->args; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_6signal_4args_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_6signal_4args_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_6signal_4args_2__set__(((struct PyGeventSignalObject *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_6signal_4args_2__set__(struct PyGeventSignalObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__set__", 0); + if (!(likely(PyTuple_CheckExact(__pyx_v_value))||((__pyx_v_value) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v_value)->tp_name), 0))) __PYX_ERR(0, 1055, __pyx_L1_error) + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.signal.args.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_6signal_4args_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_6signal_4args_5__del__(PyObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_6signal_4args_4__del__(((struct PyGeventSignalObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_6signal_4args_4__del__(struct PyGeventSignalObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 0); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = ((PyObject*)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_6signal_6_flags_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_6signal_6_flags_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_6signal_6_flags___get__(((struct PyGeventSignalObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_6signal_6_flags___get__(struct PyGeventSignalObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1056, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.signal._flags.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4idle_3ref_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4idle_3ref_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4idle_3ref___get__(((struct PyGeventIdleObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4idle_3ref___get__(struct PyGeventIdleObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + if (((__pyx_v_self->_flags & 4) != 0)) { + __Pyx_INCREF(Py_False); + __pyx_t_1 = Py_False; + } else { + __Pyx_INCREF(Py_True); + __pyx_t_1 = Py_True; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_4idle_3ref_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_4idle_3ref_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4idle_3ref_2__set__(((struct PyGeventIdleObject *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_4idle_3ref_2__set__(struct PyGeventIdleObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + __Pyx_RefNannySetupContext("__set__", 0); + + __pyx_t_1 = ((!(__pyx_v_self->loop->_ptr != 0)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__50, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1192, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__45, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1192, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__49, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1192, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1192, __pyx_L1_error) + + } + + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_value); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1193, __pyx_L1_error) + if (__pyx_t_1) { + + __pyx_t_1 = ((!((__pyx_v_self->_flags & 4) != 0)) != 0); + if (__pyx_t_1) { + + __pyx_r = 0; + goto __pyx_L0; + + } + + __pyx_t_1 = ((__pyx_v_self->_flags & 2) != 0); + if (__pyx_t_1) { + + ev_ref(__pyx_v_self->loop->_ptr); + + } + + __pyx_v_self->_flags = (__pyx_v_self->_flags & (~6)); + + goto __pyx_L4; + } + + /*else*/ { + __pyx_t_1 = ((__pyx_v_self->_flags & 4) != 0); + if (__pyx_t_1) { + + __pyx_r = 0; + goto __pyx_L0; + + } + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 4); + + __pyx_t_3 = ((!((__pyx_v_self->_flags & 2) != 0)) != 0); + if (__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L9_bool_binop_done; + } + __pyx_t_3 = (ev_is_active((&__pyx_v_self->_watcher)) != 0); + __pyx_t_1 = __pyx_t_3; + __pyx_L9_bool_binop_done:; + if (__pyx_t_1) { + + ev_unref(__pyx_v_self->loop->_ptr); + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 2); + + } + } + __pyx_L4:; + + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.idle.ref.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4idle_8callback_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4idle_8callback_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4idle_8callback___get__(((struct PyGeventIdleObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4idle_8callback___get__(struct PyGeventIdleObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->_callback); + __pyx_r = __pyx_v_self->_callback; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_4idle_8callback_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_callback); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_4idle_8callback_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_callback) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4idle_8callback_2__set__(((struct PyGeventIdleObject *)__pyx_v_self), ((PyObject *)__pyx_v_callback)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_4idle_8callback_2__set__(struct PyGeventIdleObject *__pyx_v_self, PyObject *__pyx_v_callback) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + __Pyx_RefNannySetupContext("__set__", 0); + + __pyx_t_2 = ((!(PyCallable_Check(((PyObject*)__pyx_v_callback)) != 0)) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_2 = (__pyx_v_callback != Py_None); + __pyx_t_3 = (__pyx_t_2 != 0); + __pyx_t_1 = __pyx_t_3; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { + + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1214, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_v_callback); + __Pyx_GIVEREF(__pyx_v_callback); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_callback); + __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_Expected_callable_not_r, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1214, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1214, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1214, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_5, 0, 0, 0); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __PYX_ERR(0, 1214, __pyx_L1_error) + + } + + __Pyx_INCREF(__pyx_v_callback); + __Pyx_GIVEREF(__pyx_v_callback); + __Pyx_GOTREF(__pyx_v_self->_callback); + __Pyx_DECREF(__pyx_v_self->_callback); + __pyx_v_self->_callback = __pyx_v_callback; + + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("gevent.libev.corecext.idle.callback.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4idle_1stop(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4idle_1stop(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("stop (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4idle_stop(((struct PyGeventIdleObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4idle_stop(struct PyGeventIdleObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("stop", 0); + + __pyx_t_1 = ((!(__pyx_v_self->loop->_ptr != 0)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__51, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1220, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__46, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1220, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__50, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1220, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1220, __pyx_L1_error) + + } + + __pyx_t_1 = ((__pyx_v_self->_flags & 2) != 0); + if (__pyx_t_1) { + + ev_ref(__pyx_v_self->loop->_ptr); + + __pyx_v_self->_flags = (__pyx_v_self->_flags & (~2)); + + } + + ev_idle_stop(__pyx_v_self->loop->_ptr, (&__pyx_v_self->_watcher)); + + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->_callback); + __Pyx_DECREF(__pyx_v_self->_callback); + __pyx_v_self->_callback = Py_None; + + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = ((PyObject*)Py_None); + + __pyx_t_1 = ((__pyx_v_self->_flags & 1) != 0); + if (__pyx_t_1) { + + Py_DECREF(((PyObject*)__pyx_v_self)); + + __pyx_v_self->_flags = (__pyx_v_self->_flags & (~1)); + + } + + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.idle.stop", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4idle_8priority_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4idle_8priority_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4idle_8priority___get__(((struct PyGeventIdleObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4idle_8priority___get__(struct PyGeventIdleObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(ev_priority((&__pyx_v_self->_watcher))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1234, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.idle.priority.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_4idle_8priority_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_priority); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_4idle_8priority_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_priority) { + int __pyx_v_priority; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_priority); { + __pyx_v_priority = __Pyx_PyInt_As_int(__pyx_arg_priority); if (unlikely((__pyx_v_priority == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1236, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.libev.corecext.idle.priority.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4idle_8priority_2__set__(((struct PyGeventIdleObject *)__pyx_v_self), ((int)__pyx_v_priority)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_4idle_8priority_2__set__(struct PyGeventIdleObject *__pyx_v_self, int __pyx_v_priority) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("__set__", 0); + + __pyx_t_1 = (ev_is_active((&__pyx_v_self->_watcher)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__52, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1238, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__47, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1238, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__51, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1238, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1238, __pyx_L1_error) + + } + + ev_set_priority((&__pyx_v_self->_watcher), __pyx_v_priority); + + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.idle.priority.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4idle_3feed(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4idle_3feed(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + int __pyx_v_revents; + PyObject *__pyx_v_callback = 0; + PyObject *__pyx_v_args = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("feed (wrapper)", 0); + if (PyTuple_GET_SIZE(__pyx_args) > 2) { + __pyx_v_args = PyTuple_GetSlice(__pyx_args, 2, PyTuple_GET_SIZE(__pyx_args)); + if (unlikely(!__pyx_v_args)) { + __Pyx_RefNannyFinishContext(); + return NULL; + } + __Pyx_GOTREF(__pyx_v_args); + } else { + __pyx_v_args = __pyx_empty_tuple; __Pyx_INCREF(__pyx_empty_tuple); + } + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_revents,&__pyx_n_s_callback,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + default: + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_revents)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_callback)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("feed", 0, 2, 2, 1); __PYX_ERR(0, 1241, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t used_pos_args = (pos_args < 2) ? pos_args : 2; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, used_pos_args, "feed") < 0)) __PYX_ERR(0, 1241, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) < 2) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + } + __pyx_v_revents = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_revents == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1241, __pyx_L3_error) + __pyx_v_callback = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("feed", 0, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1241, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0; + __Pyx_AddTraceback("gevent.libev.corecext.idle.feed", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4idle_2feed(((struct PyGeventIdleObject *)__pyx_v_self), __pyx_v_revents, __pyx_v_callback, __pyx_v_args); + + /* function exit code */ + __Pyx_XDECREF(__pyx_v_args); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4idle_2feed(struct PyGeventIdleObject *__pyx_v_self, int __pyx_v_revents, PyObject *__pyx_v_callback, PyObject *__pyx_v_args) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("feed", 0); + + __pyx_t_1 = ((!(__pyx_v_self->loop->_ptr != 0)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__53, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1244, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__48, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1244, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__52, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1244, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1244, __pyx_L1_error) + + } + + if (__Pyx_PyObject_SetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_callback, __pyx_v_callback) < 0) __PYX_ERR(0, 1245, __pyx_L1_error) + + __Pyx_INCREF(__pyx_v_args); + __Pyx_GIVEREF(__pyx_v_args); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = __pyx_v_args; + + __pyx_t_1 = (((__pyx_v_self->_flags & 6) == 4) != 0); + if (__pyx_t_1) { + + ev_unref(__pyx_v_self->loop->_ptr); + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 2); + + } + + ev_feed_event(__pyx_v_self->loop->_ptr, (&__pyx_v_self->_watcher), __pyx_v_revents); + + __pyx_t_1 = ((!((__pyx_v_self->_flags & 1) != 0)) != 0); + if (__pyx_t_1) { + + Py_INCREF(((PyObject*)__pyx_v_self)); + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 1); + + } + + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.idle.feed", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4idle_5start(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4idle_5start(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_callback = 0; + PyObject *__pyx_v_args = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("start (wrapper)", 0); + if (PyTuple_GET_SIZE(__pyx_args) > 1) { + __pyx_v_args = PyTuple_GetSlice(__pyx_args, 1, PyTuple_GET_SIZE(__pyx_args)); + if (unlikely(!__pyx_v_args)) { + __Pyx_RefNannyFinishContext(); + return NULL; + } + __Pyx_GOTREF(__pyx_v_args); + } else { + __pyx_v_args = __pyx_empty_tuple; __Pyx_INCREF(__pyx_empty_tuple); + } + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_callback,0}; + PyObject* values[1] = {0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + default: + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_callback)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t used_pos_args = (pos_args < 1) ? pos_args : 1; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, used_pos_args, "start") < 0)) __PYX_ERR(0, 1255, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) < 1) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + } + __pyx_v_callback = values[0]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("start", 0, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1255, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0; + __Pyx_AddTraceback("gevent.libev.corecext.idle.start", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4idle_4start(((struct PyGeventIdleObject *)__pyx_v_self), __pyx_v_callback, __pyx_v_args); + + /* function exit code */ + __Pyx_XDECREF(__pyx_v_args); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4idle_4start(struct PyGeventIdleObject *__pyx_v_self, PyObject *__pyx_v_callback, PyObject *__pyx_v_args) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + __Pyx_RefNannySetupContext("start", 0); + + __pyx_t_1 = ((!(__pyx_v_self->loop->_ptr != 0)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__54, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1258, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__49, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1258, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__53, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1258, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1258, __pyx_L1_error) + + } + + __pyx_t_1 = (__pyx_v_callback == Py_None); + __pyx_t_3 = (__pyx_t_1 != 0); + if (__pyx_t_3) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__55, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1260, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__50, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1260, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__54, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1260, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1260, __pyx_L1_error) + + } + + if (__Pyx_PyObject_SetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_callback, __pyx_v_callback) < 0) __PYX_ERR(0, 1261, __pyx_L1_error) + + __Pyx_INCREF(__pyx_v_args); + __Pyx_GIVEREF(__pyx_v_args); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = __pyx_v_args; + + __pyx_t_3 = (((__pyx_v_self->_flags & 6) == 4) != 0); + if (__pyx_t_3) { + + ev_unref(__pyx_v_self->loop->_ptr); + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 2); + + } + + ev_idle_start(__pyx_v_self->loop->_ptr, (&__pyx_v_self->_watcher)); + + __pyx_t_3 = ((!((__pyx_v_self->_flags & 1) != 0)) != 0); + if (__pyx_t_3) { + + Py_INCREF(((PyObject*)__pyx_v_self)); + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 1); + + } + + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.idle.start", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4idle_6active_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4idle_6active_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4idle_6active___get__(((struct PyGeventIdleObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4idle_6active___get__(struct PyGeventIdleObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + if ((ev_is_active((&__pyx_v_self->_watcher)) != 0)) { + __Pyx_INCREF(Py_True); + __pyx_t_1 = Py_True; + } else { + __Pyx_INCREF(Py_False); + __pyx_t_1 = Py_False; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4idle_7pending_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4idle_7pending_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4idle_7pending___get__(((struct PyGeventIdleObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4idle_7pending___get__(struct PyGeventIdleObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + if ((ev_is_pending((&__pyx_v_self->_watcher)) != 0)) { + __Pyx_INCREF(Py_True); + __pyx_t_1 = Py_True; + } else { + __Pyx_INCREF(Py_False); + __pyx_t_1 = Py_False; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_4idle_7__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_4idle_7__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + struct PyGeventLoopObject *__pyx_v_loop = 0; + PyObject *__pyx_v_ref = 0; + PyObject *__pyx_v_priority = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_loop,&__pyx_n_s_ref,&__pyx_n_s_priority,0}; + PyObject* values[3] = {0,0,0}; + values[1] = ((PyObject *)Py_True); + values[2] = ((PyObject *)Py_None); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_loop)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ref); + if (value) { values[1] = value; kw_args--; } + } + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_priority); + if (value) { values[2] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 1283, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_loop = ((struct PyGeventLoopObject *)values[0]); + __pyx_v_ref = values[1]; + __pyx_v_priority = values[2]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1283, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.libev.corecext.idle.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_loop), __pyx_ptype_6gevent_5libev_8corecext_loop, 1, "loop", 0))) __PYX_ERR(0, 1283, __pyx_L1_error) + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4idle_6__init__(((struct PyGeventIdleObject *)__pyx_v_self), __pyx_v_loop, __pyx_v_ref, __pyx_v_priority); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_4idle_6__init__(struct PyGeventIdleObject *__pyx_v_self, struct PyGeventLoopObject *__pyx_v_loop, PyObject *__pyx_v_ref, PyObject *__pyx_v_priority) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + __Pyx_RefNannySetupContext("__init__", 0); + + ev_idle_init((&__pyx_v_self->_watcher), ((void *)gevent_callback_idle)); + + __Pyx_INCREF(((PyObject *)__pyx_v_loop)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_loop)); + __Pyx_GOTREF(__pyx_v_self->loop); + __Pyx_DECREF(((PyObject *)__pyx_v_self->loop)); + __pyx_v_self->loop = __pyx_v_loop; + + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_ref); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1286, __pyx_L1_error) + if (__pyx_t_1) { + + __pyx_v_self->_flags = 0; + + goto __pyx_L3; + } + + /*else*/ { + __pyx_v_self->_flags = 4; + } + __pyx_L3:; + + __pyx_t_1 = (__pyx_v_priority != Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_v_priority); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1291, __pyx_L1_error) + ev_set_priority((&__pyx_v_self->_watcher), __pyx_t_3); + + } + + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("gevent.libev.corecext.idle.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4idle_4loop_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4idle_4loop_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4idle_4loop___get__(((struct PyGeventIdleObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4idle_4loop___get__(struct PyGeventIdleObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self->loop)); + __pyx_r = ((PyObject *)__pyx_v_self->loop); + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_4idle_4loop_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_4idle_4loop_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4idle_4loop_2__set__(((struct PyGeventIdleObject *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_4idle_4loop_2__set__(struct PyGeventIdleObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__set__", 0); + if (!(likely(((__pyx_v_value) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_value, __pyx_ptype_6gevent_5libev_8corecext_loop))))) __PYX_ERR(0, 1178, __pyx_L1_error) + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->loop); + __Pyx_DECREF(((PyObject *)__pyx_v_self->loop)); + __pyx_v_self->loop = ((struct PyGeventLoopObject *)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.idle.loop.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_4idle_4loop_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_4idle_4loop_5__del__(PyObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4idle_4loop_4__del__(((struct PyGeventIdleObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_4idle_4loop_4__del__(struct PyGeventIdleObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 0); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->loop); + __Pyx_DECREF(((PyObject *)__pyx_v_self->loop)); + __pyx_v_self->loop = ((struct PyGeventLoopObject *)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4idle_4args_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4idle_4args_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4idle_4args___get__(((struct PyGeventIdleObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4idle_4args___get__(struct PyGeventIdleObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->args); + __pyx_r = __pyx_v_self->args; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_4idle_4args_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_4idle_4args_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4idle_4args_2__set__(((struct PyGeventIdleObject *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_4idle_4args_2__set__(struct PyGeventIdleObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__set__", 0); + if (!(likely(PyTuple_CheckExact(__pyx_v_value))||((__pyx_v_value) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v_value)->tp_name), 0))) __PYX_ERR(0, 1180, __pyx_L1_error) + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.idle.args.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_4idle_4args_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_4idle_4args_5__del__(PyObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4idle_4args_4__del__(((struct PyGeventIdleObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_4idle_4args_4__del__(struct PyGeventIdleObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 0); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = ((PyObject*)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4idle_6_flags_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4idle_6_flags_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4idle_6_flags___get__(((struct PyGeventIdleObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4idle_6_flags___get__(struct PyGeventIdleObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1181, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.idle._flags.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_7prepare_3ref_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_7prepare_3ref_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_7prepare_3ref___get__(((struct PyGeventPrepareObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_7prepare_3ref___get__(struct PyGeventPrepareObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + if (((__pyx_v_self->_flags & 4) != 0)) { + __Pyx_INCREF(Py_False); + __pyx_t_1 = Py_False; + } else { + __Pyx_INCREF(Py_True); + __pyx_t_1 = Py_True; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_7prepare_3ref_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_7prepare_3ref_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_7prepare_3ref_2__set__(((struct PyGeventPrepareObject *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_7prepare_3ref_2__set__(struct PyGeventPrepareObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + __Pyx_RefNannySetupContext("__set__", 0); + + __pyx_t_1 = ((!(__pyx_v_self->loop->_ptr != 0)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__56, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1311, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__51, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1311, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__55, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1311, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1311, __pyx_L1_error) + + } + + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_value); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1312, __pyx_L1_error) + if (__pyx_t_1) { + + __pyx_t_1 = ((!((__pyx_v_self->_flags & 4) != 0)) != 0); + if (__pyx_t_1) { + + __pyx_r = 0; + goto __pyx_L0; + + } + + __pyx_t_1 = ((__pyx_v_self->_flags & 2) != 0); + if (__pyx_t_1) { + + ev_ref(__pyx_v_self->loop->_ptr); + + } + + __pyx_v_self->_flags = (__pyx_v_self->_flags & (~6)); + + goto __pyx_L4; + } + + /*else*/ { + __pyx_t_1 = ((__pyx_v_self->_flags & 4) != 0); + if (__pyx_t_1) { + + __pyx_r = 0; + goto __pyx_L0; + + } + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 4); + + __pyx_t_3 = ((!((__pyx_v_self->_flags & 2) != 0)) != 0); + if (__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L9_bool_binop_done; + } + __pyx_t_3 = (ev_is_active((&__pyx_v_self->_watcher)) != 0); + __pyx_t_1 = __pyx_t_3; + __pyx_L9_bool_binop_done:; + if (__pyx_t_1) { + + ev_unref(__pyx_v_self->loop->_ptr); + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 2); + + } + } + __pyx_L4:; + + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.prepare.ref.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_7prepare_8callback_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_7prepare_8callback_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_7prepare_8callback___get__(((struct PyGeventPrepareObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_7prepare_8callback___get__(struct PyGeventPrepareObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->_callback); + __pyx_r = __pyx_v_self->_callback; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_7prepare_8callback_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_callback); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_7prepare_8callback_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_callback) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_7prepare_8callback_2__set__(((struct PyGeventPrepareObject *)__pyx_v_self), ((PyObject *)__pyx_v_callback)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_7prepare_8callback_2__set__(struct PyGeventPrepareObject *__pyx_v_self, PyObject *__pyx_v_callback) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + __Pyx_RefNannySetupContext("__set__", 0); + + __pyx_t_2 = ((!(PyCallable_Check(((PyObject*)__pyx_v_callback)) != 0)) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_2 = (__pyx_v_callback != Py_None); + __pyx_t_3 = (__pyx_t_2 != 0); + __pyx_t_1 = __pyx_t_3; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { + + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1333, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_v_callback); + __Pyx_GIVEREF(__pyx_v_callback); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_callback); + __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_Expected_callable_not_r, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1333, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1333, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1333, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_5, 0, 0, 0); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __PYX_ERR(0, 1333, __pyx_L1_error) + + } + + __Pyx_INCREF(__pyx_v_callback); + __Pyx_GIVEREF(__pyx_v_callback); + __Pyx_GOTREF(__pyx_v_self->_callback); + __Pyx_DECREF(__pyx_v_self->_callback); + __pyx_v_self->_callback = __pyx_v_callback; + + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("gevent.libev.corecext.prepare.callback.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_7prepare_1stop(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_7prepare_1stop(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("stop (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_7prepare_stop(((struct PyGeventPrepareObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_7prepare_stop(struct PyGeventPrepareObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("stop", 0); + + __pyx_t_1 = ((!(__pyx_v_self->loop->_ptr != 0)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__57, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1339, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__52, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1339, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__56, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1339, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1339, __pyx_L1_error) + + } + + __pyx_t_1 = ((__pyx_v_self->_flags & 2) != 0); + if (__pyx_t_1) { + + ev_ref(__pyx_v_self->loop->_ptr); + + __pyx_v_self->_flags = (__pyx_v_self->_flags & (~2)); + + } + + ev_prepare_stop(__pyx_v_self->loop->_ptr, (&__pyx_v_self->_watcher)); + + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->_callback); + __Pyx_DECREF(__pyx_v_self->_callback); + __pyx_v_self->_callback = Py_None; + + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = ((PyObject*)Py_None); + + __pyx_t_1 = ((__pyx_v_self->_flags & 1) != 0); + if (__pyx_t_1) { + + Py_DECREF(((PyObject*)__pyx_v_self)); + + __pyx_v_self->_flags = (__pyx_v_self->_flags & (~1)); + + } + + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.prepare.stop", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_7prepare_8priority_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_7prepare_8priority_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_7prepare_8priority___get__(((struct PyGeventPrepareObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_7prepare_8priority___get__(struct PyGeventPrepareObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(ev_priority((&__pyx_v_self->_watcher))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1353, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.prepare.priority.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_7prepare_8priority_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_priority); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_7prepare_8priority_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_priority) { + int __pyx_v_priority; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_priority); { + __pyx_v_priority = __Pyx_PyInt_As_int(__pyx_arg_priority); if (unlikely((__pyx_v_priority == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1355, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.libev.corecext.prepare.priority.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_7prepare_8priority_2__set__(((struct PyGeventPrepareObject *)__pyx_v_self), ((int)__pyx_v_priority)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_7prepare_8priority_2__set__(struct PyGeventPrepareObject *__pyx_v_self, int __pyx_v_priority) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("__set__", 0); + + __pyx_t_1 = (ev_is_active((&__pyx_v_self->_watcher)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__58, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1357, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__53, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1357, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__57, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1357, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1357, __pyx_L1_error) + + } + + ev_set_priority((&__pyx_v_self->_watcher), __pyx_v_priority); + + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.prepare.priority.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_7prepare_3feed(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_7prepare_3feed(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + int __pyx_v_revents; + PyObject *__pyx_v_callback = 0; + PyObject *__pyx_v_args = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("feed (wrapper)", 0); + if (PyTuple_GET_SIZE(__pyx_args) > 2) { + __pyx_v_args = PyTuple_GetSlice(__pyx_args, 2, PyTuple_GET_SIZE(__pyx_args)); + if (unlikely(!__pyx_v_args)) { + __Pyx_RefNannyFinishContext(); + return NULL; + } + __Pyx_GOTREF(__pyx_v_args); + } else { + __pyx_v_args = __pyx_empty_tuple; __Pyx_INCREF(__pyx_empty_tuple); + } + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_revents,&__pyx_n_s_callback,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + default: + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_revents)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_callback)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("feed", 0, 2, 2, 1); __PYX_ERR(0, 1360, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t used_pos_args = (pos_args < 2) ? pos_args : 2; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, used_pos_args, "feed") < 0)) __PYX_ERR(0, 1360, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) < 2) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + } + __pyx_v_revents = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_revents == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1360, __pyx_L3_error) + __pyx_v_callback = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("feed", 0, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1360, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0; + __Pyx_AddTraceback("gevent.libev.corecext.prepare.feed", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_7prepare_2feed(((struct PyGeventPrepareObject *)__pyx_v_self), __pyx_v_revents, __pyx_v_callback, __pyx_v_args); + + /* function exit code */ + __Pyx_XDECREF(__pyx_v_args); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_7prepare_2feed(struct PyGeventPrepareObject *__pyx_v_self, int __pyx_v_revents, PyObject *__pyx_v_callback, PyObject *__pyx_v_args) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("feed", 0); + + __pyx_t_1 = ((!(__pyx_v_self->loop->_ptr != 0)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__59, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1363, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__54, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1363, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__58, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1363, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1363, __pyx_L1_error) + + } + + if (__Pyx_PyObject_SetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_callback, __pyx_v_callback) < 0) __PYX_ERR(0, 1364, __pyx_L1_error) + + __Pyx_INCREF(__pyx_v_args); + __Pyx_GIVEREF(__pyx_v_args); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = __pyx_v_args; + + __pyx_t_1 = (((__pyx_v_self->_flags & 6) == 4) != 0); + if (__pyx_t_1) { + + ev_unref(__pyx_v_self->loop->_ptr); + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 2); + + } + + ev_feed_event(__pyx_v_self->loop->_ptr, (&__pyx_v_self->_watcher), __pyx_v_revents); + + __pyx_t_1 = ((!((__pyx_v_self->_flags & 1) != 0)) != 0); + if (__pyx_t_1) { + + Py_INCREF(((PyObject*)__pyx_v_self)); + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 1); + + } + + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.prepare.feed", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_7prepare_5start(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_7prepare_5start(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_callback = 0; + PyObject *__pyx_v_args = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("start (wrapper)", 0); + if (PyTuple_GET_SIZE(__pyx_args) > 1) { + __pyx_v_args = PyTuple_GetSlice(__pyx_args, 1, PyTuple_GET_SIZE(__pyx_args)); + if (unlikely(!__pyx_v_args)) { + __Pyx_RefNannyFinishContext(); + return NULL; + } + __Pyx_GOTREF(__pyx_v_args); + } else { + __pyx_v_args = __pyx_empty_tuple; __Pyx_INCREF(__pyx_empty_tuple); + } + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_callback,0}; + PyObject* values[1] = {0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + default: + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_callback)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t used_pos_args = (pos_args < 1) ? pos_args : 1; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, used_pos_args, "start") < 0)) __PYX_ERR(0, 1374, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) < 1) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + } + __pyx_v_callback = values[0]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("start", 0, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1374, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0; + __Pyx_AddTraceback("gevent.libev.corecext.prepare.start", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_7prepare_4start(((struct PyGeventPrepareObject *)__pyx_v_self), __pyx_v_callback, __pyx_v_args); + + /* function exit code */ + __Pyx_XDECREF(__pyx_v_args); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_7prepare_4start(struct PyGeventPrepareObject *__pyx_v_self, PyObject *__pyx_v_callback, PyObject *__pyx_v_args) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + __Pyx_RefNannySetupContext("start", 0); + + __pyx_t_1 = ((!(__pyx_v_self->loop->_ptr != 0)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__60, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1377, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__55, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1377, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__59, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1377, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1377, __pyx_L1_error) + + } + + __pyx_t_1 = (__pyx_v_callback == Py_None); + __pyx_t_3 = (__pyx_t_1 != 0); + if (__pyx_t_3) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__61, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1379, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__56, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1379, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__60, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1379, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1379, __pyx_L1_error) + + } + + if (__Pyx_PyObject_SetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_callback, __pyx_v_callback) < 0) __PYX_ERR(0, 1380, __pyx_L1_error) + + __Pyx_INCREF(__pyx_v_args); + __Pyx_GIVEREF(__pyx_v_args); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = __pyx_v_args; + + __pyx_t_3 = (((__pyx_v_self->_flags & 6) == 4) != 0); + if (__pyx_t_3) { + + ev_unref(__pyx_v_self->loop->_ptr); + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 2); + + } + + ev_prepare_start(__pyx_v_self->loop->_ptr, (&__pyx_v_self->_watcher)); + + __pyx_t_3 = ((!((__pyx_v_self->_flags & 1) != 0)) != 0); + if (__pyx_t_3) { + + Py_INCREF(((PyObject*)__pyx_v_self)); + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 1); + + } + + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.prepare.start", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_7prepare_6active_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_7prepare_6active_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_7prepare_6active___get__(((struct PyGeventPrepareObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_7prepare_6active___get__(struct PyGeventPrepareObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + if ((ev_is_active((&__pyx_v_self->_watcher)) != 0)) { + __Pyx_INCREF(Py_True); + __pyx_t_1 = Py_True; + } else { + __Pyx_INCREF(Py_False); + __pyx_t_1 = Py_False; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_7prepare_7pending_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_7prepare_7pending_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_7prepare_7pending___get__(((struct PyGeventPrepareObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_7prepare_7pending___get__(struct PyGeventPrepareObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + if ((ev_is_pending((&__pyx_v_self->_watcher)) != 0)) { + __Pyx_INCREF(Py_True); + __pyx_t_1 = Py_True; + } else { + __Pyx_INCREF(Py_False); + __pyx_t_1 = Py_False; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_7prepare_7__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_7prepare_7__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + struct PyGeventLoopObject *__pyx_v_loop = 0; + PyObject *__pyx_v_ref = 0; + PyObject *__pyx_v_priority = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_loop,&__pyx_n_s_ref,&__pyx_n_s_priority,0}; + PyObject* values[3] = {0,0,0}; + values[1] = ((PyObject *)Py_True); + values[2] = ((PyObject *)Py_None); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_loop)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ref); + if (value) { values[1] = value; kw_args--; } + } + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_priority); + if (value) { values[2] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 1402, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_loop = ((struct PyGeventLoopObject *)values[0]); + __pyx_v_ref = values[1]; + __pyx_v_priority = values[2]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1402, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.libev.corecext.prepare.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_loop), __pyx_ptype_6gevent_5libev_8corecext_loop, 1, "loop", 0))) __PYX_ERR(0, 1402, __pyx_L1_error) + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_7prepare_6__init__(((struct PyGeventPrepareObject *)__pyx_v_self), __pyx_v_loop, __pyx_v_ref, __pyx_v_priority); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_7prepare_6__init__(struct PyGeventPrepareObject *__pyx_v_self, struct PyGeventLoopObject *__pyx_v_loop, PyObject *__pyx_v_ref, PyObject *__pyx_v_priority) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + __Pyx_RefNannySetupContext("__init__", 0); + + ev_prepare_init((&__pyx_v_self->_watcher), ((void *)gevent_callback_prepare)); + + __Pyx_INCREF(((PyObject *)__pyx_v_loop)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_loop)); + __Pyx_GOTREF(__pyx_v_self->loop); + __Pyx_DECREF(((PyObject *)__pyx_v_self->loop)); + __pyx_v_self->loop = __pyx_v_loop; + + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_ref); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1405, __pyx_L1_error) + if (__pyx_t_1) { + + __pyx_v_self->_flags = 0; + + goto __pyx_L3; + } + + /*else*/ { + __pyx_v_self->_flags = 4; + } + __pyx_L3:; + + __pyx_t_1 = (__pyx_v_priority != Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_v_priority); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1410, __pyx_L1_error) + ev_set_priority((&__pyx_v_self->_watcher), __pyx_t_3); + + } + + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("gevent.libev.corecext.prepare.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_7prepare_4loop_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_7prepare_4loop_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_7prepare_4loop___get__(((struct PyGeventPrepareObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_7prepare_4loop___get__(struct PyGeventPrepareObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self->loop)); + __pyx_r = ((PyObject *)__pyx_v_self->loop); + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_7prepare_4loop_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_7prepare_4loop_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_7prepare_4loop_2__set__(((struct PyGeventPrepareObject *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_7prepare_4loop_2__set__(struct PyGeventPrepareObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__set__", 0); + if (!(likely(((__pyx_v_value) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_value, __pyx_ptype_6gevent_5libev_8corecext_loop))))) __PYX_ERR(0, 1297, __pyx_L1_error) + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->loop); + __Pyx_DECREF(((PyObject *)__pyx_v_self->loop)); + __pyx_v_self->loop = ((struct PyGeventLoopObject *)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.prepare.loop.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_7prepare_4loop_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_7prepare_4loop_5__del__(PyObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_7prepare_4loop_4__del__(((struct PyGeventPrepareObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_7prepare_4loop_4__del__(struct PyGeventPrepareObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 0); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->loop); + __Pyx_DECREF(((PyObject *)__pyx_v_self->loop)); + __pyx_v_self->loop = ((struct PyGeventLoopObject *)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_7prepare_4args_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_7prepare_4args_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_7prepare_4args___get__(((struct PyGeventPrepareObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_7prepare_4args___get__(struct PyGeventPrepareObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->args); + __pyx_r = __pyx_v_self->args; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_7prepare_4args_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_7prepare_4args_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_7prepare_4args_2__set__(((struct PyGeventPrepareObject *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_7prepare_4args_2__set__(struct PyGeventPrepareObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__set__", 0); + if (!(likely(PyTuple_CheckExact(__pyx_v_value))||((__pyx_v_value) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v_value)->tp_name), 0))) __PYX_ERR(0, 1299, __pyx_L1_error) + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.prepare.args.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_7prepare_4args_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_7prepare_4args_5__del__(PyObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_7prepare_4args_4__del__(((struct PyGeventPrepareObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_7prepare_4args_4__del__(struct PyGeventPrepareObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 0); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = ((PyObject*)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_7prepare_6_flags_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_7prepare_6_flags_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_7prepare_6_flags___get__(((struct PyGeventPrepareObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_7prepare_6_flags___get__(struct PyGeventPrepareObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1300, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.prepare._flags.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5check_3ref_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5check_3ref_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5check_3ref___get__(((struct PyGeventCheckObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5check_3ref___get__(struct PyGeventCheckObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + if (((__pyx_v_self->_flags & 4) != 0)) { + __Pyx_INCREF(Py_False); + __pyx_t_1 = Py_False; + } else { + __Pyx_INCREF(Py_True); + __pyx_t_1 = Py_True; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_5check_3ref_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_5check_3ref_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5check_3ref_2__set__(((struct PyGeventCheckObject *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_5check_3ref_2__set__(struct PyGeventCheckObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + __Pyx_RefNannySetupContext("__set__", 0); + + __pyx_t_1 = ((!(__pyx_v_self->loop->_ptr != 0)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__62, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1430, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__57, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1430, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__61, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1430, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1430, __pyx_L1_error) + + } + + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_value); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1431, __pyx_L1_error) + if (__pyx_t_1) { + + __pyx_t_1 = ((!((__pyx_v_self->_flags & 4) != 0)) != 0); + if (__pyx_t_1) { + + __pyx_r = 0; + goto __pyx_L0; + + } + + __pyx_t_1 = ((__pyx_v_self->_flags & 2) != 0); + if (__pyx_t_1) { + + ev_ref(__pyx_v_self->loop->_ptr); + + } + + __pyx_v_self->_flags = (__pyx_v_self->_flags & (~6)); + + goto __pyx_L4; + } + + /*else*/ { + __pyx_t_1 = ((__pyx_v_self->_flags & 4) != 0); + if (__pyx_t_1) { + + __pyx_r = 0; + goto __pyx_L0; + + } + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 4); + + __pyx_t_3 = ((!((__pyx_v_self->_flags & 2) != 0)) != 0); + if (__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L9_bool_binop_done; + } + __pyx_t_3 = (ev_is_active((&__pyx_v_self->_watcher)) != 0); + __pyx_t_1 = __pyx_t_3; + __pyx_L9_bool_binop_done:; + if (__pyx_t_1) { + + ev_unref(__pyx_v_self->loop->_ptr); + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 2); + + } + } + __pyx_L4:; + + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.check.ref.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5check_8callback_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5check_8callback_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5check_8callback___get__(((struct PyGeventCheckObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5check_8callback___get__(struct PyGeventCheckObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->_callback); + __pyx_r = __pyx_v_self->_callback; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_5check_8callback_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_callback); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_5check_8callback_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_callback) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5check_8callback_2__set__(((struct PyGeventCheckObject *)__pyx_v_self), ((PyObject *)__pyx_v_callback)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_5check_8callback_2__set__(struct PyGeventCheckObject *__pyx_v_self, PyObject *__pyx_v_callback) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + __Pyx_RefNannySetupContext("__set__", 0); + + __pyx_t_2 = ((!(PyCallable_Check(((PyObject*)__pyx_v_callback)) != 0)) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_2 = (__pyx_v_callback != Py_None); + __pyx_t_3 = (__pyx_t_2 != 0); + __pyx_t_1 = __pyx_t_3; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { + + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1452, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_v_callback); + __Pyx_GIVEREF(__pyx_v_callback); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_callback); + __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_Expected_callable_not_r, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1452, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1452, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1452, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_5, 0, 0, 0); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __PYX_ERR(0, 1452, __pyx_L1_error) + + } + + __Pyx_INCREF(__pyx_v_callback); + __Pyx_GIVEREF(__pyx_v_callback); + __Pyx_GOTREF(__pyx_v_self->_callback); + __Pyx_DECREF(__pyx_v_self->_callback); + __pyx_v_self->_callback = __pyx_v_callback; + + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("gevent.libev.corecext.check.callback.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5check_1stop(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5check_1stop(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("stop (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5check_stop(((struct PyGeventCheckObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5check_stop(struct PyGeventCheckObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("stop", 0); + + __pyx_t_1 = ((!(__pyx_v_self->loop->_ptr != 0)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__63, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1458, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__58, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1458, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__62, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1458, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1458, __pyx_L1_error) + + } + + __pyx_t_1 = ((__pyx_v_self->_flags & 2) != 0); + if (__pyx_t_1) { + + ev_ref(__pyx_v_self->loop->_ptr); + + __pyx_v_self->_flags = (__pyx_v_self->_flags & (~2)); + + } + + ev_check_stop(__pyx_v_self->loop->_ptr, (&__pyx_v_self->_watcher)); + + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->_callback); + __Pyx_DECREF(__pyx_v_self->_callback); + __pyx_v_self->_callback = Py_None; + + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = ((PyObject*)Py_None); + + __pyx_t_1 = ((__pyx_v_self->_flags & 1) != 0); + if (__pyx_t_1) { + + Py_DECREF(((PyObject*)__pyx_v_self)); + + __pyx_v_self->_flags = (__pyx_v_self->_flags & (~1)); + + } + + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.check.stop", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5check_8priority_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5check_8priority_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5check_8priority___get__(((struct PyGeventCheckObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5check_8priority___get__(struct PyGeventCheckObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(ev_priority((&__pyx_v_self->_watcher))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1472, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.check.priority.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_5check_8priority_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_priority); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_5check_8priority_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_priority) { + int __pyx_v_priority; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_priority); { + __pyx_v_priority = __Pyx_PyInt_As_int(__pyx_arg_priority); if (unlikely((__pyx_v_priority == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1474, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.libev.corecext.check.priority.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5check_8priority_2__set__(((struct PyGeventCheckObject *)__pyx_v_self), ((int)__pyx_v_priority)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_5check_8priority_2__set__(struct PyGeventCheckObject *__pyx_v_self, int __pyx_v_priority) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("__set__", 0); + + __pyx_t_1 = (ev_is_active((&__pyx_v_self->_watcher)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__64, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1476, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__59, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1476, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__63, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1476, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1476, __pyx_L1_error) + + } + + ev_set_priority((&__pyx_v_self->_watcher), __pyx_v_priority); + + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.check.priority.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5check_3feed(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5check_3feed(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + int __pyx_v_revents; + PyObject *__pyx_v_callback = 0; + PyObject *__pyx_v_args = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("feed (wrapper)", 0); + if (PyTuple_GET_SIZE(__pyx_args) > 2) { + __pyx_v_args = PyTuple_GetSlice(__pyx_args, 2, PyTuple_GET_SIZE(__pyx_args)); + if (unlikely(!__pyx_v_args)) { + __Pyx_RefNannyFinishContext(); + return NULL; + } + __Pyx_GOTREF(__pyx_v_args); + } else { + __pyx_v_args = __pyx_empty_tuple; __Pyx_INCREF(__pyx_empty_tuple); + } + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_revents,&__pyx_n_s_callback,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + default: + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_revents)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_callback)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("feed", 0, 2, 2, 1); __PYX_ERR(0, 1479, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t used_pos_args = (pos_args < 2) ? pos_args : 2; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, used_pos_args, "feed") < 0)) __PYX_ERR(0, 1479, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) < 2) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + } + __pyx_v_revents = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_revents == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1479, __pyx_L3_error) + __pyx_v_callback = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("feed", 0, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1479, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0; + __Pyx_AddTraceback("gevent.libev.corecext.check.feed", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5check_2feed(((struct PyGeventCheckObject *)__pyx_v_self), __pyx_v_revents, __pyx_v_callback, __pyx_v_args); + + /* function exit code */ + __Pyx_XDECREF(__pyx_v_args); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5check_2feed(struct PyGeventCheckObject *__pyx_v_self, int __pyx_v_revents, PyObject *__pyx_v_callback, PyObject *__pyx_v_args) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("feed", 0); + + __pyx_t_1 = ((!(__pyx_v_self->loop->_ptr != 0)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__65, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1482, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__60, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1482, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__64, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1482, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1482, __pyx_L1_error) + + } + + if (__Pyx_PyObject_SetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_callback, __pyx_v_callback) < 0) __PYX_ERR(0, 1483, __pyx_L1_error) + + __Pyx_INCREF(__pyx_v_args); + __Pyx_GIVEREF(__pyx_v_args); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = __pyx_v_args; + + __pyx_t_1 = (((__pyx_v_self->_flags & 6) == 4) != 0); + if (__pyx_t_1) { + + ev_unref(__pyx_v_self->loop->_ptr); + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 2); + + } + + ev_feed_event(__pyx_v_self->loop->_ptr, (&__pyx_v_self->_watcher), __pyx_v_revents); + + __pyx_t_1 = ((!((__pyx_v_self->_flags & 1) != 0)) != 0); + if (__pyx_t_1) { + + Py_INCREF(((PyObject*)__pyx_v_self)); + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 1); + + } + + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.check.feed", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5check_5start(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5check_5start(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_callback = 0; + PyObject *__pyx_v_args = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("start (wrapper)", 0); + if (PyTuple_GET_SIZE(__pyx_args) > 1) { + __pyx_v_args = PyTuple_GetSlice(__pyx_args, 1, PyTuple_GET_SIZE(__pyx_args)); + if (unlikely(!__pyx_v_args)) { + __Pyx_RefNannyFinishContext(); + return NULL; + } + __Pyx_GOTREF(__pyx_v_args); + } else { + __pyx_v_args = __pyx_empty_tuple; __Pyx_INCREF(__pyx_empty_tuple); + } + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_callback,0}; + PyObject* values[1] = {0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + default: + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_callback)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t used_pos_args = (pos_args < 1) ? pos_args : 1; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, used_pos_args, "start") < 0)) __PYX_ERR(0, 1493, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) < 1) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + } + __pyx_v_callback = values[0]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("start", 0, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1493, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0; + __Pyx_AddTraceback("gevent.libev.corecext.check.start", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5check_4start(((struct PyGeventCheckObject *)__pyx_v_self), __pyx_v_callback, __pyx_v_args); + + /* function exit code */ + __Pyx_XDECREF(__pyx_v_args); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5check_4start(struct PyGeventCheckObject *__pyx_v_self, PyObject *__pyx_v_callback, PyObject *__pyx_v_args) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + __Pyx_RefNannySetupContext("start", 0); + + __pyx_t_1 = ((!(__pyx_v_self->loop->_ptr != 0)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__66, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1496, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__61, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1496, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__65, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1496, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1496, __pyx_L1_error) + + } + + __pyx_t_1 = (__pyx_v_callback == Py_None); + __pyx_t_3 = (__pyx_t_1 != 0); + if (__pyx_t_3) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__67, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1498, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__62, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1498, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__66, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1498, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1498, __pyx_L1_error) + + } + + if (__Pyx_PyObject_SetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_callback, __pyx_v_callback) < 0) __PYX_ERR(0, 1499, __pyx_L1_error) + + __Pyx_INCREF(__pyx_v_args); + __Pyx_GIVEREF(__pyx_v_args); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = __pyx_v_args; + + __pyx_t_3 = (((__pyx_v_self->_flags & 6) == 4) != 0); + if (__pyx_t_3) { + + ev_unref(__pyx_v_self->loop->_ptr); + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 2); + + } + + ev_check_start(__pyx_v_self->loop->_ptr, (&__pyx_v_self->_watcher)); + + __pyx_t_3 = ((!((__pyx_v_self->_flags & 1) != 0)) != 0); + if (__pyx_t_3) { + + Py_INCREF(((PyObject*)__pyx_v_self)); + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 1); + + } + + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.check.start", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5check_6active_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5check_6active_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5check_6active___get__(((struct PyGeventCheckObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5check_6active___get__(struct PyGeventCheckObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + if ((ev_is_active((&__pyx_v_self->_watcher)) != 0)) { + __Pyx_INCREF(Py_True); + __pyx_t_1 = Py_True; + } else { + __Pyx_INCREF(Py_False); + __pyx_t_1 = Py_False; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5check_7pending_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5check_7pending_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5check_7pending___get__(((struct PyGeventCheckObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5check_7pending___get__(struct PyGeventCheckObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + if ((ev_is_pending((&__pyx_v_self->_watcher)) != 0)) { + __Pyx_INCREF(Py_True); + __pyx_t_1 = Py_True; + } else { + __Pyx_INCREF(Py_False); + __pyx_t_1 = Py_False; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_5check_7__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_5check_7__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + struct PyGeventLoopObject *__pyx_v_loop = 0; + PyObject *__pyx_v_ref = 0; + PyObject *__pyx_v_priority = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_loop,&__pyx_n_s_ref,&__pyx_n_s_priority,0}; + PyObject* values[3] = {0,0,0}; + values[1] = ((PyObject *)Py_True); + values[2] = ((PyObject *)Py_None); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_loop)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ref); + if (value) { values[1] = value; kw_args--; } + } + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_priority); + if (value) { values[2] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 1521, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_loop = ((struct PyGeventLoopObject *)values[0]); + __pyx_v_ref = values[1]; + __pyx_v_priority = values[2]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1521, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.libev.corecext.check.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_loop), __pyx_ptype_6gevent_5libev_8corecext_loop, 1, "loop", 0))) __PYX_ERR(0, 1521, __pyx_L1_error) + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5check_6__init__(((struct PyGeventCheckObject *)__pyx_v_self), __pyx_v_loop, __pyx_v_ref, __pyx_v_priority); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_5check_6__init__(struct PyGeventCheckObject *__pyx_v_self, struct PyGeventLoopObject *__pyx_v_loop, PyObject *__pyx_v_ref, PyObject *__pyx_v_priority) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + __Pyx_RefNannySetupContext("__init__", 0); + + ev_check_init((&__pyx_v_self->_watcher), ((void *)gevent_callback_check)); + + __Pyx_INCREF(((PyObject *)__pyx_v_loop)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_loop)); + __Pyx_GOTREF(__pyx_v_self->loop); + __Pyx_DECREF(((PyObject *)__pyx_v_self->loop)); + __pyx_v_self->loop = __pyx_v_loop; + + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_ref); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1524, __pyx_L1_error) + if (__pyx_t_1) { + + __pyx_v_self->_flags = 0; + + goto __pyx_L3; + } + + /*else*/ { + __pyx_v_self->_flags = 4; + } + __pyx_L3:; + + __pyx_t_1 = (__pyx_v_priority != Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_v_priority); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1529, __pyx_L1_error) + ev_set_priority((&__pyx_v_self->_watcher), __pyx_t_3); + + } + + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("gevent.libev.corecext.check.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5check_4loop_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5check_4loop_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5check_4loop___get__(((struct PyGeventCheckObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5check_4loop___get__(struct PyGeventCheckObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self->loop)); + __pyx_r = ((PyObject *)__pyx_v_self->loop); + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_5check_4loop_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_5check_4loop_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5check_4loop_2__set__(((struct PyGeventCheckObject *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_5check_4loop_2__set__(struct PyGeventCheckObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__set__", 0); + if (!(likely(((__pyx_v_value) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_value, __pyx_ptype_6gevent_5libev_8corecext_loop))))) __PYX_ERR(0, 1416, __pyx_L1_error) + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->loop); + __Pyx_DECREF(((PyObject *)__pyx_v_self->loop)); + __pyx_v_self->loop = ((struct PyGeventLoopObject *)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.check.loop.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_5check_4loop_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_5check_4loop_5__del__(PyObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5check_4loop_4__del__(((struct PyGeventCheckObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_5check_4loop_4__del__(struct PyGeventCheckObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 0); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->loop); + __Pyx_DECREF(((PyObject *)__pyx_v_self->loop)); + __pyx_v_self->loop = ((struct PyGeventLoopObject *)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5check_4args_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5check_4args_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5check_4args___get__(((struct PyGeventCheckObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5check_4args___get__(struct PyGeventCheckObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->args); + __pyx_r = __pyx_v_self->args; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_5check_4args_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_5check_4args_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5check_4args_2__set__(((struct PyGeventCheckObject *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_5check_4args_2__set__(struct PyGeventCheckObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__set__", 0); + if (!(likely(PyTuple_CheckExact(__pyx_v_value))||((__pyx_v_value) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v_value)->tp_name), 0))) __PYX_ERR(0, 1418, __pyx_L1_error) + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.check.args.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_5check_4args_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_5check_4args_5__del__(PyObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5check_4args_4__del__(((struct PyGeventCheckObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_5check_4args_4__del__(struct PyGeventCheckObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 0); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = ((PyObject*)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5check_6_flags_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5check_6_flags_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5check_6_flags___get__(((struct PyGeventCheckObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5check_6_flags___get__(struct PyGeventCheckObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1419, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.check._flags.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4fork_3ref_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4fork_3ref_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4fork_3ref___get__(((struct PyGeventForkObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4fork_3ref___get__(struct PyGeventForkObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + if (((__pyx_v_self->_flags & 4) != 0)) { + __Pyx_INCREF(Py_False); + __pyx_t_1 = Py_False; + } else { + __Pyx_INCREF(Py_True); + __pyx_t_1 = Py_True; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_4fork_3ref_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_4fork_3ref_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4fork_3ref_2__set__(((struct PyGeventForkObject *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_4fork_3ref_2__set__(struct PyGeventForkObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + __Pyx_RefNannySetupContext("__set__", 0); + + __pyx_t_1 = ((!(__pyx_v_self->loop->_ptr != 0)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__68, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1549, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__63, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1549, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__67, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1549, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1549, __pyx_L1_error) + + } + + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_value); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1550, __pyx_L1_error) + if (__pyx_t_1) { + + __pyx_t_1 = ((!((__pyx_v_self->_flags & 4) != 0)) != 0); + if (__pyx_t_1) { + + __pyx_r = 0; + goto __pyx_L0; + + } + + __pyx_t_1 = ((__pyx_v_self->_flags & 2) != 0); + if (__pyx_t_1) { + + ev_ref(__pyx_v_self->loop->_ptr); + + } + + __pyx_v_self->_flags = (__pyx_v_self->_flags & (~6)); + + goto __pyx_L4; + } + + /*else*/ { + __pyx_t_1 = ((__pyx_v_self->_flags & 4) != 0); + if (__pyx_t_1) { + + __pyx_r = 0; + goto __pyx_L0; + + } + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 4); + + __pyx_t_3 = ((!((__pyx_v_self->_flags & 2) != 0)) != 0); + if (__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L9_bool_binop_done; + } + __pyx_t_3 = (ev_is_active((&__pyx_v_self->_watcher)) != 0); + __pyx_t_1 = __pyx_t_3; + __pyx_L9_bool_binop_done:; + if (__pyx_t_1) { + + ev_unref(__pyx_v_self->loop->_ptr); + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 2); + + } + } + __pyx_L4:; + + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.fork.ref.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4fork_8callback_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4fork_8callback_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4fork_8callback___get__(((struct PyGeventForkObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4fork_8callback___get__(struct PyGeventForkObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->_callback); + __pyx_r = __pyx_v_self->_callback; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_4fork_8callback_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_callback); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_4fork_8callback_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_callback) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4fork_8callback_2__set__(((struct PyGeventForkObject *)__pyx_v_self), ((PyObject *)__pyx_v_callback)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_4fork_8callback_2__set__(struct PyGeventForkObject *__pyx_v_self, PyObject *__pyx_v_callback) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + __Pyx_RefNannySetupContext("__set__", 0); + + __pyx_t_2 = ((!(PyCallable_Check(((PyObject*)__pyx_v_callback)) != 0)) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_2 = (__pyx_v_callback != Py_None); + __pyx_t_3 = (__pyx_t_2 != 0); + __pyx_t_1 = __pyx_t_3; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { + + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1571, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_v_callback); + __Pyx_GIVEREF(__pyx_v_callback); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_callback); + __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_Expected_callable_not_r, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1571, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1571, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1571, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_5, 0, 0, 0); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __PYX_ERR(0, 1571, __pyx_L1_error) + + } + + __Pyx_INCREF(__pyx_v_callback); + __Pyx_GIVEREF(__pyx_v_callback); + __Pyx_GOTREF(__pyx_v_self->_callback); + __Pyx_DECREF(__pyx_v_self->_callback); + __pyx_v_self->_callback = __pyx_v_callback; + + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("gevent.libev.corecext.fork.callback.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4fork_1stop(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4fork_1stop(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("stop (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4fork_stop(((struct PyGeventForkObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4fork_stop(struct PyGeventForkObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("stop", 0); + + __pyx_t_1 = ((!(__pyx_v_self->loop->_ptr != 0)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__69, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1577, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__64, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1577, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__68, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1577, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1577, __pyx_L1_error) + + } + + __pyx_t_1 = ((__pyx_v_self->_flags & 2) != 0); + if (__pyx_t_1) { + + ev_ref(__pyx_v_self->loop->_ptr); + + __pyx_v_self->_flags = (__pyx_v_self->_flags & (~2)); + + } + + ev_fork_stop(__pyx_v_self->loop->_ptr, (&__pyx_v_self->_watcher)); + + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->_callback); + __Pyx_DECREF(__pyx_v_self->_callback); + __pyx_v_self->_callback = Py_None; + + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = ((PyObject*)Py_None); + + __pyx_t_1 = ((__pyx_v_self->_flags & 1) != 0); + if (__pyx_t_1) { + + Py_DECREF(((PyObject*)__pyx_v_self)); + + __pyx_v_self->_flags = (__pyx_v_self->_flags & (~1)); + + } + + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.fork.stop", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4fork_8priority_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4fork_8priority_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4fork_8priority___get__(((struct PyGeventForkObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4fork_8priority___get__(struct PyGeventForkObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(ev_priority((&__pyx_v_self->_watcher))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1591, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.fork.priority.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_4fork_8priority_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_priority); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_4fork_8priority_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_priority) { + int __pyx_v_priority; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_priority); { + __pyx_v_priority = __Pyx_PyInt_As_int(__pyx_arg_priority); if (unlikely((__pyx_v_priority == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1593, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.libev.corecext.fork.priority.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4fork_8priority_2__set__(((struct PyGeventForkObject *)__pyx_v_self), ((int)__pyx_v_priority)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_4fork_8priority_2__set__(struct PyGeventForkObject *__pyx_v_self, int __pyx_v_priority) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("__set__", 0); + + __pyx_t_1 = (ev_is_active((&__pyx_v_self->_watcher)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__70, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1595, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__65, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1595, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__69, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1595, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1595, __pyx_L1_error) + + } + + ev_set_priority((&__pyx_v_self->_watcher), __pyx_v_priority); + + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.fork.priority.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4fork_3feed(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4fork_3feed(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + int __pyx_v_revents; + PyObject *__pyx_v_callback = 0; + PyObject *__pyx_v_args = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("feed (wrapper)", 0); + if (PyTuple_GET_SIZE(__pyx_args) > 2) { + __pyx_v_args = PyTuple_GetSlice(__pyx_args, 2, PyTuple_GET_SIZE(__pyx_args)); + if (unlikely(!__pyx_v_args)) { + __Pyx_RefNannyFinishContext(); + return NULL; + } + __Pyx_GOTREF(__pyx_v_args); + } else { + __pyx_v_args = __pyx_empty_tuple; __Pyx_INCREF(__pyx_empty_tuple); + } + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_revents,&__pyx_n_s_callback,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + default: + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_revents)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_callback)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("feed", 0, 2, 2, 1); __PYX_ERR(0, 1598, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t used_pos_args = (pos_args < 2) ? pos_args : 2; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, used_pos_args, "feed") < 0)) __PYX_ERR(0, 1598, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) < 2) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + } + __pyx_v_revents = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_revents == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1598, __pyx_L3_error) + __pyx_v_callback = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("feed", 0, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1598, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0; + __Pyx_AddTraceback("gevent.libev.corecext.fork.feed", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4fork_2feed(((struct PyGeventForkObject *)__pyx_v_self), __pyx_v_revents, __pyx_v_callback, __pyx_v_args); + + /* function exit code */ + __Pyx_XDECREF(__pyx_v_args); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4fork_2feed(struct PyGeventForkObject *__pyx_v_self, int __pyx_v_revents, PyObject *__pyx_v_callback, PyObject *__pyx_v_args) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("feed", 0); + + __pyx_t_1 = ((!(__pyx_v_self->loop->_ptr != 0)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__71, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1601, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__66, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1601, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__70, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1601, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1601, __pyx_L1_error) + + } + + if (__Pyx_PyObject_SetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_callback, __pyx_v_callback) < 0) __PYX_ERR(0, 1602, __pyx_L1_error) + + __Pyx_INCREF(__pyx_v_args); + __Pyx_GIVEREF(__pyx_v_args); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = __pyx_v_args; + + __pyx_t_1 = (((__pyx_v_self->_flags & 6) == 4) != 0); + if (__pyx_t_1) { + + ev_unref(__pyx_v_self->loop->_ptr); + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 2); + + } + + ev_feed_event(__pyx_v_self->loop->_ptr, (&__pyx_v_self->_watcher), __pyx_v_revents); + + __pyx_t_1 = ((!((__pyx_v_self->_flags & 1) != 0)) != 0); + if (__pyx_t_1) { + + Py_INCREF(((PyObject*)__pyx_v_self)); + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 1); + + } + + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.fork.feed", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4fork_5start(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4fork_5start(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_callback = 0; + PyObject *__pyx_v_args = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("start (wrapper)", 0); + if (PyTuple_GET_SIZE(__pyx_args) > 1) { + __pyx_v_args = PyTuple_GetSlice(__pyx_args, 1, PyTuple_GET_SIZE(__pyx_args)); + if (unlikely(!__pyx_v_args)) { + __Pyx_RefNannyFinishContext(); + return NULL; + } + __Pyx_GOTREF(__pyx_v_args); + } else { + __pyx_v_args = __pyx_empty_tuple; __Pyx_INCREF(__pyx_empty_tuple); + } + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_callback,0}; + PyObject* values[1] = {0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + default: + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_callback)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t used_pos_args = (pos_args < 1) ? pos_args : 1; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, used_pos_args, "start") < 0)) __PYX_ERR(0, 1612, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) < 1) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + } + __pyx_v_callback = values[0]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("start", 0, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1612, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0; + __Pyx_AddTraceback("gevent.libev.corecext.fork.start", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4fork_4start(((struct PyGeventForkObject *)__pyx_v_self), __pyx_v_callback, __pyx_v_args); + + /* function exit code */ + __Pyx_XDECREF(__pyx_v_args); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4fork_4start(struct PyGeventForkObject *__pyx_v_self, PyObject *__pyx_v_callback, PyObject *__pyx_v_args) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + __Pyx_RefNannySetupContext("start", 0); + + __pyx_t_1 = ((!(__pyx_v_self->loop->_ptr != 0)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__72, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1615, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__67, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1615, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__71, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1615, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1615, __pyx_L1_error) + + } + + __pyx_t_1 = (__pyx_v_callback == Py_None); + __pyx_t_3 = (__pyx_t_1 != 0); + if (__pyx_t_3) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__73, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1617, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__68, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1617, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__72, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1617, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1617, __pyx_L1_error) + + } + + if (__Pyx_PyObject_SetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_callback, __pyx_v_callback) < 0) __PYX_ERR(0, 1618, __pyx_L1_error) + + __Pyx_INCREF(__pyx_v_args); + __Pyx_GIVEREF(__pyx_v_args); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = __pyx_v_args; + + __pyx_t_3 = (((__pyx_v_self->_flags & 6) == 4) != 0); + if (__pyx_t_3) { + + ev_unref(__pyx_v_self->loop->_ptr); + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 2); + + } + + ev_fork_start(__pyx_v_self->loop->_ptr, (&__pyx_v_self->_watcher)); + + __pyx_t_3 = ((!((__pyx_v_self->_flags & 1) != 0)) != 0); + if (__pyx_t_3) { + + Py_INCREF(((PyObject*)__pyx_v_self)); + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 1); + + } + + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.fork.start", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4fork_6active_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4fork_6active_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4fork_6active___get__(((struct PyGeventForkObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4fork_6active___get__(struct PyGeventForkObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + if ((ev_is_active((&__pyx_v_self->_watcher)) != 0)) { + __Pyx_INCREF(Py_True); + __pyx_t_1 = Py_True; + } else { + __Pyx_INCREF(Py_False); + __pyx_t_1 = Py_False; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4fork_7pending_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4fork_7pending_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4fork_7pending___get__(((struct PyGeventForkObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4fork_7pending___get__(struct PyGeventForkObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + if ((ev_is_pending((&__pyx_v_self->_watcher)) != 0)) { + __Pyx_INCREF(Py_True); + __pyx_t_1 = Py_True; + } else { + __Pyx_INCREF(Py_False); + __pyx_t_1 = Py_False; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_4fork_7__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_4fork_7__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + struct PyGeventLoopObject *__pyx_v_loop = 0; + PyObject *__pyx_v_ref = 0; + PyObject *__pyx_v_priority = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_loop,&__pyx_n_s_ref,&__pyx_n_s_priority,0}; + PyObject* values[3] = {0,0,0}; + values[1] = ((PyObject *)Py_True); + values[2] = ((PyObject *)Py_None); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_loop)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ref); + if (value) { values[1] = value; kw_args--; } + } + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_priority); + if (value) { values[2] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 1640, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_loop = ((struct PyGeventLoopObject *)values[0]); + __pyx_v_ref = values[1]; + __pyx_v_priority = values[2]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1640, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.libev.corecext.fork.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_loop), __pyx_ptype_6gevent_5libev_8corecext_loop, 1, "loop", 0))) __PYX_ERR(0, 1640, __pyx_L1_error) + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4fork_6__init__(((struct PyGeventForkObject *)__pyx_v_self), __pyx_v_loop, __pyx_v_ref, __pyx_v_priority); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_4fork_6__init__(struct PyGeventForkObject *__pyx_v_self, struct PyGeventLoopObject *__pyx_v_loop, PyObject *__pyx_v_ref, PyObject *__pyx_v_priority) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + __Pyx_RefNannySetupContext("__init__", 0); + + ev_fork_init((&__pyx_v_self->_watcher), ((void *)gevent_callback_fork)); + + __Pyx_INCREF(((PyObject *)__pyx_v_loop)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_loop)); + __Pyx_GOTREF(__pyx_v_self->loop); + __Pyx_DECREF(((PyObject *)__pyx_v_self->loop)); + __pyx_v_self->loop = __pyx_v_loop; + + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_ref); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1643, __pyx_L1_error) + if (__pyx_t_1) { + + __pyx_v_self->_flags = 0; + + goto __pyx_L3; + } + + /*else*/ { + __pyx_v_self->_flags = 4; + } + __pyx_L3:; + + __pyx_t_1 = (__pyx_v_priority != Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_v_priority); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1648, __pyx_L1_error) + ev_set_priority((&__pyx_v_self->_watcher), __pyx_t_3); + + } + + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("gevent.libev.corecext.fork.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4fork_4loop_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4fork_4loop_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4fork_4loop___get__(((struct PyGeventForkObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4fork_4loop___get__(struct PyGeventForkObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self->loop)); + __pyx_r = ((PyObject *)__pyx_v_self->loop); + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_4fork_4loop_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_4fork_4loop_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4fork_4loop_2__set__(((struct PyGeventForkObject *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_4fork_4loop_2__set__(struct PyGeventForkObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__set__", 0); + if (!(likely(((__pyx_v_value) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_value, __pyx_ptype_6gevent_5libev_8corecext_loop))))) __PYX_ERR(0, 1535, __pyx_L1_error) + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->loop); + __Pyx_DECREF(((PyObject *)__pyx_v_self->loop)); + __pyx_v_self->loop = ((struct PyGeventLoopObject *)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.fork.loop.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_4fork_4loop_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_4fork_4loop_5__del__(PyObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4fork_4loop_4__del__(((struct PyGeventForkObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_4fork_4loop_4__del__(struct PyGeventForkObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 0); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->loop); + __Pyx_DECREF(((PyObject *)__pyx_v_self->loop)); + __pyx_v_self->loop = ((struct PyGeventLoopObject *)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4fork_4args_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4fork_4args_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4fork_4args___get__(((struct PyGeventForkObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4fork_4args___get__(struct PyGeventForkObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->args); + __pyx_r = __pyx_v_self->args; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_4fork_4args_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_4fork_4args_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4fork_4args_2__set__(((struct PyGeventForkObject *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_4fork_4args_2__set__(struct PyGeventForkObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__set__", 0); + if (!(likely(PyTuple_CheckExact(__pyx_v_value))||((__pyx_v_value) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v_value)->tp_name), 0))) __PYX_ERR(0, 1537, __pyx_L1_error) + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.fork.args.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_4fork_4args_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_4fork_4args_5__del__(PyObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4fork_4args_4__del__(((struct PyGeventForkObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_4fork_4args_4__del__(struct PyGeventForkObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 0); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = ((PyObject*)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4fork_6_flags_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4fork_6_flags_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4fork_6_flags___get__(((struct PyGeventForkObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4fork_6_flags___get__(struct PyGeventForkObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1538, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.fork._flags.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5async_3ref_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5async_3ref_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5async_3ref___get__(((struct PyGeventAsyncObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5async_3ref___get__(struct PyGeventAsyncObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + if (((__pyx_v_self->_flags & 4) != 0)) { + __Pyx_INCREF(Py_False); + __pyx_t_1 = Py_False; + } else { + __Pyx_INCREF(Py_True); + __pyx_t_1 = Py_True; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_5async_3ref_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_5async_3ref_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5async_3ref_2__set__(((struct PyGeventAsyncObject *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_5async_3ref_2__set__(struct PyGeventAsyncObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + __Pyx_RefNannySetupContext("__set__", 0); + + __pyx_t_1 = ((!(__pyx_v_self->loop->_ptr != 0)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__74, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1668, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__69, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1668, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__73, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1668, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1668, __pyx_L1_error) + + } + + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_value); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1669, __pyx_L1_error) + if (__pyx_t_1) { + + __pyx_t_1 = ((!((__pyx_v_self->_flags & 4) != 0)) != 0); + if (__pyx_t_1) { + + __pyx_r = 0; + goto __pyx_L0; + + } + + __pyx_t_1 = ((__pyx_v_self->_flags & 2) != 0); + if (__pyx_t_1) { + + ev_ref(__pyx_v_self->loop->_ptr); + + } + + __pyx_v_self->_flags = (__pyx_v_self->_flags & (~6)); + + goto __pyx_L4; + } + + /*else*/ { + __pyx_t_1 = ((__pyx_v_self->_flags & 4) != 0); + if (__pyx_t_1) { + + __pyx_r = 0; + goto __pyx_L0; + + } + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 4); + + __pyx_t_3 = ((!((__pyx_v_self->_flags & 2) != 0)) != 0); + if (__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L9_bool_binop_done; + } + __pyx_t_3 = (ev_is_active((&__pyx_v_self->_watcher)) != 0); + __pyx_t_1 = __pyx_t_3; + __pyx_L9_bool_binop_done:; + if (__pyx_t_1) { + + ev_unref(__pyx_v_self->loop->_ptr); + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 2); + + } + } + __pyx_L4:; + + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.async.ref.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5async_8callback_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5async_8callback_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5async_8callback___get__(((struct PyGeventAsyncObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5async_8callback___get__(struct PyGeventAsyncObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->_callback); + __pyx_r = __pyx_v_self->_callback; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_5async_8callback_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_callback); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_5async_8callback_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_callback) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5async_8callback_2__set__(((struct PyGeventAsyncObject *)__pyx_v_self), ((PyObject *)__pyx_v_callback)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_5async_8callback_2__set__(struct PyGeventAsyncObject *__pyx_v_self, PyObject *__pyx_v_callback) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + __Pyx_RefNannySetupContext("__set__", 0); + + __pyx_t_2 = ((!(PyCallable_Check(((PyObject*)__pyx_v_callback)) != 0)) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_2 = (__pyx_v_callback != Py_None); + __pyx_t_3 = (__pyx_t_2 != 0); + __pyx_t_1 = __pyx_t_3; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { + + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1690, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_v_callback); + __Pyx_GIVEREF(__pyx_v_callback); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_callback); + __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_Expected_callable_not_r, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1690, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1690, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1690, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_5, 0, 0, 0); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __PYX_ERR(0, 1690, __pyx_L1_error) + + } + + __Pyx_INCREF(__pyx_v_callback); + __Pyx_GIVEREF(__pyx_v_callback); + __Pyx_GOTREF(__pyx_v_self->_callback); + __Pyx_DECREF(__pyx_v_self->_callback); + __pyx_v_self->_callback = __pyx_v_callback; + + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("gevent.libev.corecext.async.callback.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5async_1stop(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5async_1stop(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("stop (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5async_stop(((struct PyGeventAsyncObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5async_stop(struct PyGeventAsyncObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("stop", 0); + + __pyx_t_1 = ((!(__pyx_v_self->loop->_ptr != 0)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__75, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1696, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__70, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1696, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__74, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1696, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1696, __pyx_L1_error) + + } + + __pyx_t_1 = ((__pyx_v_self->_flags & 2) != 0); + if (__pyx_t_1) { + + ev_ref(__pyx_v_self->loop->_ptr); + + __pyx_v_self->_flags = (__pyx_v_self->_flags & (~2)); + + } + + ev_async_stop(__pyx_v_self->loop->_ptr, (&__pyx_v_self->_watcher)); + + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->_callback); + __Pyx_DECREF(__pyx_v_self->_callback); + __pyx_v_self->_callback = Py_None; + + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = ((PyObject*)Py_None); + + __pyx_t_1 = ((__pyx_v_self->_flags & 1) != 0); + if (__pyx_t_1) { + + Py_DECREF(((PyObject*)__pyx_v_self)); + + __pyx_v_self->_flags = (__pyx_v_self->_flags & (~1)); + + } + + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.async.stop", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5async_8priority_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5async_8priority_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5async_8priority___get__(((struct PyGeventAsyncObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5async_8priority___get__(struct PyGeventAsyncObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(ev_priority((&__pyx_v_self->_watcher))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1710, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.async.priority.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_5async_8priority_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_priority); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_5async_8priority_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_priority) { + int __pyx_v_priority; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_priority); { + __pyx_v_priority = __Pyx_PyInt_As_int(__pyx_arg_priority); if (unlikely((__pyx_v_priority == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1712, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.libev.corecext.async.priority.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5async_8priority_2__set__(((struct PyGeventAsyncObject *)__pyx_v_self), ((int)__pyx_v_priority)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_5async_8priority_2__set__(struct PyGeventAsyncObject *__pyx_v_self, int __pyx_v_priority) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("__set__", 0); + + __pyx_t_1 = (ev_is_active((&__pyx_v_self->_watcher)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__76, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1714, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__71, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1714, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__75, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1714, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1714, __pyx_L1_error) + + } + + ev_set_priority((&__pyx_v_self->_watcher), __pyx_v_priority); + + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.async.priority.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5async_3feed(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5async_3feed(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + int __pyx_v_revents; + PyObject *__pyx_v_callback = 0; + PyObject *__pyx_v_args = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("feed (wrapper)", 0); + if (PyTuple_GET_SIZE(__pyx_args) > 2) { + __pyx_v_args = PyTuple_GetSlice(__pyx_args, 2, PyTuple_GET_SIZE(__pyx_args)); + if (unlikely(!__pyx_v_args)) { + __Pyx_RefNannyFinishContext(); + return NULL; + } + __Pyx_GOTREF(__pyx_v_args); + } else { + __pyx_v_args = __pyx_empty_tuple; __Pyx_INCREF(__pyx_empty_tuple); + } + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_revents,&__pyx_n_s_callback,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + default: + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_revents)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_callback)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("feed", 0, 2, 2, 1); __PYX_ERR(0, 1717, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t used_pos_args = (pos_args < 2) ? pos_args : 2; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, used_pos_args, "feed") < 0)) __PYX_ERR(0, 1717, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) < 2) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + } + __pyx_v_revents = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_revents == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1717, __pyx_L3_error) + __pyx_v_callback = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("feed", 0, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1717, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0; + __Pyx_AddTraceback("gevent.libev.corecext.async.feed", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5async_2feed(((struct PyGeventAsyncObject *)__pyx_v_self), __pyx_v_revents, __pyx_v_callback, __pyx_v_args); + + /* function exit code */ + __Pyx_XDECREF(__pyx_v_args); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5async_2feed(struct PyGeventAsyncObject *__pyx_v_self, int __pyx_v_revents, PyObject *__pyx_v_callback, PyObject *__pyx_v_args) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("feed", 0); + + __pyx_t_1 = ((!(__pyx_v_self->loop->_ptr != 0)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__77, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1720, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__72, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1720, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__76, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1720, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1720, __pyx_L1_error) + + } + + if (__Pyx_PyObject_SetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_callback, __pyx_v_callback) < 0) __PYX_ERR(0, 1721, __pyx_L1_error) + + __Pyx_INCREF(__pyx_v_args); + __Pyx_GIVEREF(__pyx_v_args); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = __pyx_v_args; + + __pyx_t_1 = (((__pyx_v_self->_flags & 6) == 4) != 0); + if (__pyx_t_1) { + + ev_unref(__pyx_v_self->loop->_ptr); + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 2); + + } + + ev_feed_event(__pyx_v_self->loop->_ptr, (&__pyx_v_self->_watcher), __pyx_v_revents); + + __pyx_t_1 = ((!((__pyx_v_self->_flags & 1) != 0)) != 0); + if (__pyx_t_1) { + + Py_INCREF(((PyObject*)__pyx_v_self)); + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 1); + + } + + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.async.feed", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5async_5start(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5async_5start(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_callback = 0; + PyObject *__pyx_v_args = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("start (wrapper)", 0); + if (PyTuple_GET_SIZE(__pyx_args) > 1) { + __pyx_v_args = PyTuple_GetSlice(__pyx_args, 1, PyTuple_GET_SIZE(__pyx_args)); + if (unlikely(!__pyx_v_args)) { + __Pyx_RefNannyFinishContext(); + return NULL; + } + __Pyx_GOTREF(__pyx_v_args); + } else { + __pyx_v_args = __pyx_empty_tuple; __Pyx_INCREF(__pyx_empty_tuple); + } + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_callback,0}; + PyObject* values[1] = {0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + default: + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_callback)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t used_pos_args = (pos_args < 1) ? pos_args : 1; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, used_pos_args, "start") < 0)) __PYX_ERR(0, 1731, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) < 1) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + } + __pyx_v_callback = values[0]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("start", 0, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1731, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0; + __Pyx_AddTraceback("gevent.libev.corecext.async.start", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5async_4start(((struct PyGeventAsyncObject *)__pyx_v_self), __pyx_v_callback, __pyx_v_args); + + /* function exit code */ + __Pyx_XDECREF(__pyx_v_args); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5async_4start(struct PyGeventAsyncObject *__pyx_v_self, PyObject *__pyx_v_callback, PyObject *__pyx_v_args) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + __Pyx_RefNannySetupContext("start", 0); + + __pyx_t_1 = ((!(__pyx_v_self->loop->_ptr != 0)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__78, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1734, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__73, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1734, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__77, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1734, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1734, __pyx_L1_error) + + } + + __pyx_t_1 = (__pyx_v_callback == Py_None); + __pyx_t_3 = (__pyx_t_1 != 0); + if (__pyx_t_3) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__79, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1736, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__74, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1736, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__78, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1736, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1736, __pyx_L1_error) + + } + + if (__Pyx_PyObject_SetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_callback, __pyx_v_callback) < 0) __PYX_ERR(0, 1737, __pyx_L1_error) + + __Pyx_INCREF(__pyx_v_args); + __Pyx_GIVEREF(__pyx_v_args); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = __pyx_v_args; + + __pyx_t_3 = (((__pyx_v_self->_flags & 6) == 4) != 0); + if (__pyx_t_3) { + + ev_unref(__pyx_v_self->loop->_ptr); + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 2); + + } + + ev_async_start(__pyx_v_self->loop->_ptr, (&__pyx_v_self->_watcher)); + + __pyx_t_3 = ((!((__pyx_v_self->_flags & 1) != 0)) != 0); + if (__pyx_t_3) { + + Py_INCREF(((PyObject*)__pyx_v_self)); + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 1); + + } + + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.async.start", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5async_6active_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5async_6active_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5async_6active___get__(((struct PyGeventAsyncObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5async_6active___get__(struct PyGeventAsyncObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + if ((ev_is_active((&__pyx_v_self->_watcher)) != 0)) { + __Pyx_INCREF(Py_True); + __pyx_t_1 = Py_True; + } else { + __Pyx_INCREF(Py_False); + __pyx_t_1 = Py_False; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5async_7pending_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5async_7pending_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5async_7pending___get__(((struct PyGeventAsyncObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5async_7pending___get__(struct PyGeventAsyncObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + if ((ev_async_pending((&__pyx_v_self->_watcher)) != 0)) { + __Pyx_INCREF(Py_True); + __pyx_t_1 = Py_True; + } else { + __Pyx_INCREF(Py_False); + __pyx_t_1 = Py_False; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_5async_7__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_5async_7__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + struct PyGeventLoopObject *__pyx_v_loop = 0; + PyObject *__pyx_v_ref = 0; + PyObject *__pyx_v_priority = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_loop,&__pyx_n_s_ref,&__pyx_n_s_priority,0}; + PyObject* values[3] = {0,0,0}; + values[1] = ((PyObject *)Py_True); + values[2] = ((PyObject *)Py_None); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_loop)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ref); + if (value) { values[1] = value; kw_args--; } + } + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_priority); + if (value) { values[2] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 1758, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_loop = ((struct PyGeventLoopObject *)values[0]); + __pyx_v_ref = values[1]; + __pyx_v_priority = values[2]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1758, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.libev.corecext.async.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_loop), __pyx_ptype_6gevent_5libev_8corecext_loop, 1, "loop", 0))) __PYX_ERR(0, 1758, __pyx_L1_error) + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5async_6__init__(((struct PyGeventAsyncObject *)__pyx_v_self), __pyx_v_loop, __pyx_v_ref, __pyx_v_priority); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_5async_6__init__(struct PyGeventAsyncObject *__pyx_v_self, struct PyGeventLoopObject *__pyx_v_loop, PyObject *__pyx_v_ref, PyObject *__pyx_v_priority) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + __Pyx_RefNannySetupContext("__init__", 0); + + ev_async_init((&__pyx_v_self->_watcher), ((void *)gevent_callback_async)); + + __Pyx_INCREF(((PyObject *)__pyx_v_loop)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_loop)); + __Pyx_GOTREF(__pyx_v_self->loop); + __Pyx_DECREF(((PyObject *)__pyx_v_self->loop)); + __pyx_v_self->loop = __pyx_v_loop; + + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_ref); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1761, __pyx_L1_error) + if (__pyx_t_1) { + + __pyx_v_self->_flags = 0; + + goto __pyx_L3; + } + + /*else*/ { + __pyx_v_self->_flags = 4; + } + __pyx_L3:; + + __pyx_t_1 = (__pyx_v_priority != Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_v_priority); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1766, __pyx_L1_error) + ev_set_priority((&__pyx_v_self->_watcher), __pyx_t_3); + + } + + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("gevent.libev.corecext.async.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5async_9send(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5async_9send(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("send (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5async_8send(((struct PyGeventAsyncObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5async_8send(struct PyGeventAsyncObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("send", 0); + + __pyx_t_1 = ((!(__pyx_v_self->loop->_ptr != 0)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__80, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1771, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__75, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1771, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__79, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1771, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1771, __pyx_L1_error) + + } + + ev_async_send(__pyx_v_self->loop->_ptr, (&__pyx_v_self->_watcher)); + + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.async.send", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5async_4loop_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5async_4loop_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5async_4loop___get__(((struct PyGeventAsyncObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5async_4loop___get__(struct PyGeventAsyncObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self->loop)); + __pyx_r = ((PyObject *)__pyx_v_self->loop); + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_5async_4loop_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_5async_4loop_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5async_4loop_2__set__(((struct PyGeventAsyncObject *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_5async_4loop_2__set__(struct PyGeventAsyncObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__set__", 0); + if (!(likely(((__pyx_v_value) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_value, __pyx_ptype_6gevent_5libev_8corecext_loop))))) __PYX_ERR(0, 1654, __pyx_L1_error) + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->loop); + __Pyx_DECREF(((PyObject *)__pyx_v_self->loop)); + __pyx_v_self->loop = ((struct PyGeventLoopObject *)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.async.loop.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_5async_4loop_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_5async_4loop_5__del__(PyObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5async_4loop_4__del__(((struct PyGeventAsyncObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_5async_4loop_4__del__(struct PyGeventAsyncObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 0); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->loop); + __Pyx_DECREF(((PyObject *)__pyx_v_self->loop)); + __pyx_v_self->loop = ((struct PyGeventLoopObject *)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5async_4args_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5async_4args_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5async_4args___get__(((struct PyGeventAsyncObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5async_4args___get__(struct PyGeventAsyncObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->args); + __pyx_r = __pyx_v_self->args; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_5async_4args_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_5async_4args_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5async_4args_2__set__(((struct PyGeventAsyncObject *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_5async_4args_2__set__(struct PyGeventAsyncObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__set__", 0); + if (!(likely(PyTuple_CheckExact(__pyx_v_value))||((__pyx_v_value) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v_value)->tp_name), 0))) __PYX_ERR(0, 1656, __pyx_L1_error) + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.async.args.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_5async_4args_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_5async_4args_5__del__(PyObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5async_4args_4__del__(((struct PyGeventAsyncObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_5async_4args_4__del__(struct PyGeventAsyncObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 0); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = ((PyObject*)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5async_6_flags_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5async_6_flags_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5async_6_flags___get__(((struct PyGeventAsyncObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5async_6_flags___get__(struct PyGeventAsyncObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1657, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.async._flags.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4stat_3ref_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4stat_3ref_1__get__(PyObject *__pyx_v_self) { +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5child_3ref_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5child_3ref_1__get__(PyObject *__pyx_v_self) { +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4stat_3ref_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4stat_3ref_1__get__(PyObject *__pyx_v_self) { +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4stat_3ref___get__(((struct PyGeventStatObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4stat_3ref___get__(struct PyGeventStatObject *__pyx_v_self) { +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5child_3ref___get__(((struct PyGeventChildObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5child_3ref___get__(struct PyGeventChildObject *__pyx_v_self) { +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4stat_3ref___get__(((struct PyGeventStatObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4stat_3ref___get__(struct PyGeventStatObject *__pyx_v_self) { +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + if (((__pyx_v_self->_flags & 4) != 0)) { + __Pyx_INCREF(Py_False); + __pyx_t_1 = Py_False; + } else { + __Pyx_INCREF(Py_True); + __pyx_t_1 = Py_True; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) +static int __pyx_pw_6gevent_5libev_8corecext_4stat_3ref_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_4stat_3ref_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static int __pyx_pw_6gevent_5libev_8corecext_5child_3ref_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_5child_3ref_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) +static int __pyx_pw_6gevent_5libev_8corecext_4stat_3ref_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_4stat_3ref_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4stat_3ref_2__set__(((struct PyGeventStatObject *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_4stat_3ref_2__set__(struct PyGeventStatObject *__pyx_v_self, PyObject *__pyx_v_value) { +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5child_3ref_2__set__(((struct PyGeventChildObject *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_5child_3ref_2__set__(struct PyGeventChildObject *__pyx_v_self, PyObject *__pyx_v_value) { +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4stat_3ref_2__set__(((struct PyGeventStatObject *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_4stat_3ref_2__set__(struct PyGeventStatObject *__pyx_v_self, PyObject *__pyx_v_value) { +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + __Pyx_RefNannySetupContext("__set__", 0); + + __pyx_t_1 = ((!(__pyx_v_self->loop->_ptr != 0)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__81, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1794, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__76, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1794, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__80, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1939, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__80, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1794, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1794, __pyx_L1_error) + + } + + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_value); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1795, __pyx_L1_error) + if (__pyx_t_1) { + + __pyx_t_1 = ((!((__pyx_v_self->_flags & 4) != 0)) != 0); + if (__pyx_t_1) { + + __pyx_r = 0; + goto __pyx_L0; + + } + + __pyx_t_1 = ((__pyx_v_self->_flags & 2) != 0); + if (__pyx_t_1) { + + ev_ref(__pyx_v_self->loop->_ptr); + + } + + __pyx_v_self->_flags = (__pyx_v_self->_flags & (~6)); + + goto __pyx_L4; + } + + /*else*/ { + __pyx_t_1 = ((__pyx_v_self->_flags & 4) != 0); + if (__pyx_t_1) { + + __pyx_r = 0; + goto __pyx_L0; + + } + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 4); + + __pyx_t_3 = ((!((__pyx_v_self->_flags & 2) != 0)) != 0); + if (__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L9_bool_binop_done; + } + __pyx_t_3 = (ev_is_active((&__pyx_v_self->_watcher)) != 0); + __pyx_t_1 = __pyx_t_3; + __pyx_L9_bool_binop_done:; + if (__pyx_t_1) { + + ev_unref(__pyx_v_self->loop->_ptr); + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 2); + + } + } + __pyx_L4:; + + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.child.ref.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5child_8callback_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5child_8callback_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5child_8callback___get__(((struct PyGeventChildObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5child_8callback___get__(struct PyGeventChildObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->_callback); + __pyx_r = __pyx_v_self->_callback; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_5child_8callback_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_callback); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_5child_8callback_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_callback) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5child_8callback_2__set__(((struct PyGeventChildObject *)__pyx_v_self), ((PyObject *)__pyx_v_callback)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_5child_8callback_2__set__(struct PyGeventChildObject *__pyx_v_self, PyObject *__pyx_v_callback) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + __Pyx_RefNannySetupContext("__set__", 0); + + __pyx_t_2 = ((!(PyCallable_Check(((PyObject*)__pyx_v_callback)) != 0)) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_2 = (__pyx_v_callback != Py_None); + __pyx_t_3 = (__pyx_t_2 != 0); + __pyx_t_1 = __pyx_t_3; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { + + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1816, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_v_callback); + __Pyx_GIVEREF(__pyx_v_callback); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_callback); + __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_Expected_callable_not_r, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1816, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1816, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1816, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_5, 0, 0, 0); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __PYX_ERR(0, 1816, __pyx_L1_error) + + } + + __Pyx_INCREF(__pyx_v_callback); + __Pyx_GIVEREF(__pyx_v_callback); + __Pyx_GOTREF(__pyx_v_self->_callback); + __Pyx_DECREF(__pyx_v_self->_callback); + __pyx_v_self->_callback = __pyx_v_callback; + + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("gevent.libev.corecext.child.callback.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5child_1stop(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5child_1stop(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("stop (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5child_stop(((struct PyGeventChildObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5child_stop(struct PyGeventChildObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("stop", 0); + + __pyx_t_1 = ((!(__pyx_v_self->loop->_ptr != 0)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__82, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1822, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__77, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1822, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__81, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1822, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1822, __pyx_L1_error) + + } + + __pyx_t_1 = ((__pyx_v_self->_flags & 2) != 0); + if (__pyx_t_1) { + + ev_ref(__pyx_v_self->loop->_ptr); + + __pyx_v_self->_flags = (__pyx_v_self->_flags & (~2)); + + } + + ev_child_stop(__pyx_v_self->loop->_ptr, (&__pyx_v_self->_watcher)); + + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->_callback); + __Pyx_DECREF(__pyx_v_self->_callback); + __pyx_v_self->_callback = Py_None; + + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = ((PyObject*)Py_None); + + __pyx_t_1 = ((__pyx_v_self->_flags & 1) != 0); + if (__pyx_t_1) { + + Py_DECREF(((PyObject*)__pyx_v_self)); + + __pyx_v_self->_flags = (__pyx_v_self->_flags & (~1)); + + } + + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.child.stop", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5child_8priority_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5child_8priority_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5child_8priority___get__(((struct PyGeventChildObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5child_8priority___get__(struct PyGeventChildObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(ev_priority((&__pyx_v_self->_watcher))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1836, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.child.priority.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_5child_8priority_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_priority); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_5child_8priority_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_priority) { + int __pyx_v_priority; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_priority); { + __pyx_v_priority = __Pyx_PyInt_As_int(__pyx_arg_priority); if (unlikely((__pyx_v_priority == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1838, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.libev.corecext.child.priority.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5child_8priority_2__set__(((struct PyGeventChildObject *)__pyx_v_self), ((int)__pyx_v_priority)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_5child_8priority_2__set__(struct PyGeventChildObject *__pyx_v_self, int __pyx_v_priority) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("__set__", 0); + + __pyx_t_1 = (ev_is_active((&__pyx_v_self->_watcher)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__83, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1840, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__78, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1840, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__82, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1840, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1840, __pyx_L1_error) + + } + + ev_set_priority((&__pyx_v_self->_watcher), __pyx_v_priority); + + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.child.priority.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5child_3feed(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5child_3feed(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + int __pyx_v_revents; + PyObject *__pyx_v_callback = 0; + PyObject *__pyx_v_args = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("feed (wrapper)", 0); + if (PyTuple_GET_SIZE(__pyx_args) > 2) { + __pyx_v_args = PyTuple_GetSlice(__pyx_args, 2, PyTuple_GET_SIZE(__pyx_args)); + if (unlikely(!__pyx_v_args)) { + __Pyx_RefNannyFinishContext(); + return NULL; + } + __Pyx_GOTREF(__pyx_v_args); + } else { + __pyx_v_args = __pyx_empty_tuple; __Pyx_INCREF(__pyx_empty_tuple); + } + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_revents,&__pyx_n_s_callback,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + default: + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_revents)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_callback)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("feed", 0, 2, 2, 1); __PYX_ERR(0, 1843, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t used_pos_args = (pos_args < 2) ? pos_args : 2; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, used_pos_args, "feed") < 0)) __PYX_ERR(0, 1843, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) < 2) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + } + __pyx_v_revents = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_revents == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1843, __pyx_L3_error) + __pyx_v_callback = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("feed", 0, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1843, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0; + __Pyx_AddTraceback("gevent.libev.corecext.child.feed", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5child_2feed(((struct PyGeventChildObject *)__pyx_v_self), __pyx_v_revents, __pyx_v_callback, __pyx_v_args); + + /* function exit code */ + __Pyx_XDECREF(__pyx_v_args); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5child_2feed(struct PyGeventChildObject *__pyx_v_self, int __pyx_v_revents, PyObject *__pyx_v_callback, PyObject *__pyx_v_args) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("feed", 0); + + __pyx_t_1 = ((!(__pyx_v_self->loop->_ptr != 0)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__84, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1846, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__79, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1846, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__83, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1846, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1846, __pyx_L1_error) + + } + + if (__Pyx_PyObject_SetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_callback, __pyx_v_callback) < 0) __PYX_ERR(0, 1847, __pyx_L1_error) + + __Pyx_INCREF(__pyx_v_args); + __Pyx_GIVEREF(__pyx_v_args); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = __pyx_v_args; + + __pyx_t_1 = (((__pyx_v_self->_flags & 6) == 4) != 0); + if (__pyx_t_1) { + + ev_unref(__pyx_v_self->loop->_ptr); + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 2); + + } + + ev_feed_event(__pyx_v_self->loop->_ptr, (&__pyx_v_self->_watcher), __pyx_v_revents); + + __pyx_t_1 = ((!((__pyx_v_self->_flags & 1) != 0)) != 0); + if (__pyx_t_1) { + + Py_INCREF(((PyObject*)__pyx_v_self)); + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 1); + + } + + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.child.feed", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5child_5start(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5child_5start(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_callback = 0; + PyObject *__pyx_v_args = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("start (wrapper)", 0); + if (PyTuple_GET_SIZE(__pyx_args) > 1) { + __pyx_v_args = PyTuple_GetSlice(__pyx_args, 1, PyTuple_GET_SIZE(__pyx_args)); + if (unlikely(!__pyx_v_args)) { + __Pyx_RefNannyFinishContext(); + return NULL; + } + __Pyx_GOTREF(__pyx_v_args); + } else { + __pyx_v_args = __pyx_empty_tuple; __Pyx_INCREF(__pyx_empty_tuple); + } + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_callback,0}; + PyObject* values[1] = {0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + default: + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_callback)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t used_pos_args = (pos_args < 1) ? pos_args : 1; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, used_pos_args, "start") < 0)) __PYX_ERR(0, 1857, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) < 1) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + } + __pyx_v_callback = values[0]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("start", 0, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1857, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0; + __Pyx_AddTraceback("gevent.libev.corecext.child.start", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5child_4start(((struct PyGeventChildObject *)__pyx_v_self), __pyx_v_callback, __pyx_v_args); + + /* function exit code */ + __Pyx_XDECREF(__pyx_v_args); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5child_4start(struct PyGeventChildObject *__pyx_v_self, PyObject *__pyx_v_callback, PyObject *__pyx_v_args) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + __Pyx_RefNannySetupContext("start", 0); + + __pyx_t_1 = ((!(__pyx_v_self->loop->_ptr != 0)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__85, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1860, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__80, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1860, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__84, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1860, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1860, __pyx_L1_error) + + } + + __pyx_t_1 = (__pyx_v_callback == Py_None); + __pyx_t_3 = (__pyx_t_1 != 0); + if (__pyx_t_3) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__86, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1862, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__81, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1862, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__85, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1862, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1862, __pyx_L1_error) + + } + + if (__Pyx_PyObject_SetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_callback, __pyx_v_callback) < 0) __PYX_ERR(0, 1863, __pyx_L1_error) + + __Pyx_INCREF(__pyx_v_args); + __Pyx_GIVEREF(__pyx_v_args); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = __pyx_v_args; + + __pyx_t_3 = (((__pyx_v_self->_flags & 6) == 4) != 0); + if (__pyx_t_3) { + + ev_unref(__pyx_v_self->loop->_ptr); + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 2); + + } + + ev_child_start(__pyx_v_self->loop->_ptr, (&__pyx_v_self->_watcher)); + + __pyx_t_3 = ((!((__pyx_v_self->_flags & 1) != 0)) != 0); + if (__pyx_t_3) { + + Py_INCREF(((PyObject*)__pyx_v_self)); + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 1); + + } + + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.child.start", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5child_6active_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5child_6active_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5child_6active___get__(((struct PyGeventChildObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5child_6active___get__(struct PyGeventChildObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + if ((ev_is_active((&__pyx_v_self->_watcher)) != 0)) { + __Pyx_INCREF(Py_True); + __pyx_t_1 = Py_True; + } else { + __Pyx_INCREF(Py_False); + __pyx_t_1 = Py_False; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5child_7pending_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5child_7pending_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5child_7pending___get__(((struct PyGeventChildObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5child_7pending___get__(struct PyGeventChildObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + if ((ev_is_pending((&__pyx_v_self->_watcher)) != 0)) { + __Pyx_INCREF(Py_True); + __pyx_t_1 = Py_True; + } else { + __Pyx_INCREF(Py_False); + __pyx_t_1 = Py_False; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_5child_7__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_5child_7__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + struct PyGeventLoopObject *__pyx_v_loop = 0; + int __pyx_v_pid; + int __pyx_v_trace; + PyObject *__pyx_v_ref = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_loop,&__pyx_n_s_pid,&__pyx_n_s_trace,&__pyx_n_s_ref,0}; + PyObject* values[4] = {0,0,0,0}; + values[3] = ((PyObject *)Py_True); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_loop)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pid)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__init__", 0, 2, 4, 1); __PYX_ERR(0, 1884, __pyx_L3_error) + } + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_trace); + if (value) { values[2] = value; kw_args--; } + } + case 3: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ref); + if (value) { values[3] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 1884, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_loop = ((struct PyGeventLoopObject *)values[0]); + __pyx_v_pid = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_pid == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1884, __pyx_L3_error) + if (values[2]) { + __pyx_v_trace = __Pyx_PyObject_IsTrue(values[2]); if (unlikely((__pyx_v_trace == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1884, __pyx_L3_error) + } else { + __pyx_v_trace = ((int)0); + } + __pyx_v_ref = values[3]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 0, 2, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1884, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.libev.corecext.child.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_loop), __pyx_ptype_6gevent_5libev_8corecext_loop, 1, "loop", 0))) __PYX_ERR(0, 1884, __pyx_L1_error) + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5child_6__init__(((struct PyGeventChildObject *)__pyx_v_self), __pyx_v_loop, __pyx_v_pid, __pyx_v_trace, __pyx_v_ref); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_5child_6__init__(struct PyGeventChildObject *__pyx_v_self, struct PyGeventLoopObject *__pyx_v_loop, int __pyx_v_pid, int __pyx_v_trace, PyObject *__pyx_v_ref) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + __Pyx_RefNannySetupContext("__init__", 0); + + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_loop), __pyx_n_s_default); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1885, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 1885, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = ((!__pyx_t_2) != 0); + if (__pyx_t_3) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__87, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1886, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__82, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1886, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__86, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1886, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 1886, __pyx_L1_error) + + } + + gevent_install_sigchld_handler(); + + ev_child_init((&__pyx_v_self->_watcher), ((void *)gevent_callback_child), __pyx_v_pid, __pyx_v_trace); + + __Pyx_INCREF(((PyObject *)__pyx_v_loop)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_loop)); + __Pyx_GOTREF(__pyx_v_self->loop); + __Pyx_DECREF(((PyObject *)__pyx_v_self->loop)); + __pyx_v_self->loop = __pyx_v_loop; + + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_ref); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 1890, __pyx_L1_error) + if (__pyx_t_3) { + + __pyx_v_self->_flags = 0; + + goto __pyx_L4; + } + + /*else*/ { + __pyx_v_self->_flags = 4; + } + __pyx_L4:; + + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.child.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5child_9_format(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5child_9_format(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_format (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5child_8_format(((struct PyGeventChildObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5child_8_format(struct PyGeventChildObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("_format", 0); + + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_pid); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1896, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_rstatus); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1896, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1896, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_pid_r_rstatus_r, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1896, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("gevent.libev.corecext.child._format", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5child_3pid_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5child_3pid_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5child_3pid___get__(((struct PyGeventChildObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5child_3pid___get__(struct PyGeventChildObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->_watcher.pid); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1901, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.child.pid.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5child_4rpid_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5child_4rpid_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5child_4rpid___get__(((struct PyGeventChildObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5child_4rpid___get__(struct PyGeventChildObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->_watcher.rpid); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1906, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.child.rpid.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_5child_4rpid_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_5child_4rpid_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + int __pyx_v_value; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_int(__pyx_arg_value); if (unlikely((__pyx_v_value == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1908, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.libev.corecext.child.rpid.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5child_4rpid_2__set__(((struct PyGeventChildObject *)__pyx_v_self), ((int)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_5child_4rpid_2__set__(struct PyGeventChildObject *__pyx_v_self, int __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + + __pyx_v_self->_watcher.rpid = __pyx_v_value; + + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5child_7rstatus_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5child_7rstatus_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5child_7rstatus___get__(((struct PyGeventChildObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5child_7rstatus___get__(struct PyGeventChildObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->_watcher.rstatus); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1914, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.child.rstatus.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_5child_7rstatus_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_5child_7rstatus_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + int __pyx_v_value; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_int(__pyx_arg_value); if (unlikely((__pyx_v_value == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1916, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.libev.corecext.child.rstatus.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5child_7rstatus_2__set__(((struct PyGeventChildObject *)__pyx_v_self), ((int)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_5child_7rstatus_2__set__(struct PyGeventChildObject *__pyx_v_self, int __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + + __pyx_v_self->_watcher.rstatus = __pyx_v_value; + + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5child_4loop_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5child_4loop_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5child_4loop___get__(((struct PyGeventChildObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5child_4loop___get__(struct PyGeventChildObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self->loop)); + __pyx_r = ((PyObject *)__pyx_v_self->loop); + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_5child_4loop_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_5child_4loop_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5child_4loop_2__set__(((struct PyGeventChildObject *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_5child_4loop_2__set__(struct PyGeventChildObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__set__", 0); + if (!(likely(((__pyx_v_value) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_value, __pyx_ptype_6gevent_5libev_8corecext_loop))))) __PYX_ERR(0, 1780, __pyx_L1_error) + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->loop); + __Pyx_DECREF(((PyObject *)__pyx_v_self->loop)); + __pyx_v_self->loop = ((struct PyGeventLoopObject *)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.child.loop.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_5child_4loop_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_5child_4loop_5__del__(PyObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5child_4loop_4__del__(((struct PyGeventChildObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_5child_4loop_4__del__(struct PyGeventChildObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 0); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->loop); + __Pyx_DECREF(((PyObject *)__pyx_v_self->loop)); + __pyx_v_self->loop = ((struct PyGeventLoopObject *)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5child_4args_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5child_4args_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5child_4args___get__(((struct PyGeventChildObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5child_4args___get__(struct PyGeventChildObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->args); + __pyx_r = __pyx_v_self->args; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_5child_4args_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_5child_4args_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5child_4args_2__set__(((struct PyGeventChildObject *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_5child_4args_2__set__(struct PyGeventChildObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__set__", 0); + if (!(likely(PyTuple_CheckExact(__pyx_v_value))||((__pyx_v_value) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v_value)->tp_name), 0))) __PYX_ERR(0, 1782, __pyx_L1_error) + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.child.args.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_5child_4args_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_5child_4args_5__del__(PyObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5child_4args_4__del__(((struct PyGeventChildObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_5child_4args_4__del__(struct PyGeventChildObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 0); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = ((PyObject*)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5child_6_flags_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_5child_6_flags_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_5child_6_flags___get__(((struct PyGeventChildObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_5child_6_flags___get__(struct PyGeventChildObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1783, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.child._flags.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4stat_3ref_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4stat_3ref_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4stat_3ref___get__(((struct PyGeventStatObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4stat_3ref___get__(struct PyGeventStatObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + if (((__pyx_v_self->_flags & 4) != 0)) { + __Pyx_INCREF(Py_False); + __pyx_t_1 = Py_False; + } else { + __Pyx_INCREF(Py_True); + __pyx_t_1 = Py_True; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_4stat_3ref_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_4stat_3ref_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4stat_3ref_2__set__(((struct PyGeventStatObject *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_4stat_3ref_2__set__(struct PyGeventStatObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + __Pyx_RefNannySetupContext("__set__", 0); + + __pyx_t_1 = ((!(__pyx_v_self->loop->_ptr != 0)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__88, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1939, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__81, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1939, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__83, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1939, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__76, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1939, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__87, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1939, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1939, __pyx_L1_error) + + } + + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_value); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1940, __pyx_L1_error) + if (__pyx_t_1) { + + __pyx_t_1 = ((!((__pyx_v_self->_flags & 4) != 0)) != 0); + if (__pyx_t_1) { + + __pyx_r = 0; + goto __pyx_L0; + + } + + __pyx_t_1 = ((__pyx_v_self->_flags & 2) != 0); + if (__pyx_t_1) { + + ev_ref(__pyx_v_self->loop->_ptr); + + } + + __pyx_v_self->_flags = (__pyx_v_self->_flags & (~6)); + + goto __pyx_L4; + } + + /*else*/ { + __pyx_t_1 = ((__pyx_v_self->_flags & 4) != 0); + if (__pyx_t_1) { + + __pyx_r = 0; + goto __pyx_L0; + + } + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 4); + + __pyx_t_3 = ((!((__pyx_v_self->_flags & 2) != 0)) != 0); + if (__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L9_bool_binop_done; + } + __pyx_t_3 = (ev_is_active((&__pyx_v_self->_watcher)) != 0); + __pyx_t_1 = __pyx_t_3; + __pyx_L9_bool_binop_done:; + if (__pyx_t_1) { + + ev_unref(__pyx_v_self->loop->_ptr); + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 2); + + } + } + __pyx_L4:; + + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.stat.ref.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4stat_8callback_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4stat_8callback_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4stat_8callback___get__(((struct PyGeventStatObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4stat_8callback___get__(struct PyGeventStatObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->_callback); + __pyx_r = __pyx_v_self->_callback; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_4stat_8callback_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_callback); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_4stat_8callback_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_callback) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4stat_8callback_2__set__(((struct PyGeventStatObject *)__pyx_v_self), ((PyObject *)__pyx_v_callback)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_4stat_8callback_2__set__(struct PyGeventStatObject *__pyx_v_self, PyObject *__pyx_v_callback) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + __Pyx_RefNannySetupContext("__set__", 0); + + __pyx_t_2 = ((!(PyCallable_Check(((PyObject*)__pyx_v_callback)) != 0)) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_2 = (__pyx_v_callback != Py_None); + __pyx_t_3 = (__pyx_t_2 != 0); + __pyx_t_1 = __pyx_t_3; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { + + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1961, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_v_callback); + __Pyx_GIVEREF(__pyx_v_callback); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_callback); + __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_Expected_callable_not_r, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1961, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1961, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1961, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_5, 0, 0, 0); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __PYX_ERR(0, 1961, __pyx_L1_error) + + } + + __Pyx_INCREF(__pyx_v_callback); + __Pyx_GIVEREF(__pyx_v_callback); + __Pyx_GOTREF(__pyx_v_self->_callback); + __Pyx_DECREF(__pyx_v_self->_callback); + __pyx_v_self->_callback = __pyx_v_callback; + + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("gevent.libev.corecext.stat.callback.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4stat_1stop(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4stat_1stop(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("stop (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4stat_stop(((struct PyGeventStatObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4stat_stop(struct PyGeventStatObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("stop", 0); + + __pyx_t_1 = ((!(__pyx_v_self->loop->_ptr != 0)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__89, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1967, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__82, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1967, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__84, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1967, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__77, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1967, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__81, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1967, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__88, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1967, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1967, __pyx_L1_error) + + } + + __pyx_t_1 = ((__pyx_v_self->_flags & 2) != 0); + if (__pyx_t_1) { + + ev_ref(__pyx_v_self->loop->_ptr); + + __pyx_v_self->_flags = (__pyx_v_self->_flags & (~2)); + + } + + ev_stat_stop(__pyx_v_self->loop->_ptr, (&__pyx_v_self->_watcher)); + + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->_callback); + __Pyx_DECREF(__pyx_v_self->_callback); + __pyx_v_self->_callback = Py_None; + + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = ((PyObject*)Py_None); + + __pyx_t_1 = ((__pyx_v_self->_flags & 1) != 0); + if (__pyx_t_1) { + + Py_DECREF(((PyObject*)__pyx_v_self)); + + __pyx_v_self->_flags = (__pyx_v_self->_flags & (~1)); + + } + + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.stat.stop", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4stat_8priority_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4stat_8priority_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4stat_8priority___get__(((struct PyGeventStatObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4stat_8priority___get__(struct PyGeventStatObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(ev_priority((&__pyx_v_self->_watcher))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1981, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.stat.priority.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_4stat_8priority_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_priority); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_4stat_8priority_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_priority) { + int __pyx_v_priority; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_priority); { + __pyx_v_priority = __Pyx_PyInt_As_int(__pyx_arg_priority); if (unlikely((__pyx_v_priority == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1983, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.libev.corecext.stat.priority.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4stat_8priority_2__set__(((struct PyGeventStatObject *)__pyx_v_self), ((int)__pyx_v_priority)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_4stat_8priority_2__set__(struct PyGeventStatObject *__pyx_v_self, int __pyx_v_priority) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("__set__", 0); + + __pyx_t_1 = (ev_is_active((&__pyx_v_self->_watcher)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__90, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1985, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__83, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1985, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__85, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1985, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__78, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1985, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__82, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1985, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__89, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1985, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1985, __pyx_L1_error) + + } + + ev_set_priority((&__pyx_v_self->_watcher), __pyx_v_priority); + + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.stat.priority.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4stat_3feed(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4stat_3feed(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + int __pyx_v_revents; + PyObject *__pyx_v_callback = 0; + PyObject *__pyx_v_args = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("feed (wrapper)", 0); + if (PyTuple_GET_SIZE(__pyx_args) > 2) { + __pyx_v_args = PyTuple_GetSlice(__pyx_args, 2, PyTuple_GET_SIZE(__pyx_args)); + if (unlikely(!__pyx_v_args)) { + __Pyx_RefNannyFinishContext(); + return NULL; + } + __Pyx_GOTREF(__pyx_v_args); + } else { + __pyx_v_args = __pyx_empty_tuple; __Pyx_INCREF(__pyx_empty_tuple); + } + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_revents,&__pyx_n_s_callback,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + default: + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_revents)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_callback)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("feed", 0, 2, 2, 1); __PYX_ERR(0, 1988, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t used_pos_args = (pos_args < 2) ? pos_args : 2; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, used_pos_args, "feed") < 0)) __PYX_ERR(0, 1988, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) < 2) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + } + __pyx_v_revents = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_revents == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1988, __pyx_L3_error) + __pyx_v_callback = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("feed", 0, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1988, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0; + __Pyx_AddTraceback("gevent.libev.corecext.stat.feed", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4stat_2feed(((struct PyGeventStatObject *)__pyx_v_self), __pyx_v_revents, __pyx_v_callback, __pyx_v_args); + + /* function exit code */ + __Pyx_XDECREF(__pyx_v_args); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4stat_2feed(struct PyGeventStatObject *__pyx_v_self, int __pyx_v_revents, PyObject *__pyx_v_callback, PyObject *__pyx_v_args) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("feed", 0); + + __pyx_t_1 = ((!(__pyx_v_self->loop->_ptr != 0)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__91, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1991, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__84, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1991, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__86, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1991, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__79, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1991, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__83, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1991, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__90, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1991, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1991, __pyx_L1_error) + + } + + if (__Pyx_PyObject_SetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_callback, __pyx_v_callback) < 0) __PYX_ERR(0, 1992, __pyx_L1_error) + + __Pyx_INCREF(__pyx_v_args); + __Pyx_GIVEREF(__pyx_v_args); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = __pyx_v_args; + + __pyx_t_1 = (((__pyx_v_self->_flags & 6) == 4) != 0); + if (__pyx_t_1) { + + ev_unref(__pyx_v_self->loop->_ptr); + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 2); + + } + + ev_feed_event(__pyx_v_self->loop->_ptr, (&__pyx_v_self->_watcher), __pyx_v_revents); + + __pyx_t_1 = ((!((__pyx_v_self->_flags & 1) != 0)) != 0); + if (__pyx_t_1) { + + Py_INCREF(((PyObject*)__pyx_v_self)); + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 1); + + } + + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.stat.feed", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4stat_5start(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4stat_5start(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_callback = 0; + PyObject *__pyx_v_args = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("start (wrapper)", 0); + if (PyTuple_GET_SIZE(__pyx_args) > 1) { + __pyx_v_args = PyTuple_GetSlice(__pyx_args, 1, PyTuple_GET_SIZE(__pyx_args)); + if (unlikely(!__pyx_v_args)) { + __Pyx_RefNannyFinishContext(); + return NULL; + } + __Pyx_GOTREF(__pyx_v_args); + } else { + __pyx_v_args = __pyx_empty_tuple; __Pyx_INCREF(__pyx_empty_tuple); + } + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_callback,0}; + PyObject* values[1] = {0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + default: + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_callback)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t used_pos_args = (pos_args < 1) ? pos_args : 1; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, used_pos_args, "start") < 0)) __PYX_ERR(0, 2002, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) < 1) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + } + __pyx_v_callback = values[0]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("start", 0, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2002, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0; + __Pyx_AddTraceback("gevent.libev.corecext.stat.start", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4stat_4start(((struct PyGeventStatObject *)__pyx_v_self), __pyx_v_callback, __pyx_v_args); + + /* function exit code */ + __Pyx_XDECREF(__pyx_v_args); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4stat_4start(struct PyGeventStatObject *__pyx_v_self, PyObject *__pyx_v_callback, PyObject *__pyx_v_args) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + __Pyx_RefNannySetupContext("start", 0); + + __pyx_t_1 = ((!(__pyx_v_self->loop->_ptr != 0)) != 0); + if (__pyx_t_1) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__92, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2005, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__85, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2005, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__87, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2005, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__80, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2005, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__84, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2005, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__91, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2005, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 2005, __pyx_L1_error) + + } + + __pyx_t_1 = (__pyx_v_callback == Py_None); + __pyx_t_3 = (__pyx_t_1 != 0); + if (__pyx_t_3) { + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__93, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2007, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__86, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2007, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__88, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2007, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__81, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2007, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__85, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2007, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__92, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2007, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 2007, __pyx_L1_error) + + } + + if (__Pyx_PyObject_SetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_callback, __pyx_v_callback) < 0) __PYX_ERR(0, 2008, __pyx_L1_error) + + __Pyx_INCREF(__pyx_v_args); + __Pyx_GIVEREF(__pyx_v_args); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = __pyx_v_args; + + __pyx_t_3 = (((__pyx_v_self->_flags & 6) == 4) != 0); + if (__pyx_t_3) { + + ev_unref(__pyx_v_self->loop->_ptr); + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 2); + + } + + ev_stat_start(__pyx_v_self->loop->_ptr, (&__pyx_v_self->_watcher)); + + __pyx_t_3 = ((!((__pyx_v_self->_flags & 1) != 0)) != 0); + if (__pyx_t_3) { + + Py_INCREF(((PyObject*)__pyx_v_self)); + + __pyx_v_self->_flags = (__pyx_v_self->_flags | 1); + + } + + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.stat.start", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4stat_6active_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4stat_6active_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4stat_6active___get__(((struct PyGeventStatObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4stat_6active___get__(struct PyGeventStatObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + if ((ev_is_active((&__pyx_v_self->_watcher)) != 0)) { + __Pyx_INCREF(Py_True); + __pyx_t_1 = Py_True; + } else { + __Pyx_INCREF(Py_False); + __pyx_t_1 = Py_False; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4stat_7pending_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4stat_7pending_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4stat_7pending___get__(((struct PyGeventStatObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4stat_7pending___get__(struct PyGeventStatObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + if ((ev_is_pending((&__pyx_v_self->_watcher)) != 0)) { + __Pyx_INCREF(Py_True); + __pyx_t_1 = Py_True; + } else { + __Pyx_INCREF(Py_False); + __pyx_t_1 = Py_False; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_4stat_7__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_4stat_7__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + struct PyGeventLoopObject *__pyx_v_loop = 0; + PyObject *__pyx_v_path = 0; + float __pyx_v_interval; + PyObject *__pyx_v_ref = 0; + PyObject *__pyx_v_priority = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_loop,&__pyx_n_s_path,&__pyx_n_s_interval,&__pyx_n_s_ref,&__pyx_n_s_priority,0}; + PyObject* values[5] = {0,0,0,0,0}; + values[3] = ((PyObject *)Py_True); + values[4] = ((PyObject *)Py_None); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_loop)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_path)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__init__", 0, 2, 5, 1); __PYX_ERR(0, 2031, __pyx_L3_error) + } + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_interval); + if (value) { values[2] = value; kw_args--; } + } + case 3: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ref); + if (value) { values[3] = value; kw_args--; } + } + case 4: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_priority); + if (value) { values[4] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 2031, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_loop = ((struct PyGeventLoopObject *)values[0]); + __pyx_v_path = ((PyObject*)values[1]); + if (values[2]) { + __pyx_v_interval = __pyx_PyFloat_AsFloat(values[2]); if (unlikely((__pyx_v_interval == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 2031, __pyx_L3_error) + } else { + __pyx_v_interval = ((float)0.0); + } + __pyx_v_ref = values[3]; + __pyx_v_priority = values[4]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 0, 2, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2031, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("gevent.libev.corecext.stat.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_loop), __pyx_ptype_6gevent_5libev_8corecext_loop, 1, "loop", 0))) __PYX_ERR(0, 2031, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_path), (&PyString_Type), 1, "path", 1))) __PYX_ERR(0, 2031, __pyx_L1_error) + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4stat_6__init__(((struct PyGeventStatObject *)__pyx_v_self), __pyx_v_loop, __pyx_v_path, __pyx_v_interval, __pyx_v_ref, __pyx_v_priority); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_4stat_6__init__(struct PyGeventStatObject *__pyx_v_self, struct PyGeventLoopObject *__pyx_v_loop, PyObject *__pyx_v_path, float __pyx_v_interval, PyObject *__pyx_v_ref, PyObject *__pyx_v_priority) { + PyObject *__pyx_v_paths = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + char *__pyx_t_8; + int __pyx_t_9; + __Pyx_RefNannySetupContext("__init__", 0); + + __Pyx_INCREF(__pyx_v_path); + __Pyx_GIVEREF(__pyx_v_path); + __Pyx_GOTREF(__pyx_v_self->path); + __Pyx_DECREF(__pyx_v_self->path); + __pyx_v_self->path = __pyx_v_path; + + __pyx_t_1 = PyUnicode_Check(__pyx_v_path); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_path, __pyx_n_s_encode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2038, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_sys); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2038, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_getfilesystemencoding); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2038, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + } + } + if (__pyx_t_6) { + __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2038, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else { + __pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2038, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_7) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2038, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2038, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2038, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + { + __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2038, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_7); __pyx_t_7 = NULL; + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2038, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (!(likely(PyBytes_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(0, 2038, __pyx_L1_error) + __pyx_v_paths = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + __Pyx_INCREF(__pyx_v_paths); + __Pyx_GIVEREF(__pyx_v_paths); + __Pyx_GOTREF(__pyx_v_self->_paths); + __Pyx_DECREF(__pyx_v_self->_paths); + __pyx_v_self->_paths = __pyx_v_paths; + + goto __pyx_L3; + } + + /*else*/ { + __pyx_t_3 = __pyx_v_path; + __Pyx_INCREF(__pyx_t_3); + __pyx_v_paths = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + __Pyx_INCREF(__pyx_v_paths); + __Pyx_GIVEREF(__pyx_v_paths); + __Pyx_GOTREF(__pyx_v_self->_paths); + __Pyx_DECREF(__pyx_v_self->_paths); + __pyx_v_self->_paths = __pyx_v_paths; + } + __pyx_L3:; + + __pyx_t_8 = __Pyx_PyObject_AsString(__pyx_v_paths); if (unlikely((!__pyx_t_8) && PyErr_Occurred())) __PYX_ERR(0, 2043, __pyx_L1_error) + ev_stat_init((&__pyx_v_self->_watcher), ((void *)gevent_callback_stat), ((char *)__pyx_t_8), __pyx_v_interval); + + __Pyx_INCREF(((PyObject *)__pyx_v_loop)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_loop)); + __Pyx_GOTREF(__pyx_v_self->loop); + __Pyx_DECREF(((PyObject *)__pyx_v_self->loop)); + __pyx_v_self->loop = __pyx_v_loop; + + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_ref); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 2045, __pyx_L1_error) + if (__pyx_t_2) { + + __pyx_v_self->_flags = 0; + + goto __pyx_L4; + } + + /*else*/ { + __pyx_v_self->_flags = 4; + } + __pyx_L4:; + + __pyx_t_2 = (__pyx_v_priority != Py_None); + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { + + __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_v_priority); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 2050, __pyx_L1_error) + ev_set_priority((&__pyx_v_self->_watcher), __pyx_t_9); + + } + + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("gevent.libev.corecext.stat.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_paths); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4stat_4attr_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4stat_4attr_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4stat_4attr___get__(((struct PyGeventStatObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4stat_4attr___get__(struct PyGeventStatObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __pyx_t_1 = ((!(__pyx_v_self->_watcher.attr.st_nlink != 0)) != 0); + if (__pyx_t_1) { + + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + } + + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = _pystat_fromstructstat((&__pyx_v_self->_watcher.attr)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2057, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.stat.attr.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4stat_4prev_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4stat_4prev_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4stat_4prev___get__(((struct PyGeventStatObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4stat_4prev___get__(struct PyGeventStatObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __pyx_t_1 = ((!(__pyx_v_self->_watcher.prev.st_nlink != 0)) != 0); + if (__pyx_t_1) { + + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + } + + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = _pystat_fromstructstat((&__pyx_v_self->_watcher.prev)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2064, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("gevent.libev.corecext.stat.prev.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4stat_8interval_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4stat_8interval_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4stat_8interval___get__(((struct PyGeventStatObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4stat_8interval___get__(struct PyGeventStatObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->_watcher.interval); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2069, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.stat.interval.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4stat_4loop_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4stat_4loop_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4stat_4loop___get__(((struct PyGeventStatObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4stat_4loop___get__(struct PyGeventStatObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self->loop)); + __pyx_r = ((PyObject *)__pyx_v_self->loop); + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_4stat_4loop_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_4stat_4loop_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4stat_4loop_2__set__(((struct PyGeventStatObject *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_4stat_4loop_2__set__(struct PyGeventStatObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__set__", 0); + if (!(likely(((__pyx_v_value) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_value, __pyx_ptype_6gevent_5libev_8corecext_loop))))) __PYX_ERR(0, 1925, __pyx_L1_error) + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->loop); + __Pyx_DECREF(((PyObject *)__pyx_v_self->loop)); + __pyx_v_self->loop = ((struct PyGeventLoopObject *)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.stat.loop.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_4stat_4loop_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_4stat_4loop_5__del__(PyObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4stat_4loop_4__del__(((struct PyGeventStatObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_4stat_4loop_4__del__(struct PyGeventStatObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 0); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->loop); + __Pyx_DECREF(((PyObject *)__pyx_v_self->loop)); + __pyx_v_self->loop = ((struct PyGeventLoopObject *)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4stat_4args_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4stat_4args_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4stat_4args___get__(((struct PyGeventStatObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4stat_4args___get__(struct PyGeventStatObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->args); + __pyx_r = __pyx_v_self->args; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_4stat_4args_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_4stat_4args_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4stat_4args_2__set__(((struct PyGeventStatObject *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_4stat_4args_2__set__(struct PyGeventStatObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__set__", 0); + if (!(likely(PyTuple_CheckExact(__pyx_v_value))||((__pyx_v_value) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v_value)->tp_name), 0))) __PYX_ERR(0, 1927, __pyx_L1_error) + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.stat.args.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_6gevent_5libev_8corecext_4stat_4args_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_6gevent_5libev_8corecext_4stat_4args_5__del__(PyObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4stat_4args_4__del__(((struct PyGeventStatObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_6gevent_5libev_8corecext_4stat_4args_4__del__(struct PyGeventStatObject *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 0); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->args); + __Pyx_DECREF(__pyx_v_self->args); + __pyx_v_self->args = ((PyObject*)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4stat_6_flags_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4stat_6_flags_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4stat_6_flags___get__(((struct PyGeventStatObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4stat_6_flags___get__(struct PyGeventStatObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1928, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.stat._flags.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4stat_4path_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4stat_4path_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4stat_4path___get__(((struct PyGeventStatObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4stat_4path___get__(struct PyGeventStatObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->path); + __pyx_r = __pyx_v_self->path; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4stat_6_paths_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_4stat_6_paths_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_4stat_6_paths___get__(((struct PyGeventStatObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_4stat_6_paths___get__(struct PyGeventStatObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->_paths); + __pyx_r = __pyx_v_self->_paths; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + + +static void __pyx_f_6gevent_5libev_8corecext__syserr_cb(char *__pyx_v_msg) { + PyObject *__pyx_v_print_exc = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_t_9; + PyObject *__pyx_t_10 = NULL; + int __pyx_t_11; + int __pyx_t_12; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("_syserr_cb", 0); + + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { + + __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_SYSERR_CALLBACK); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2077, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyBytes_FromString(__pyx_v_msg); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2077, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyInt_From_int(errno); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2077, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = NULL; + __pyx_t_9 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + __pyx_t_9 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_6, __pyx_t_7}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2077, __pyx_L3_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_6, __pyx_t_7}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2077, __pyx_L3_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } else + #endif + { + __pyx_t_10 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2077, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_10); + if (__pyx_t_8) { + __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); __pyx_t_8 = NULL; + } + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_9, __pyx_t_6); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_9, __pyx_t_7); + __pyx_t_6 = 0; + __pyx_t_7 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_10, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2077, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L10_try_end; + __pyx_L3_error:; + __Pyx_PyThreadState_assign + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + + /*except:*/ { + __Pyx_AddTraceback("gevent.libev.corecext._syserr_cb", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_5, &__pyx_t_10) < 0) __PYX_ERR(0, 2078, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_10); + + __pyx_t_7 = __pyx_f_6gevent_5libev_8corecext_set_syserr_cb(Py_None, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2079, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_traceback); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2080, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = __Pyx_GetAttr3(__pyx_t_7, __pyx_n_s_print_exc, Py_None); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2080, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_v_print_exc = __pyx_t_6; + __pyx_t_6 = 0; + + __pyx_t_11 = (__pyx_v_print_exc != Py_None); + __pyx_t_12 = (__pyx_t_11 != 0); + if (__pyx_t_12) { + + __Pyx_INCREF(__pyx_v_print_exc); + __pyx_t_7 = __pyx_v_print_exc; __pyx_t_8 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + } + } + if (__pyx_t_8) { + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2082, __pyx_L5_except_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } else { + __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2082, __pyx_L5_except_error) + } + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + goto __pyx_L4_exception_handled; + } + __pyx_L5_except_error:; + + __Pyx_PyThreadState_assign + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L4_exception_handled:; + __Pyx_PyThreadState_assign + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + __pyx_L10_try_end:; + } + + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_WriteUnraisable("gevent.libev.corecext._syserr_cb", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0); + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_print_exc); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + PyGILState_Release(__pyx_gilstate_save); + #endif +} + + +static PyObject *__pyx_pw_6gevent_5libev_8corecext_21set_syserr_cb(PyObject *__pyx_self, PyObject *__pyx_v_callback); /*proto*/ +static PyObject *__pyx_f_6gevent_5libev_8corecext_set_syserr_cb(PyObject *__pyx_v_callback, CYTHON_UNUSED int __pyx_skip_dispatch) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + __Pyx_RefNannySetupContext("set_syserr_cb", 0); + + __pyx_t_1 = (__pyx_v_callback == Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + ev_set_syserr_cb(NULL); + + if (PyDict_SetItem(__pyx_d, __pyx_n_s_SYSERR_CALLBACK, Py_None) < 0) __PYX_ERR(0, 2089, __pyx_L1_error) + + goto __pyx_L3; + } + + __pyx_t_2 = __Pyx_PyCallable_Check(__pyx_v_callback); if (unlikely(__pyx_t_2 == -1)) __PYX_ERR(0, 2090, __pyx_L1_error) + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { + + ev_set_syserr_cb(((void *)__pyx_f_6gevent_5libev_8corecext__syserr_cb)); + + if (PyDict_SetItem(__pyx_d, __pyx_n_s_SYSERR_CALLBACK, __pyx_v_callback) < 0) __PYX_ERR(0, 2092, __pyx_L1_error) + + goto __pyx_L3; + } + + /*else*/ { + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2094, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_v_callback); + __Pyx_GIVEREF(__pyx_v_callback); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_callback); + __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Expected_callable_or_None_got_r, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2094, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2094, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2094, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(0, 2094, __pyx_L1_error) + } + __pyx_L3:; + + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("gevent.libev.corecext.set_syserr_cb", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_21set_syserr_cb(PyObject *__pyx_self, PyObject *__pyx_v_callback); /*proto*/ +static PyObject *__pyx_pw_6gevent_5libev_8corecext_21set_syserr_cb(PyObject *__pyx_self, PyObject *__pyx_v_callback) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("set_syserr_cb (wrapper)", 0); + __pyx_r = __pyx_pf_6gevent_5libev_8corecext_20set_syserr_cb(__pyx_self, ((PyObject *)__pyx_v_callback)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gevent_5libev_8corecext_20set_syserr_cb(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_callback) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("set_syserr_cb", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_6gevent_5libev_8corecext_set_syserr_cb(__pyx_v_callback, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2085, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("gevent.libev.corecext.set_syserr_cb", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_tp_new_6gevent_5libev_8corecext__EVENTSType(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + return o; +} + +static void __pyx_tp_dealloc_6gevent_5libev_8corecext__EVENTSType(PyObject *o) { + #if PY_VERSION_HEX >= 0x030400a1 + if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + (*Py_TYPE(o)->tp_free)(o); +} + +static PyMethodDef __pyx_methods_6gevent_5libev_8corecext__EVENTSType[] = { + {0, 0, 0, 0} +}; + +static PyTypeObject __pyx_type_6gevent_5libev_8corecext__EVENTSType = { + PyVarObject_HEAD_INIT(0, 0) + "gevent.libev.corecext._EVENTSType", /*tp_name*/ + sizeof(struct __pyx_obj_6gevent_5libev_8corecext__EVENTSType), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_6gevent_5libev_8corecext__EVENTSType, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + __pyx_pw_6gevent_5libev_8corecext_11_EVENTSType_1__repr__, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_6gevent_5libev_8corecext__EVENTSType, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_6gevent_5libev_8corecext__EVENTSType, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; +static struct __pyx_vtabstruct_6gevent_5libev_8corecext_loop __pyx_vtable_6gevent_5libev_8corecext_loop; + +static PyObject *__pyx_tp_new_6gevent_5libev_8corecext_loop(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct PyGeventLoopObject *p; + PyObject *o; + if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + p = ((struct PyGeventLoopObject *)o); + p->__pyx_vtab = __pyx_vtabptr_6gevent_5libev_8corecext_loop; + p->error_handler = Py_None; Py_INCREF(Py_None); + p->_callbacks = ((PyObject*)Py_None); Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_6gevent_5libev_8corecext_loop(PyObject *o) { + struct PyGeventLoopObject *p = (struct PyGeventLoopObject *)o; + #if PY_VERSION_HEX >= 0x030400a1 + if (unlikely(Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + PyObject_GC_UnTrack(o); + { + PyObject *etype, *eval, *etb; + PyErr_Fetch(&etype, &eval, &etb); + ++Py_REFCNT(o); + __pyx_pw_6gevent_5libev_8corecext_4loop_7__dealloc__(o); + --Py_REFCNT(o); + PyErr_Restore(etype, eval, etb); + } + Py_CLEAR(p->error_handler); + Py_CLEAR(p->_callbacks); + (*Py_TYPE(o)->tp_free)(o); +} + +static int __pyx_tp_traverse_6gevent_5libev_8corecext_loop(PyObject *o, visitproc v, void *a) { + int e; + struct PyGeventLoopObject *p = (struct PyGeventLoopObject *)o; + if (p->error_handler) { + e = (*v)(p->error_handler, a); if (e) return e; + } + if (p->_callbacks) { + e = (*v)(p->_callbacks, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_6gevent_5libev_8corecext_loop(PyObject *o) { + PyObject* tmp; + struct PyGeventLoopObject *p = (struct PyGeventLoopObject *)o; + tmp = ((PyObject*)p->error_handler); + p->error_handler = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_callbacks); + p->_callbacks = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_4loop_ptr(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_4loop_3ptr_1__get__(o); +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_4loop_WatcherType(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_4loop_11WatcherType_1__get__(o); +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_4loop_MAXPRI(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_4loop_6MAXPRI_1__get__(o); +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_4loop_MINPRI(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_4loop_6MINPRI_1__get__(o); +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_4loop_default(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_4loop_7default_1__get__(o); +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_4loop_iteration(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_4loop_9iteration_1__get__(o); +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_4loop_depth(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_4loop_5depth_1__get__(o); +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_4loop_backend_int(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_4loop_11backend_int_1__get__(o); +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_4loop_backend(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_4loop_7backend_1__get__(o); +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_4loop_pendingcnt(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_4loop_10pendingcnt_1__get__(o); +} + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_4loop_activecnt(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_4loop_9activecnt_1__get__(o); +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_4loop_sig_pending(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_4loop_11sig_pending_1__get__(o); +} + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_4loop_sigfd(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_4loop_5sigfd_1__get__(o); +} + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_4loop_origflags(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_4loop_9origflags_1__get__(o); +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_4loop_origflags_int(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_4loop_13origflags_int_1__get__(o); +} + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_4loop_error_handler(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_4loop_13error_handler_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_4loop_error_handler(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_4loop_13error_handler_3__set__(o, v); + } + else { + return __pyx_pw_6gevent_5libev_8corecext_4loop_13error_handler_5__del__(o); + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_4loop__callbacks(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_4loop_10_callbacks_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_4loop__callbacks(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_4loop_10_callbacks_3__set__(o, v); + } + else { + return __pyx_pw_6gevent_5libev_8corecext_4loop_10_callbacks_5__del__(o); + } +} + +static PyMethodDef __pyx_methods_6gevent_5libev_8corecext_loop[] = { + {"_stop_watchers", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_4loop_3_stop_watchers, METH_NOARGS, 0}, + {"destroy", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_4loop_5destroy, METH_NOARGS, 0}, + {"_handle_syserr", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_4loop_9_handle_syserr, METH_VARARGS|METH_KEYWORDS, 0}, + {"handle_error", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_4loop_11handle_error, METH_VARARGS|METH_KEYWORDS, 0}, + {"_default_handle_error", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_4loop_13_default_handle_error, METH_VARARGS|METH_KEYWORDS, 0}, + {"run", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_4loop_15run, METH_VARARGS|METH_KEYWORDS, 0}, + {"reinit", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_4loop_17reinit, METH_NOARGS, 0}, + {"ref", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_4loop_19ref, METH_NOARGS, 0}, + {"unref", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_4loop_21unref, METH_NOARGS, 0}, + {"break_", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_4loop_23break_, METH_VARARGS|METH_KEYWORDS, 0}, + {"verify", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_4loop_25verify, METH_NOARGS, 0}, + {"now", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_4loop_27now, METH_NOARGS, 0}, + {"update", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_4loop_29update, METH_NOARGS, 0}, + {"io", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_4loop_33io, METH_VARARGS|METH_KEYWORDS, 0}, + {"timer", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_4loop_35timer, METH_VARARGS|METH_KEYWORDS, 0}, + {"signal", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_4loop_37signal, METH_VARARGS|METH_KEYWORDS, 0}, + {"idle", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_4loop_39idle, METH_VARARGS|METH_KEYWORDS, 0}, + {"prepare", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_4loop_41prepare, METH_VARARGS|METH_KEYWORDS, 0}, + {"check", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_4loop_43check, METH_VARARGS|METH_KEYWORDS, 0}, + {"fork", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_4loop_45fork, METH_VARARGS|METH_KEYWORDS, 0}, + {"async", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_4loop_47async, METH_VARARGS|METH_KEYWORDS, 0}, +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + {"stat", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_4loop_49stat, METH_VARARGS|METH_KEYWORDS, 0}, + {"run_callback", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_4loop_51run_callback, METH_VARARGS|METH_KEYWORDS, 0}, + {"_format", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_4loop_53_format, METH_NOARGS, 0}, + {"_format_details", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_4loop_55_format_details, METH_NOARGS, 0}, + {"fileno", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_4loop_57fileno, METH_NOARGS, 0}, +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + {"child", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_4loop_49child, METH_VARARGS|METH_KEYWORDS, 0}, + {"install_sigchld", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_4loop_51install_sigchld, METH_NOARGS, 0}, + {"reset_sigchld", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_4loop_53reset_sigchld, METH_NOARGS, 0}, + {"stat", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_4loop_55stat, METH_VARARGS|METH_KEYWORDS, 0}, + {"run_callback", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_4loop_57run_callback, METH_VARARGS|METH_KEYWORDS, 0}, + {"_format", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_4loop_59_format, METH_NOARGS, 0}, +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + {"_format_details", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_4loop_61_format_details, METH_NOARGS, 0}, + {"fileno", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_4loop_63fileno, METH_NOARGS, 0}, +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + {"stat", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_4loop_49stat, METH_VARARGS|METH_KEYWORDS, 0}, + {"run_callback", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_4loop_51run_callback, METH_VARARGS|METH_KEYWORDS, 0}, + {"_format", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_4loop_53_format, METH_NOARGS, 0}, +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + {"_format_details", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_4loop_55_format_details, METH_NOARGS, 0}, + {"fileno", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_4loop_57fileno, METH_NOARGS, 0}, +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + {"_format_details", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_4loop_61_format_details, METH_NOARGS, 0}, + {"fileno", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_4loop_63fileno, METH_NOARGS, 0}, +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_6gevent_5libev_8corecext_loop[] = { + {(char *)"ptr", __pyx_getprop_6gevent_5libev_8corecext_4loop_ptr, 0, (char *)0, 0}, + {(char *)"WatcherType", __pyx_getprop_6gevent_5libev_8corecext_4loop_WatcherType, 0, (char *)0, 0}, + {(char *)"MAXPRI", __pyx_getprop_6gevent_5libev_8corecext_4loop_MAXPRI, 0, (char *)0, 0}, + {(char *)"MINPRI", __pyx_getprop_6gevent_5libev_8corecext_4loop_MINPRI, 0, (char *)0, 0}, + {(char *)"default", __pyx_getprop_6gevent_5libev_8corecext_4loop_default, 0, (char *)0, 0}, + {(char *)"iteration", __pyx_getprop_6gevent_5libev_8corecext_4loop_iteration, 0, (char *)0, 0}, + {(char *)"depth", __pyx_getprop_6gevent_5libev_8corecext_4loop_depth, 0, (char *)0, 0}, + {(char *)"backend_int", __pyx_getprop_6gevent_5libev_8corecext_4loop_backend_int, 0, (char *)0, 0}, + {(char *)"backend", __pyx_getprop_6gevent_5libev_8corecext_4loop_backend, 0, (char *)0, 0}, + {(char *)"pendingcnt", __pyx_getprop_6gevent_5libev_8corecext_4loop_pendingcnt, 0, (char *)0, 0}, +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + {(char *)"activecnt", __pyx_getprop_6gevent_5libev_8corecext_4loop_activecnt, 0, (char *)0, 0}, + {(char *)"sig_pending", __pyx_getprop_6gevent_5libev_8corecext_4loop_sig_pending, 0, (char *)0, 0}, +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + {(char *)"sigfd", __pyx_getprop_6gevent_5libev_8corecext_4loop_sigfd, 0, (char *)0, 0}, +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + {(char *)"origflags", __pyx_getprop_6gevent_5libev_8corecext_4loop_origflags, 0, (char *)0, 0}, + {(char *)"origflags_int", __pyx_getprop_6gevent_5libev_8corecext_4loop_origflags_int, 0, (char *)0, 0}, +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + {(char *)"error_handler", __pyx_getprop_6gevent_5libev_8corecext_4loop_error_handler, __pyx_setprop_6gevent_5libev_8corecext_4loop_error_handler, (char *)0, 0}, + {(char *)"_callbacks", __pyx_getprop_6gevent_5libev_8corecext_4loop__callbacks, __pyx_setprop_6gevent_5libev_8corecext_4loop__callbacks, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; + +DL_EXPORT(PyTypeObject) PyGeventLoop_Type = { + PyVarObject_HEAD_INIT(0, 0) + "gevent.libev.corecext.loop", /*tp_name*/ + sizeof(struct PyGeventLoopObject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_6gevent_5libev_8corecext_loop, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + __pyx_pw_6gevent_5libev_8corecext_4loop_31__repr__, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_6gevent_5libev_8corecext_loop, /*tp_traverse*/ + __pyx_tp_clear_6gevent_5libev_8corecext_loop, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_6gevent_5libev_8corecext_loop, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_6gevent_5libev_8corecext_loop, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + __pyx_pw_6gevent_5libev_8corecext_4loop_1__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_6gevent_5libev_8corecext_loop, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; + +static PyObject *__pyx_tp_new_6gevent_5libev_8corecext_callback(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct PyGeventCallbackObject *p; + PyObject *o; + if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + p = ((struct PyGeventCallbackObject *)o); + p->callback = Py_None; Py_INCREF(Py_None); + p->args = ((PyObject*)Py_None); Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_6gevent_5libev_8corecext_callback(PyObject *o) { + struct PyGeventCallbackObject *p = (struct PyGeventCallbackObject *)o; + #if PY_VERSION_HEX >= 0x030400a1 + if (unlikely(Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->callback); + Py_CLEAR(p->args); + (*Py_TYPE(o)->tp_free)(o); +} + +static int __pyx_tp_traverse_6gevent_5libev_8corecext_callback(PyObject *o, visitproc v, void *a) { + int e; + struct PyGeventCallbackObject *p = (struct PyGeventCallbackObject *)o; + if (p->callback) { + e = (*v)(p->callback, a); if (e) return e; + } + if (p->args) { + e = (*v)(p->args, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_6gevent_5libev_8corecext_callback(PyObject *o) { + PyObject* tmp; + struct PyGeventCallbackObject *p = (struct PyGeventCallbackObject *)o; + tmp = ((PyObject*)p->callback); + p->callback = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->args); + p->args = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_8callback_pending(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_8callback_7pending_1__get__(o); +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_8callback_callback(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_8callback_8callback_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_8callback_callback(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_8callback_8callback_3__set__(o, v); + } + else { + return __pyx_pw_6gevent_5libev_8corecext_8callback_8callback_5__del__(o); + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_8callback_args(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_8callback_4args_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_8callback_args(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_8callback_4args_3__set__(o, v); + } + else { + return __pyx_pw_6gevent_5libev_8corecext_8callback_4args_5__del__(o); + } +} + +static PyMethodDef __pyx_methods_6gevent_5libev_8corecext_callback[] = { + {"stop", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_8callback_3stop, METH_NOARGS, 0}, + {"_format", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_8callback_9_format, METH_NOARGS, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_6gevent_5libev_8corecext_callback[] = { + {(char *)"pending", __pyx_getprop_6gevent_5libev_8corecext_8callback_pending, 0, (char *)0, 0}, + {(char *)"callback", __pyx_getprop_6gevent_5libev_8corecext_8callback_callback, __pyx_setprop_6gevent_5libev_8corecext_8callback_callback, (char *)0, 0}, + {(char *)"args", __pyx_getprop_6gevent_5libev_8corecext_8callback_args, __pyx_setprop_6gevent_5libev_8corecext_8callback_args, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; + +static PyNumberMethods __pyx_tp_as_number_callback = { + 0, /*nb_add*/ + 0, /*nb_subtract*/ + 0, /*nb_multiply*/ + #if PY_MAJOR_VERSION < 3 || CYTHON_COMPILING_IN_PYPY + 0, /*nb_divide*/ + #endif + 0, /*nb_remainder*/ + 0, /*nb_divmod*/ + 0, /*nb_power*/ + 0, /*nb_negative*/ + 0, /*nb_positive*/ + 0, /*nb_absolute*/ + __pyx_pw_6gevent_5libev_8corecext_8callback_5__nonzero__, /*nb_nonzero*/ + 0, /*nb_invert*/ + 0, /*nb_lshift*/ + 0, /*nb_rshift*/ + 0, /*nb_and*/ + 0, /*nb_xor*/ + 0, /*nb_or*/ + #if PY_MAJOR_VERSION < 3 || CYTHON_COMPILING_IN_PYPY + 0, /*nb_coerce*/ + #endif + 0, /*nb_int*/ + #if PY_MAJOR_VERSION < 3 + 0, /*nb_long*/ + #else + 0, /*reserved*/ + #endif + 0, /*nb_float*/ + #if PY_MAJOR_VERSION < 3 || CYTHON_COMPILING_IN_PYPY + 0, /*nb_oct*/ + #endif + #if PY_MAJOR_VERSION < 3 || CYTHON_COMPILING_IN_PYPY + 0, /*nb_hex*/ + #endif + 0, /*nb_inplace_add*/ + 0, /*nb_inplace_subtract*/ + 0, /*nb_inplace_multiply*/ + #if PY_MAJOR_VERSION < 3 || CYTHON_COMPILING_IN_PYPY + 0, /*nb_inplace_divide*/ + #endif + 0, /*nb_inplace_remainder*/ + 0, /*nb_inplace_power*/ + 0, /*nb_inplace_lshift*/ + 0, /*nb_inplace_rshift*/ + 0, /*nb_inplace_and*/ + 0, /*nb_inplace_xor*/ + 0, /*nb_inplace_or*/ + 0, /*nb_floor_divide*/ + 0, /*nb_true_divide*/ + 0, /*nb_inplace_floor_divide*/ + 0, /*nb_inplace_true_divide*/ + 0, /*nb_index*/ + #if PY_VERSION_HEX >= 0x03050000 + 0, /*nb_matrix_multiply*/ + #endif + #if PY_VERSION_HEX >= 0x03050000 + 0, /*nb_inplace_matrix_multiply*/ + #endif +}; + +DL_EXPORT(PyTypeObject) PyGeventCallback_Type = { + PyVarObject_HEAD_INIT(0, 0) + "gevent.libev.corecext.callback", /*tp_name*/ + sizeof(struct PyGeventCallbackObject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_6gevent_5libev_8corecext_callback, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + __pyx_pw_6gevent_5libev_8corecext_8callback_7__repr__, /*tp_repr*/ + &__pyx_tp_as_number_callback, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_6gevent_5libev_8corecext_callback, /*tp_traverse*/ + __pyx_tp_clear_6gevent_5libev_8corecext_callback, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_6gevent_5libev_8corecext_callback, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_6gevent_5libev_8corecext_callback, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + __pyx_pw_6gevent_5libev_8corecext_8callback_1__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_6gevent_5libev_8corecext_callback, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; + +static PyObject *__pyx_tp_new_6gevent_5libev_8corecext_watcher(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + return o; +} + +static void __pyx_tp_dealloc_6gevent_5libev_8corecext_watcher(PyObject *o) { + #if PY_VERSION_HEX >= 0x030400a1 + if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + (*Py_TYPE(o)->tp_free)(o); +} + +static PyMethodDef __pyx_methods_6gevent_5libev_8corecext_watcher[] = { + {"_format", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_7watcher_3_format, METH_NOARGS, 0}, + {0, 0, 0, 0} +}; + +DL_EXPORT(PyTypeObject) PyGeventWatcher_Type = { + PyVarObject_HEAD_INIT(0, 0) + "gevent.libev.corecext.watcher", /*tp_name*/ + sizeof(struct PyGeventWatcherObject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_6gevent_5libev_8corecext_watcher, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + __pyx_pw_6gevent_5libev_8corecext_7watcher_1__repr__, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + "Abstract base class for all the watchers", /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_6gevent_5libev_8corecext_watcher, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_6gevent_5libev_8corecext_watcher, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; + +static PyObject *__pyx_tp_new_6gevent_5libev_8corecext_io(PyTypeObject *t, PyObject *a, PyObject *k) { + struct PyGeventIOObject *p; + PyObject *o = __pyx_tp_new_6gevent_5libev_8corecext_watcher(t, a, k); + if (unlikely(!o)) return 0; + p = ((struct PyGeventIOObject *)o); + p->loop = ((struct PyGeventLoopObject *)Py_None); Py_INCREF(Py_None); + p->_callback = Py_None; Py_INCREF(Py_None); + p->args = ((PyObject*)Py_None); Py_INCREF(Py_None); +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + if (unlikely(__pyx_pw_6gevent_5libev_8corecext_2io_11__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + return o; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + bad: + Py_DECREF(o); o = 0; + return NULL; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +} + +static void __pyx_tp_dealloc_6gevent_5libev_8corecext_io(PyObject *o) { + struct PyGeventIOObject *p = (struct PyGeventIOObject *)o; + #if PY_VERSION_HEX >= 0x030400a1 + if (unlikely(Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + PyObject_GC_UnTrack(o); +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + { + PyObject *etype, *eval, *etb; + PyErr_Fetch(&etype, &eval, &etb); + ++Py_REFCNT(o); + __pyx_pw_6gevent_5libev_8corecext_2io_13__dealloc__(o); + --Py_REFCNT(o); + PyErr_Restore(etype, eval, etb); + } +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + Py_CLEAR(p->loop); + Py_CLEAR(p->_callback); + Py_CLEAR(p->args); + #if CYTHON_USE_TYPE_SLOTS + if (PyType_IS_GC(Py_TYPE(o)->tp_base)) + #endif + PyObject_GC_Track(o); + __pyx_tp_dealloc_6gevent_5libev_8corecext_watcher(o); +} + +static int __pyx_tp_traverse_6gevent_5libev_8corecext_io(PyObject *o, visitproc v, void *a) { + int e; + struct PyGeventIOObject *p = (struct PyGeventIOObject *)o; + e = ((likely(__pyx_ptype_6gevent_5libev_8corecext_watcher)) ? ((__pyx_ptype_6gevent_5libev_8corecext_watcher->tp_traverse) ? __pyx_ptype_6gevent_5libev_8corecext_watcher->tp_traverse(o, v, a) : 0) : __Pyx_call_next_tp_traverse(o, v, a, __pyx_tp_traverse_6gevent_5libev_8corecext_io)); if (e) return e; + if (p->loop) { + e = (*v)(((PyObject*)p->loop), a); if (e) return e; + } + if (p->_callback) { + e = (*v)(p->_callback, a); if (e) return e; + } + if (p->args) { + e = (*v)(p->args, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_6gevent_5libev_8corecext_io(PyObject *o) { + PyObject* tmp; + struct PyGeventIOObject *p = (struct PyGeventIOObject *)o; + if (likely(__pyx_ptype_6gevent_5libev_8corecext_watcher)) { if (__pyx_ptype_6gevent_5libev_8corecext_watcher->tp_clear) __pyx_ptype_6gevent_5libev_8corecext_watcher->tp_clear(o); } else __Pyx_call_next_tp_clear(o, __pyx_tp_clear_6gevent_5libev_8corecext_io); + tmp = ((PyObject*)p->loop); + p->loop = ((struct PyGeventLoopObject *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_callback); + p->_callback = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->args); + p->args = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_2io_ref(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_2io_3ref_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_2io_ref(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_2io_3ref_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_2io_callback(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_2io_8callback_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_2io_callback(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_2io_8callback_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_2io_priority(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_2io_8priority_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_2io_priority(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_2io_8priority_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_2io_active(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_2io_6active_1__get__(o); +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_2io_pending(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_2io_7pending_1__get__(o); +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_2io_fd(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_2io_2fd_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_2io_fd(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_2io_2fd_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_2io_events(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_2io_6events_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_2io_events(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_2io_6events_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_2io_events_str(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_2io_10events_str_1__get__(o); +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_2io_loop(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_2io_4loop_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_2io_loop(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_2io_4loop_3__set__(o, v); + } + else { + return __pyx_pw_6gevent_5libev_8corecext_2io_4loop_5__del__(o); + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_2io_args(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_2io_4args_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_2io_args(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_2io_4args_3__set__(o, v); + } + else { + return __pyx_pw_6gevent_5libev_8corecext_2io_4args_5__del__(o); + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_2io__flags(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_2io_6_flags_1__get__(o); +} + +static PyMethodDef __pyx_methods_6gevent_5libev_8corecext_io[] = { + {"stop", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_2io_1stop, METH_NOARGS, 0}, + {"feed", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_2io_3feed, METH_VARARGS|METH_KEYWORDS, 0}, + {"start", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_2io_5start, METH_VARARGS|METH_KEYWORDS, 0}, + {"_format", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_2io_9_format, METH_NOARGS, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_6gevent_5libev_8corecext_io[] = { + {(char *)"ref", __pyx_getprop_6gevent_5libev_8corecext_2io_ref, __pyx_setprop_6gevent_5libev_8corecext_2io_ref, (char *)0, 0}, + {(char *)"callback", __pyx_getprop_6gevent_5libev_8corecext_2io_callback, __pyx_setprop_6gevent_5libev_8corecext_2io_callback, (char *)0, 0}, + {(char *)"priority", __pyx_getprop_6gevent_5libev_8corecext_2io_priority, __pyx_setprop_6gevent_5libev_8corecext_2io_priority, (char *)0, 0}, + {(char *)"active", __pyx_getprop_6gevent_5libev_8corecext_2io_active, 0, (char *)0, 0}, + {(char *)"pending", __pyx_getprop_6gevent_5libev_8corecext_2io_pending, 0, (char *)0, 0}, + {(char *)"fd", __pyx_getprop_6gevent_5libev_8corecext_2io_fd, __pyx_setprop_6gevent_5libev_8corecext_2io_fd, (char *)0, 0}, + {(char *)"events", __pyx_getprop_6gevent_5libev_8corecext_2io_events, __pyx_setprop_6gevent_5libev_8corecext_2io_events, (char *)0, 0}, + {(char *)"events_str", __pyx_getprop_6gevent_5libev_8corecext_2io_events_str, 0, (char *)0, 0}, + {(char *)"loop", __pyx_getprop_6gevent_5libev_8corecext_2io_loop, __pyx_setprop_6gevent_5libev_8corecext_2io_loop, (char *)0, 0}, + {(char *)"args", __pyx_getprop_6gevent_5libev_8corecext_2io_args, __pyx_setprop_6gevent_5libev_8corecext_2io_args, (char *)0, 0}, + {(char *)"_flags", __pyx_getprop_6gevent_5libev_8corecext_2io__flags, 0, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; + +DL_EXPORT(PyTypeObject) PyGeventIO_Type = { + PyVarObject_HEAD_INIT(0, 0) + "gevent.libev.corecext.io", /*tp_name*/ + sizeof(struct PyGeventIOObject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_6gevent_5libev_8corecext_io, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + #if CYTHON_COMPILING_IN_PYPY + __pyx_pw_6gevent_5libev_8corecext_7watcher_1__repr__, /*tp_repr*/ + #else + 0, /*tp_repr*/ + #endif + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_6gevent_5libev_8corecext_io, /*tp_traverse*/ + __pyx_tp_clear_6gevent_5libev_8corecext_io, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_6gevent_5libev_8corecext_io, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_6gevent_5libev_8corecext_io, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + __pyx_pw_6gevent_5libev_8corecext_2io_7__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_6gevent_5libev_8corecext_io, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; + +static PyObject *__pyx_tp_new_6gevent_5libev_8corecext_timer(PyTypeObject *t, PyObject *a, PyObject *k) { + struct PyGeventTimerObject *p; + PyObject *o = __pyx_tp_new_6gevent_5libev_8corecext_watcher(t, a, k); + if (unlikely(!o)) return 0; + p = ((struct PyGeventTimerObject *)o); + p->loop = ((struct PyGeventLoopObject *)Py_None); Py_INCREF(Py_None); + p->_callback = Py_None; Py_INCREF(Py_None); + p->args = ((PyObject*)Py_None); Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_6gevent_5libev_8corecext_timer(PyObject *o) { + struct PyGeventTimerObject *p = (struct PyGeventTimerObject *)o; + #if PY_VERSION_HEX >= 0x030400a1 + if (unlikely(Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->loop); + Py_CLEAR(p->_callback); + Py_CLEAR(p->args); + #if CYTHON_USE_TYPE_SLOTS + if (PyType_IS_GC(Py_TYPE(o)->tp_base)) + #endif + PyObject_GC_Track(o); + __pyx_tp_dealloc_6gevent_5libev_8corecext_watcher(o); +} + +static int __pyx_tp_traverse_6gevent_5libev_8corecext_timer(PyObject *o, visitproc v, void *a) { + int e; + struct PyGeventTimerObject *p = (struct PyGeventTimerObject *)o; + e = ((likely(__pyx_ptype_6gevent_5libev_8corecext_watcher)) ? ((__pyx_ptype_6gevent_5libev_8corecext_watcher->tp_traverse) ? __pyx_ptype_6gevent_5libev_8corecext_watcher->tp_traverse(o, v, a) : 0) : __Pyx_call_next_tp_traverse(o, v, a, __pyx_tp_traverse_6gevent_5libev_8corecext_timer)); if (e) return e; + if (p->loop) { + e = (*v)(((PyObject*)p->loop), a); if (e) return e; + } + if (p->_callback) { + e = (*v)(p->_callback, a); if (e) return e; + } + if (p->args) { + e = (*v)(p->args, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_6gevent_5libev_8corecext_timer(PyObject *o) { + PyObject* tmp; + struct PyGeventTimerObject *p = (struct PyGeventTimerObject *)o; + if (likely(__pyx_ptype_6gevent_5libev_8corecext_watcher)) { if (__pyx_ptype_6gevent_5libev_8corecext_watcher->tp_clear) __pyx_ptype_6gevent_5libev_8corecext_watcher->tp_clear(o); } else __Pyx_call_next_tp_clear(o, __pyx_tp_clear_6gevent_5libev_8corecext_timer); + tmp = ((PyObject*)p->loop); + p->loop = ((struct PyGeventLoopObject *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_callback); + p->_callback = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->args); + p->args = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_5timer_ref(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_5timer_3ref_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_5timer_ref(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_5timer_3ref_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_5timer_callback(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_5timer_8callback_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_5timer_callback(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_5timer_8callback_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_5timer_priority(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_5timer_8priority_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_5timer_priority(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_5timer_8priority_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_5timer_active(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_5timer_6active_1__get__(o); +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_5timer_pending(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_5timer_7pending_1__get__(o); +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_5timer_at(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_5timer_2at_1__get__(o); +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_5timer_loop(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_5timer_4loop_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_5timer_loop(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_5timer_4loop_3__set__(o, v); + } + else { + return __pyx_pw_6gevent_5libev_8corecext_5timer_4loop_5__del__(o); + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_5timer_args(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_5timer_4args_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_5timer_args(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_5timer_4args_3__set__(o, v); + } + else { + return __pyx_pw_6gevent_5libev_8corecext_5timer_4args_5__del__(o); + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_5timer__flags(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_5timer_6_flags_1__get__(o); +} + +static PyMethodDef __pyx_methods_6gevent_5libev_8corecext_timer[] = { + {"stop", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_5timer_1stop, METH_NOARGS, 0}, + {"feed", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_5timer_3feed, METH_VARARGS|METH_KEYWORDS, 0}, + {"start", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_5timer_5start, METH_VARARGS|METH_KEYWORDS, 0}, + {"again", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_5timer_9again, METH_VARARGS|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_6gevent_5libev_8corecext_timer[] = { + {(char *)"ref", __pyx_getprop_6gevent_5libev_8corecext_5timer_ref, __pyx_setprop_6gevent_5libev_8corecext_5timer_ref, (char *)0, 0}, + {(char *)"callback", __pyx_getprop_6gevent_5libev_8corecext_5timer_callback, __pyx_setprop_6gevent_5libev_8corecext_5timer_callback, (char *)0, 0}, + {(char *)"priority", __pyx_getprop_6gevent_5libev_8corecext_5timer_priority, __pyx_setprop_6gevent_5libev_8corecext_5timer_priority, (char *)0, 0}, + {(char *)"active", __pyx_getprop_6gevent_5libev_8corecext_5timer_active, 0, (char *)0, 0}, + {(char *)"pending", __pyx_getprop_6gevent_5libev_8corecext_5timer_pending, 0, (char *)0, 0}, + {(char *)"at", __pyx_getprop_6gevent_5libev_8corecext_5timer_at, 0, (char *)0, 0}, + {(char *)"loop", __pyx_getprop_6gevent_5libev_8corecext_5timer_loop, __pyx_setprop_6gevent_5libev_8corecext_5timer_loop, (char *)0, 0}, + {(char *)"args", __pyx_getprop_6gevent_5libev_8corecext_5timer_args, __pyx_setprop_6gevent_5libev_8corecext_5timer_args, (char *)0, 0}, + {(char *)"_flags", __pyx_getprop_6gevent_5libev_8corecext_5timer__flags, 0, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; + +DL_EXPORT(PyTypeObject) PyGeventTimer_Type = { + PyVarObject_HEAD_INIT(0, 0) + "gevent.libev.corecext.timer", /*tp_name*/ + sizeof(struct PyGeventTimerObject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_6gevent_5libev_8corecext_timer, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + #if CYTHON_COMPILING_IN_PYPY + __pyx_pw_6gevent_5libev_8corecext_7watcher_1__repr__, /*tp_repr*/ + #else + 0, /*tp_repr*/ + #endif + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_6gevent_5libev_8corecext_timer, /*tp_traverse*/ + __pyx_tp_clear_6gevent_5libev_8corecext_timer, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_6gevent_5libev_8corecext_timer, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_6gevent_5libev_8corecext_timer, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + __pyx_pw_6gevent_5libev_8corecext_5timer_7__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_6gevent_5libev_8corecext_timer, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; + +static PyObject *__pyx_tp_new_6gevent_5libev_8corecext_signal(PyTypeObject *t, PyObject *a, PyObject *k) { + struct PyGeventSignalObject *p; + PyObject *o = __pyx_tp_new_6gevent_5libev_8corecext_watcher(t, a, k); + if (unlikely(!o)) return 0; + p = ((struct PyGeventSignalObject *)o); + p->loop = ((struct PyGeventLoopObject *)Py_None); Py_INCREF(Py_None); + p->_callback = Py_None; Py_INCREF(Py_None); + p->args = ((PyObject*)Py_None); Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_6gevent_5libev_8corecext_signal(PyObject *o) { + struct PyGeventSignalObject *p = (struct PyGeventSignalObject *)o; + #if PY_VERSION_HEX >= 0x030400a1 + if (unlikely(Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->loop); + Py_CLEAR(p->_callback); + Py_CLEAR(p->args); + #if CYTHON_USE_TYPE_SLOTS + if (PyType_IS_GC(Py_TYPE(o)->tp_base)) + #endif + PyObject_GC_Track(o); + __pyx_tp_dealloc_6gevent_5libev_8corecext_watcher(o); +} + +static int __pyx_tp_traverse_6gevent_5libev_8corecext_signal(PyObject *o, visitproc v, void *a) { + int e; + struct PyGeventSignalObject *p = (struct PyGeventSignalObject *)o; + e = ((likely(__pyx_ptype_6gevent_5libev_8corecext_watcher)) ? ((__pyx_ptype_6gevent_5libev_8corecext_watcher->tp_traverse) ? __pyx_ptype_6gevent_5libev_8corecext_watcher->tp_traverse(o, v, a) : 0) : __Pyx_call_next_tp_traverse(o, v, a, __pyx_tp_traverse_6gevent_5libev_8corecext_signal)); if (e) return e; + if (p->loop) { + e = (*v)(((PyObject*)p->loop), a); if (e) return e; + } + if (p->_callback) { + e = (*v)(p->_callback, a); if (e) return e; + } + if (p->args) { + e = (*v)(p->args, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_6gevent_5libev_8corecext_signal(PyObject *o) { + PyObject* tmp; + struct PyGeventSignalObject *p = (struct PyGeventSignalObject *)o; + if (likely(__pyx_ptype_6gevent_5libev_8corecext_watcher)) { if (__pyx_ptype_6gevent_5libev_8corecext_watcher->tp_clear) __pyx_ptype_6gevent_5libev_8corecext_watcher->tp_clear(o); } else __Pyx_call_next_tp_clear(o, __pyx_tp_clear_6gevent_5libev_8corecext_signal); + tmp = ((PyObject*)p->loop); + p->loop = ((struct PyGeventLoopObject *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_callback); + p->_callback = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->args); + p->args = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_6signal_ref(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_6signal_3ref_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_6signal_ref(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_6signal_3ref_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_6signal_callback(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_6signal_8callback_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_6signal_callback(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_6signal_8callback_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_6signal_priority(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_6signal_8priority_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_6signal_priority(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_6signal_8priority_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_6signal_active(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_6signal_6active_1__get__(o); +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_6signal_pending(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_6signal_7pending_1__get__(o); +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_6signal_loop(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_6signal_4loop_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_6signal_loop(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_6signal_4loop_3__set__(o, v); + } + else { + return __pyx_pw_6gevent_5libev_8corecext_6signal_4loop_5__del__(o); + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_6signal_args(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_6signal_4args_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_6signal_args(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_6signal_4args_3__set__(o, v); + } + else { + return __pyx_pw_6gevent_5libev_8corecext_6signal_4args_5__del__(o); + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_6signal__flags(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_6signal_6_flags_1__get__(o); +} + +static PyMethodDef __pyx_methods_6gevent_5libev_8corecext_signal[] = { + {"stop", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_6signal_1stop, METH_NOARGS, 0}, + {"feed", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_6signal_3feed, METH_VARARGS|METH_KEYWORDS, 0}, + {"start", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_6signal_5start, METH_VARARGS|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_6gevent_5libev_8corecext_signal[] = { + {(char *)"ref", __pyx_getprop_6gevent_5libev_8corecext_6signal_ref, __pyx_setprop_6gevent_5libev_8corecext_6signal_ref, (char *)0, 0}, + {(char *)"callback", __pyx_getprop_6gevent_5libev_8corecext_6signal_callback, __pyx_setprop_6gevent_5libev_8corecext_6signal_callback, (char *)0, 0}, + {(char *)"priority", __pyx_getprop_6gevent_5libev_8corecext_6signal_priority, __pyx_setprop_6gevent_5libev_8corecext_6signal_priority, (char *)0, 0}, + {(char *)"active", __pyx_getprop_6gevent_5libev_8corecext_6signal_active, 0, (char *)0, 0}, + {(char *)"pending", __pyx_getprop_6gevent_5libev_8corecext_6signal_pending, 0, (char *)0, 0}, + {(char *)"loop", __pyx_getprop_6gevent_5libev_8corecext_6signal_loop, __pyx_setprop_6gevent_5libev_8corecext_6signal_loop, (char *)0, 0}, + {(char *)"args", __pyx_getprop_6gevent_5libev_8corecext_6signal_args, __pyx_setprop_6gevent_5libev_8corecext_6signal_args, (char *)0, 0}, + {(char *)"_flags", __pyx_getprop_6gevent_5libev_8corecext_6signal__flags, 0, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; + +DL_EXPORT(PyTypeObject) PyGeventSignal_Type = { + PyVarObject_HEAD_INIT(0, 0) + "gevent.libev.corecext.signal", /*tp_name*/ + sizeof(struct PyGeventSignalObject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_6gevent_5libev_8corecext_signal, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + #if CYTHON_COMPILING_IN_PYPY + __pyx_pw_6gevent_5libev_8corecext_7watcher_1__repr__, /*tp_repr*/ + #else + 0, /*tp_repr*/ + #endif + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_6gevent_5libev_8corecext_signal, /*tp_traverse*/ + __pyx_tp_clear_6gevent_5libev_8corecext_signal, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_6gevent_5libev_8corecext_signal, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_6gevent_5libev_8corecext_signal, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + __pyx_pw_6gevent_5libev_8corecext_6signal_7__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_6gevent_5libev_8corecext_signal, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; + +static PyObject *__pyx_tp_new_6gevent_5libev_8corecext_idle(PyTypeObject *t, PyObject *a, PyObject *k) { + struct PyGeventIdleObject *p; + PyObject *o = __pyx_tp_new_6gevent_5libev_8corecext_watcher(t, a, k); + if (unlikely(!o)) return 0; + p = ((struct PyGeventIdleObject *)o); + p->loop = ((struct PyGeventLoopObject *)Py_None); Py_INCREF(Py_None); + p->_callback = Py_None; Py_INCREF(Py_None); + p->args = ((PyObject*)Py_None); Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_6gevent_5libev_8corecext_idle(PyObject *o) { + struct PyGeventIdleObject *p = (struct PyGeventIdleObject *)o; + #if PY_VERSION_HEX >= 0x030400a1 + if (unlikely(Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->loop); + Py_CLEAR(p->_callback); + Py_CLEAR(p->args); + #if CYTHON_USE_TYPE_SLOTS + if (PyType_IS_GC(Py_TYPE(o)->tp_base)) + #endif + PyObject_GC_Track(o); + __pyx_tp_dealloc_6gevent_5libev_8corecext_watcher(o); +} + +static int __pyx_tp_traverse_6gevent_5libev_8corecext_idle(PyObject *o, visitproc v, void *a) { + int e; + struct PyGeventIdleObject *p = (struct PyGeventIdleObject *)o; + e = ((likely(__pyx_ptype_6gevent_5libev_8corecext_watcher)) ? ((__pyx_ptype_6gevent_5libev_8corecext_watcher->tp_traverse) ? __pyx_ptype_6gevent_5libev_8corecext_watcher->tp_traverse(o, v, a) : 0) : __Pyx_call_next_tp_traverse(o, v, a, __pyx_tp_traverse_6gevent_5libev_8corecext_idle)); if (e) return e; + if (p->loop) { + e = (*v)(((PyObject*)p->loop), a); if (e) return e; + } + if (p->_callback) { + e = (*v)(p->_callback, a); if (e) return e; + } + if (p->args) { + e = (*v)(p->args, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_6gevent_5libev_8corecext_idle(PyObject *o) { + PyObject* tmp; + struct PyGeventIdleObject *p = (struct PyGeventIdleObject *)o; + if (likely(__pyx_ptype_6gevent_5libev_8corecext_watcher)) { if (__pyx_ptype_6gevent_5libev_8corecext_watcher->tp_clear) __pyx_ptype_6gevent_5libev_8corecext_watcher->tp_clear(o); } else __Pyx_call_next_tp_clear(o, __pyx_tp_clear_6gevent_5libev_8corecext_idle); + tmp = ((PyObject*)p->loop); + p->loop = ((struct PyGeventLoopObject *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_callback); + p->_callback = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->args); + p->args = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_4idle_ref(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_4idle_3ref_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_4idle_ref(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_4idle_3ref_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_4idle_callback(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_4idle_8callback_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_4idle_callback(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_4idle_8callback_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_4idle_priority(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_4idle_8priority_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_4idle_priority(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_4idle_8priority_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_4idle_active(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_4idle_6active_1__get__(o); +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_4idle_pending(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_4idle_7pending_1__get__(o); +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_4idle_loop(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_4idle_4loop_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_4idle_loop(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_4idle_4loop_3__set__(o, v); + } + else { + return __pyx_pw_6gevent_5libev_8corecext_4idle_4loop_5__del__(o); + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_4idle_args(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_4idle_4args_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_4idle_args(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_4idle_4args_3__set__(o, v); + } + else { + return __pyx_pw_6gevent_5libev_8corecext_4idle_4args_5__del__(o); + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_4idle__flags(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_4idle_6_flags_1__get__(o); +} + +static PyMethodDef __pyx_methods_6gevent_5libev_8corecext_idle[] = { + {"stop", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_4idle_1stop, METH_NOARGS, 0}, + {"feed", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_4idle_3feed, METH_VARARGS|METH_KEYWORDS, 0}, + {"start", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_4idle_5start, METH_VARARGS|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_6gevent_5libev_8corecext_idle[] = { + {(char *)"ref", __pyx_getprop_6gevent_5libev_8corecext_4idle_ref, __pyx_setprop_6gevent_5libev_8corecext_4idle_ref, (char *)0, 0}, + {(char *)"callback", __pyx_getprop_6gevent_5libev_8corecext_4idle_callback, __pyx_setprop_6gevent_5libev_8corecext_4idle_callback, (char *)0, 0}, + {(char *)"priority", __pyx_getprop_6gevent_5libev_8corecext_4idle_priority, __pyx_setprop_6gevent_5libev_8corecext_4idle_priority, (char *)0, 0}, + {(char *)"active", __pyx_getprop_6gevent_5libev_8corecext_4idle_active, 0, (char *)0, 0}, + {(char *)"pending", __pyx_getprop_6gevent_5libev_8corecext_4idle_pending, 0, (char *)0, 0}, + {(char *)"loop", __pyx_getprop_6gevent_5libev_8corecext_4idle_loop, __pyx_setprop_6gevent_5libev_8corecext_4idle_loop, (char *)0, 0}, + {(char *)"args", __pyx_getprop_6gevent_5libev_8corecext_4idle_args, __pyx_setprop_6gevent_5libev_8corecext_4idle_args, (char *)0, 0}, + {(char *)"_flags", __pyx_getprop_6gevent_5libev_8corecext_4idle__flags, 0, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; + +DL_EXPORT(PyTypeObject) PyGeventIdle_Type = { + PyVarObject_HEAD_INIT(0, 0) + "gevent.libev.corecext.idle", /*tp_name*/ + sizeof(struct PyGeventIdleObject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_6gevent_5libev_8corecext_idle, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + #if CYTHON_COMPILING_IN_PYPY + __pyx_pw_6gevent_5libev_8corecext_7watcher_1__repr__, /*tp_repr*/ + #else + 0, /*tp_repr*/ + #endif + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_6gevent_5libev_8corecext_idle, /*tp_traverse*/ + __pyx_tp_clear_6gevent_5libev_8corecext_idle, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_6gevent_5libev_8corecext_idle, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_6gevent_5libev_8corecext_idle, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + __pyx_pw_6gevent_5libev_8corecext_4idle_7__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_6gevent_5libev_8corecext_idle, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; + +static PyObject *__pyx_tp_new_6gevent_5libev_8corecext_prepare(PyTypeObject *t, PyObject *a, PyObject *k) { + struct PyGeventPrepareObject *p; + PyObject *o = __pyx_tp_new_6gevent_5libev_8corecext_watcher(t, a, k); + if (unlikely(!o)) return 0; + p = ((struct PyGeventPrepareObject *)o); + p->loop = ((struct PyGeventLoopObject *)Py_None); Py_INCREF(Py_None); + p->_callback = Py_None; Py_INCREF(Py_None); + p->args = ((PyObject*)Py_None); Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_6gevent_5libev_8corecext_prepare(PyObject *o) { + struct PyGeventPrepareObject *p = (struct PyGeventPrepareObject *)o; + #if PY_VERSION_HEX >= 0x030400a1 + if (unlikely(Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->loop); + Py_CLEAR(p->_callback); + Py_CLEAR(p->args); + #if CYTHON_USE_TYPE_SLOTS + if (PyType_IS_GC(Py_TYPE(o)->tp_base)) + #endif + PyObject_GC_Track(o); + __pyx_tp_dealloc_6gevent_5libev_8corecext_watcher(o); +} + +static int __pyx_tp_traverse_6gevent_5libev_8corecext_prepare(PyObject *o, visitproc v, void *a) { + int e; + struct PyGeventPrepareObject *p = (struct PyGeventPrepareObject *)o; + e = ((likely(__pyx_ptype_6gevent_5libev_8corecext_watcher)) ? ((__pyx_ptype_6gevent_5libev_8corecext_watcher->tp_traverse) ? __pyx_ptype_6gevent_5libev_8corecext_watcher->tp_traverse(o, v, a) : 0) : __Pyx_call_next_tp_traverse(o, v, a, __pyx_tp_traverse_6gevent_5libev_8corecext_prepare)); if (e) return e; + if (p->loop) { + e = (*v)(((PyObject*)p->loop), a); if (e) return e; + } + if (p->_callback) { + e = (*v)(p->_callback, a); if (e) return e; + } + if (p->args) { + e = (*v)(p->args, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_6gevent_5libev_8corecext_prepare(PyObject *o) { + PyObject* tmp; + struct PyGeventPrepareObject *p = (struct PyGeventPrepareObject *)o; + if (likely(__pyx_ptype_6gevent_5libev_8corecext_watcher)) { if (__pyx_ptype_6gevent_5libev_8corecext_watcher->tp_clear) __pyx_ptype_6gevent_5libev_8corecext_watcher->tp_clear(o); } else __Pyx_call_next_tp_clear(o, __pyx_tp_clear_6gevent_5libev_8corecext_prepare); + tmp = ((PyObject*)p->loop); + p->loop = ((struct PyGeventLoopObject *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_callback); + p->_callback = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->args); + p->args = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_7prepare_ref(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_7prepare_3ref_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_7prepare_ref(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_7prepare_3ref_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_7prepare_callback(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_7prepare_8callback_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_7prepare_callback(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_7prepare_8callback_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_7prepare_priority(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_7prepare_8priority_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_7prepare_priority(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_7prepare_8priority_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_7prepare_active(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_7prepare_6active_1__get__(o); +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_7prepare_pending(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_7prepare_7pending_1__get__(o); +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_7prepare_loop(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_7prepare_4loop_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_7prepare_loop(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_7prepare_4loop_3__set__(o, v); + } + else { + return __pyx_pw_6gevent_5libev_8corecext_7prepare_4loop_5__del__(o); + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_7prepare_args(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_7prepare_4args_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_7prepare_args(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_7prepare_4args_3__set__(o, v); + } + else { + return __pyx_pw_6gevent_5libev_8corecext_7prepare_4args_5__del__(o); + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_7prepare__flags(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_7prepare_6_flags_1__get__(o); +} + +static PyMethodDef __pyx_methods_6gevent_5libev_8corecext_prepare[] = { + {"stop", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_7prepare_1stop, METH_NOARGS, 0}, + {"feed", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_7prepare_3feed, METH_VARARGS|METH_KEYWORDS, 0}, + {"start", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_7prepare_5start, METH_VARARGS|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_6gevent_5libev_8corecext_prepare[] = { + {(char *)"ref", __pyx_getprop_6gevent_5libev_8corecext_7prepare_ref, __pyx_setprop_6gevent_5libev_8corecext_7prepare_ref, (char *)0, 0}, + {(char *)"callback", __pyx_getprop_6gevent_5libev_8corecext_7prepare_callback, __pyx_setprop_6gevent_5libev_8corecext_7prepare_callback, (char *)0, 0}, + {(char *)"priority", __pyx_getprop_6gevent_5libev_8corecext_7prepare_priority, __pyx_setprop_6gevent_5libev_8corecext_7prepare_priority, (char *)0, 0}, + {(char *)"active", __pyx_getprop_6gevent_5libev_8corecext_7prepare_active, 0, (char *)0, 0}, + {(char *)"pending", __pyx_getprop_6gevent_5libev_8corecext_7prepare_pending, 0, (char *)0, 0}, + {(char *)"loop", __pyx_getprop_6gevent_5libev_8corecext_7prepare_loop, __pyx_setprop_6gevent_5libev_8corecext_7prepare_loop, (char *)0, 0}, + {(char *)"args", __pyx_getprop_6gevent_5libev_8corecext_7prepare_args, __pyx_setprop_6gevent_5libev_8corecext_7prepare_args, (char *)0, 0}, + {(char *)"_flags", __pyx_getprop_6gevent_5libev_8corecext_7prepare__flags, 0, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; + +DL_EXPORT(PyTypeObject) PyGeventPrepare_Type = { + PyVarObject_HEAD_INIT(0, 0) + "gevent.libev.corecext.prepare", /*tp_name*/ + sizeof(struct PyGeventPrepareObject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_6gevent_5libev_8corecext_prepare, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + #if CYTHON_COMPILING_IN_PYPY + __pyx_pw_6gevent_5libev_8corecext_7watcher_1__repr__, /*tp_repr*/ + #else + 0, /*tp_repr*/ + #endif + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_6gevent_5libev_8corecext_prepare, /*tp_traverse*/ + __pyx_tp_clear_6gevent_5libev_8corecext_prepare, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_6gevent_5libev_8corecext_prepare, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_6gevent_5libev_8corecext_prepare, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + __pyx_pw_6gevent_5libev_8corecext_7prepare_7__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_6gevent_5libev_8corecext_prepare, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; + +static PyObject *__pyx_tp_new_6gevent_5libev_8corecext_check(PyTypeObject *t, PyObject *a, PyObject *k) { + struct PyGeventCheckObject *p; + PyObject *o = __pyx_tp_new_6gevent_5libev_8corecext_watcher(t, a, k); + if (unlikely(!o)) return 0; + p = ((struct PyGeventCheckObject *)o); + p->loop = ((struct PyGeventLoopObject *)Py_None); Py_INCREF(Py_None); + p->_callback = Py_None; Py_INCREF(Py_None); + p->args = ((PyObject*)Py_None); Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_6gevent_5libev_8corecext_check(PyObject *o) { + struct PyGeventCheckObject *p = (struct PyGeventCheckObject *)o; + #if PY_VERSION_HEX >= 0x030400a1 + if (unlikely(Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->loop); + Py_CLEAR(p->_callback); + Py_CLEAR(p->args); + #if CYTHON_USE_TYPE_SLOTS + if (PyType_IS_GC(Py_TYPE(o)->tp_base)) + #endif + PyObject_GC_Track(o); + __pyx_tp_dealloc_6gevent_5libev_8corecext_watcher(o); +} + +static int __pyx_tp_traverse_6gevent_5libev_8corecext_check(PyObject *o, visitproc v, void *a) { + int e; + struct PyGeventCheckObject *p = (struct PyGeventCheckObject *)o; + e = ((likely(__pyx_ptype_6gevent_5libev_8corecext_watcher)) ? ((__pyx_ptype_6gevent_5libev_8corecext_watcher->tp_traverse) ? __pyx_ptype_6gevent_5libev_8corecext_watcher->tp_traverse(o, v, a) : 0) : __Pyx_call_next_tp_traverse(o, v, a, __pyx_tp_traverse_6gevent_5libev_8corecext_check)); if (e) return e; + if (p->loop) { + e = (*v)(((PyObject*)p->loop), a); if (e) return e; + } + if (p->_callback) { + e = (*v)(p->_callback, a); if (e) return e; + } + if (p->args) { + e = (*v)(p->args, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_6gevent_5libev_8corecext_check(PyObject *o) { + PyObject* tmp; + struct PyGeventCheckObject *p = (struct PyGeventCheckObject *)o; + if (likely(__pyx_ptype_6gevent_5libev_8corecext_watcher)) { if (__pyx_ptype_6gevent_5libev_8corecext_watcher->tp_clear) __pyx_ptype_6gevent_5libev_8corecext_watcher->tp_clear(o); } else __Pyx_call_next_tp_clear(o, __pyx_tp_clear_6gevent_5libev_8corecext_check); + tmp = ((PyObject*)p->loop); + p->loop = ((struct PyGeventLoopObject *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_callback); + p->_callback = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->args); + p->args = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_5check_ref(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_5check_3ref_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_5check_ref(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_5check_3ref_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_5check_callback(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_5check_8callback_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_5check_callback(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_5check_8callback_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_5check_priority(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_5check_8priority_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_5check_priority(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_5check_8priority_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_5check_active(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_5check_6active_1__get__(o); +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_5check_pending(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_5check_7pending_1__get__(o); +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_5check_loop(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_5check_4loop_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_5check_loop(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_5check_4loop_3__set__(o, v); + } + else { + return __pyx_pw_6gevent_5libev_8corecext_5check_4loop_5__del__(o); + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_5check_args(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_5check_4args_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_5check_args(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_5check_4args_3__set__(o, v); + } + else { + return __pyx_pw_6gevent_5libev_8corecext_5check_4args_5__del__(o); + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_5check__flags(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_5check_6_flags_1__get__(o); +} + +static PyMethodDef __pyx_methods_6gevent_5libev_8corecext_check[] = { + {"stop", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_5check_1stop, METH_NOARGS, 0}, + {"feed", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_5check_3feed, METH_VARARGS|METH_KEYWORDS, 0}, + {"start", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_5check_5start, METH_VARARGS|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_6gevent_5libev_8corecext_check[] = { + {(char *)"ref", __pyx_getprop_6gevent_5libev_8corecext_5check_ref, __pyx_setprop_6gevent_5libev_8corecext_5check_ref, (char *)0, 0}, + {(char *)"callback", __pyx_getprop_6gevent_5libev_8corecext_5check_callback, __pyx_setprop_6gevent_5libev_8corecext_5check_callback, (char *)0, 0}, + {(char *)"priority", __pyx_getprop_6gevent_5libev_8corecext_5check_priority, __pyx_setprop_6gevent_5libev_8corecext_5check_priority, (char *)0, 0}, + {(char *)"active", __pyx_getprop_6gevent_5libev_8corecext_5check_active, 0, (char *)0, 0}, + {(char *)"pending", __pyx_getprop_6gevent_5libev_8corecext_5check_pending, 0, (char *)0, 0}, + {(char *)"loop", __pyx_getprop_6gevent_5libev_8corecext_5check_loop, __pyx_setprop_6gevent_5libev_8corecext_5check_loop, (char *)0, 0}, + {(char *)"args", __pyx_getprop_6gevent_5libev_8corecext_5check_args, __pyx_setprop_6gevent_5libev_8corecext_5check_args, (char *)0, 0}, + {(char *)"_flags", __pyx_getprop_6gevent_5libev_8corecext_5check__flags, 0, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; + +DL_EXPORT(PyTypeObject) PyGeventCheck_Type = { + PyVarObject_HEAD_INIT(0, 0) + "gevent.libev.corecext.check", /*tp_name*/ + sizeof(struct PyGeventCheckObject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_6gevent_5libev_8corecext_check, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + #if CYTHON_COMPILING_IN_PYPY + __pyx_pw_6gevent_5libev_8corecext_7watcher_1__repr__, /*tp_repr*/ + #else + 0, /*tp_repr*/ + #endif + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_6gevent_5libev_8corecext_check, /*tp_traverse*/ + __pyx_tp_clear_6gevent_5libev_8corecext_check, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_6gevent_5libev_8corecext_check, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_6gevent_5libev_8corecext_check, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + __pyx_pw_6gevent_5libev_8corecext_5check_7__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_6gevent_5libev_8corecext_check, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; + +static PyObject *__pyx_tp_new_6gevent_5libev_8corecext_fork(PyTypeObject *t, PyObject *a, PyObject *k) { + struct PyGeventForkObject *p; + PyObject *o = __pyx_tp_new_6gevent_5libev_8corecext_watcher(t, a, k); + if (unlikely(!o)) return 0; + p = ((struct PyGeventForkObject *)o); + p->loop = ((struct PyGeventLoopObject *)Py_None); Py_INCREF(Py_None); + p->_callback = Py_None; Py_INCREF(Py_None); + p->args = ((PyObject*)Py_None); Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_6gevent_5libev_8corecext_fork(PyObject *o) { + struct PyGeventForkObject *p = (struct PyGeventForkObject *)o; + #if PY_VERSION_HEX >= 0x030400a1 + if (unlikely(Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->loop); + Py_CLEAR(p->_callback); + Py_CLEAR(p->args); + #if CYTHON_USE_TYPE_SLOTS + if (PyType_IS_GC(Py_TYPE(o)->tp_base)) + #endif + PyObject_GC_Track(o); + __pyx_tp_dealloc_6gevent_5libev_8corecext_watcher(o); +} + +static int __pyx_tp_traverse_6gevent_5libev_8corecext_fork(PyObject *o, visitproc v, void *a) { + int e; + struct PyGeventForkObject *p = (struct PyGeventForkObject *)o; + e = ((likely(__pyx_ptype_6gevent_5libev_8corecext_watcher)) ? ((__pyx_ptype_6gevent_5libev_8corecext_watcher->tp_traverse) ? __pyx_ptype_6gevent_5libev_8corecext_watcher->tp_traverse(o, v, a) : 0) : __Pyx_call_next_tp_traverse(o, v, a, __pyx_tp_traverse_6gevent_5libev_8corecext_fork)); if (e) return e; + if (p->loop) { + e = (*v)(((PyObject*)p->loop), a); if (e) return e; + } + if (p->_callback) { + e = (*v)(p->_callback, a); if (e) return e; + } + if (p->args) { + e = (*v)(p->args, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_6gevent_5libev_8corecext_fork(PyObject *o) { + PyObject* tmp; + struct PyGeventForkObject *p = (struct PyGeventForkObject *)o; + if (likely(__pyx_ptype_6gevent_5libev_8corecext_watcher)) { if (__pyx_ptype_6gevent_5libev_8corecext_watcher->tp_clear) __pyx_ptype_6gevent_5libev_8corecext_watcher->tp_clear(o); } else __Pyx_call_next_tp_clear(o, __pyx_tp_clear_6gevent_5libev_8corecext_fork); + tmp = ((PyObject*)p->loop); + p->loop = ((struct PyGeventLoopObject *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_callback); + p->_callback = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->args); + p->args = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_4fork_ref(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_4fork_3ref_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_4fork_ref(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_4fork_3ref_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_4fork_callback(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_4fork_8callback_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_4fork_callback(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_4fork_8callback_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_4fork_priority(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_4fork_8priority_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_4fork_priority(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_4fork_8priority_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_4fork_active(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_4fork_6active_1__get__(o); +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_4fork_pending(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_4fork_7pending_1__get__(o); +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_4fork_loop(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_4fork_4loop_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_4fork_loop(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_4fork_4loop_3__set__(o, v); + } + else { + return __pyx_pw_6gevent_5libev_8corecext_4fork_4loop_5__del__(o); + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_4fork_args(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_4fork_4args_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_4fork_args(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_4fork_4args_3__set__(o, v); + } + else { + return __pyx_pw_6gevent_5libev_8corecext_4fork_4args_5__del__(o); + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_4fork__flags(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_4fork_6_flags_1__get__(o); +} + +static PyMethodDef __pyx_methods_6gevent_5libev_8corecext_fork[] = { + {"stop", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_4fork_1stop, METH_NOARGS, 0}, + {"feed", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_4fork_3feed, METH_VARARGS|METH_KEYWORDS, 0}, + {"start", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_4fork_5start, METH_VARARGS|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_6gevent_5libev_8corecext_fork[] = { + {(char *)"ref", __pyx_getprop_6gevent_5libev_8corecext_4fork_ref, __pyx_setprop_6gevent_5libev_8corecext_4fork_ref, (char *)0, 0}, + {(char *)"callback", __pyx_getprop_6gevent_5libev_8corecext_4fork_callback, __pyx_setprop_6gevent_5libev_8corecext_4fork_callback, (char *)0, 0}, + {(char *)"priority", __pyx_getprop_6gevent_5libev_8corecext_4fork_priority, __pyx_setprop_6gevent_5libev_8corecext_4fork_priority, (char *)0, 0}, + {(char *)"active", __pyx_getprop_6gevent_5libev_8corecext_4fork_active, 0, (char *)0, 0}, + {(char *)"pending", __pyx_getprop_6gevent_5libev_8corecext_4fork_pending, 0, (char *)0, 0}, + {(char *)"loop", __pyx_getprop_6gevent_5libev_8corecext_4fork_loop, __pyx_setprop_6gevent_5libev_8corecext_4fork_loop, (char *)0, 0}, + {(char *)"args", __pyx_getprop_6gevent_5libev_8corecext_4fork_args, __pyx_setprop_6gevent_5libev_8corecext_4fork_args, (char *)0, 0}, + {(char *)"_flags", __pyx_getprop_6gevent_5libev_8corecext_4fork__flags, 0, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; + +DL_EXPORT(PyTypeObject) PyGeventFork_Type = { + PyVarObject_HEAD_INIT(0, 0) + "gevent.libev.corecext.fork", /*tp_name*/ + sizeof(struct PyGeventForkObject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_6gevent_5libev_8corecext_fork, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + #if CYTHON_COMPILING_IN_PYPY + __pyx_pw_6gevent_5libev_8corecext_7watcher_1__repr__, /*tp_repr*/ + #else + 0, /*tp_repr*/ + #endif + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_6gevent_5libev_8corecext_fork, /*tp_traverse*/ + __pyx_tp_clear_6gevent_5libev_8corecext_fork, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_6gevent_5libev_8corecext_fork, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_6gevent_5libev_8corecext_fork, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + __pyx_pw_6gevent_5libev_8corecext_4fork_7__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_6gevent_5libev_8corecext_fork, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; + +static PyObject *__pyx_tp_new_6gevent_5libev_8corecext_async(PyTypeObject *t, PyObject *a, PyObject *k) { + struct PyGeventAsyncObject *p; + PyObject *o = __pyx_tp_new_6gevent_5libev_8corecext_watcher(t, a, k); + if (unlikely(!o)) return 0; + p = ((struct PyGeventAsyncObject *)o); + p->loop = ((struct PyGeventLoopObject *)Py_None); Py_INCREF(Py_None); + p->_callback = Py_None; Py_INCREF(Py_None); + p->args = ((PyObject*)Py_None); Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_6gevent_5libev_8corecext_async(PyObject *o) { + struct PyGeventAsyncObject *p = (struct PyGeventAsyncObject *)o; + #if PY_VERSION_HEX >= 0x030400a1 + if (unlikely(Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->loop); + Py_CLEAR(p->_callback); + Py_CLEAR(p->args); + #if CYTHON_USE_TYPE_SLOTS + if (PyType_IS_GC(Py_TYPE(o)->tp_base)) + #endif + PyObject_GC_Track(o); + __pyx_tp_dealloc_6gevent_5libev_8corecext_watcher(o); +} + +static int __pyx_tp_traverse_6gevent_5libev_8corecext_async(PyObject *o, visitproc v, void *a) { + int e; + struct PyGeventAsyncObject *p = (struct PyGeventAsyncObject *)o; + e = ((likely(__pyx_ptype_6gevent_5libev_8corecext_watcher)) ? ((__pyx_ptype_6gevent_5libev_8corecext_watcher->tp_traverse) ? __pyx_ptype_6gevent_5libev_8corecext_watcher->tp_traverse(o, v, a) : 0) : __Pyx_call_next_tp_traverse(o, v, a, __pyx_tp_traverse_6gevent_5libev_8corecext_async)); if (e) return e; + if (p->loop) { + e = (*v)(((PyObject*)p->loop), a); if (e) return e; + } + if (p->_callback) { + e = (*v)(p->_callback, a); if (e) return e; + } + if (p->args) { + e = (*v)(p->args, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_6gevent_5libev_8corecext_async(PyObject *o) { + PyObject* tmp; + struct PyGeventAsyncObject *p = (struct PyGeventAsyncObject *)o; + if (likely(__pyx_ptype_6gevent_5libev_8corecext_watcher)) { if (__pyx_ptype_6gevent_5libev_8corecext_watcher->tp_clear) __pyx_ptype_6gevent_5libev_8corecext_watcher->tp_clear(o); } else __Pyx_call_next_tp_clear(o, __pyx_tp_clear_6gevent_5libev_8corecext_async); + tmp = ((PyObject*)p->loop); + p->loop = ((struct PyGeventLoopObject *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_callback); + p->_callback = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->args); + p->args = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_5async_ref(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_5async_3ref_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_5async_ref(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_5async_3ref_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_5async_callback(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_5async_8callback_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_5async_callback(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_5async_8callback_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_5async_priority(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_5async_8priority_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_5async_priority(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_5async_8priority_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_5async_active(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_5async_6active_1__get__(o); +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_5async_pending(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_5async_7pending_1__get__(o); +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_5async_loop(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_5async_4loop_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_5async_loop(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_5async_4loop_3__set__(o, v); + } + else { + return __pyx_pw_6gevent_5libev_8corecext_5async_4loop_5__del__(o); + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_5async_args(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_5async_4args_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_5async_args(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_5async_4args_3__set__(o, v); + } + else { + return __pyx_pw_6gevent_5libev_8corecext_5async_4args_5__del__(o); + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_5async__flags(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_5async_6_flags_1__get__(o); +} + +static PyMethodDef __pyx_methods_6gevent_5libev_8corecext_async[] = { + {"stop", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_5async_1stop, METH_NOARGS, 0}, + {"feed", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_5async_3feed, METH_VARARGS|METH_KEYWORDS, 0}, + {"start", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_5async_5start, METH_VARARGS|METH_KEYWORDS, 0}, + {"send", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_5async_9send, METH_NOARGS, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_6gevent_5libev_8corecext_async[] = { + {(char *)"ref", __pyx_getprop_6gevent_5libev_8corecext_5async_ref, __pyx_setprop_6gevent_5libev_8corecext_5async_ref, (char *)0, 0}, + {(char *)"callback", __pyx_getprop_6gevent_5libev_8corecext_5async_callback, __pyx_setprop_6gevent_5libev_8corecext_5async_callback, (char *)0, 0}, + {(char *)"priority", __pyx_getprop_6gevent_5libev_8corecext_5async_priority, __pyx_setprop_6gevent_5libev_8corecext_5async_priority, (char *)0, 0}, + {(char *)"active", __pyx_getprop_6gevent_5libev_8corecext_5async_active, 0, (char *)0, 0}, + {(char *)"pending", __pyx_getprop_6gevent_5libev_8corecext_5async_pending, 0, (char *)0, 0}, + {(char *)"loop", __pyx_getprop_6gevent_5libev_8corecext_5async_loop, __pyx_setprop_6gevent_5libev_8corecext_5async_loop, (char *)0, 0}, + {(char *)"args", __pyx_getprop_6gevent_5libev_8corecext_5async_args, __pyx_setprop_6gevent_5libev_8corecext_5async_args, (char *)0, 0}, + {(char *)"_flags", __pyx_getprop_6gevent_5libev_8corecext_5async__flags, 0, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; + +DL_EXPORT(PyTypeObject) PyGeventAsync_Type = { + PyVarObject_HEAD_INIT(0, 0) + "gevent.libev.corecext.async", /*tp_name*/ + sizeof(struct PyGeventAsyncObject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_6gevent_5libev_8corecext_async, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + #if CYTHON_COMPILING_IN_PYPY + __pyx_pw_6gevent_5libev_8corecext_7watcher_1__repr__, /*tp_repr*/ + #else + 0, /*tp_repr*/ + #endif + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_6gevent_5libev_8corecext_async, /*tp_traverse*/ + __pyx_tp_clear_6gevent_5libev_8corecext_async, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_6gevent_5libev_8corecext_async, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_6gevent_5libev_8corecext_async, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + __pyx_pw_6gevent_5libev_8corecext_5async_7__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_6gevent_5libev_8corecext_async, /*tp_new*/ +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; + +static PyObject *__pyx_tp_new_6gevent_5libev_8corecext_child(PyTypeObject *t, PyObject *a, PyObject *k) { + struct PyGeventChildObject *p; + PyObject *o = __pyx_tp_new_6gevent_5libev_8corecext_watcher(t, a, k); + if (unlikely(!o)) return 0; + p = ((struct PyGeventChildObject *)o); + p->loop = ((struct PyGeventLoopObject *)Py_None); Py_INCREF(Py_None); + p->_callback = Py_None; Py_INCREF(Py_None); + p->args = ((PyObject*)Py_None); Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_6gevent_5libev_8corecext_child(PyObject *o) { + struct PyGeventChildObject *p = (struct PyGeventChildObject *)o; + #if PY_VERSION_HEX >= 0x030400a1 + if (unlikely(Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->loop); + Py_CLEAR(p->_callback); + Py_CLEAR(p->args); + #if CYTHON_USE_TYPE_SLOTS + if (PyType_IS_GC(Py_TYPE(o)->tp_base)) + #endif + PyObject_GC_Track(o); + __pyx_tp_dealloc_6gevent_5libev_8corecext_watcher(o); +} + +static int __pyx_tp_traverse_6gevent_5libev_8corecext_child(PyObject *o, visitproc v, void *a) { + int e; + struct PyGeventChildObject *p = (struct PyGeventChildObject *)o; + e = ((likely(__pyx_ptype_6gevent_5libev_8corecext_watcher)) ? ((__pyx_ptype_6gevent_5libev_8corecext_watcher->tp_traverse) ? __pyx_ptype_6gevent_5libev_8corecext_watcher->tp_traverse(o, v, a) : 0) : __Pyx_call_next_tp_traverse(o, v, a, __pyx_tp_traverse_6gevent_5libev_8corecext_child)); if (e) return e; + if (p->loop) { + e = (*v)(((PyObject*)p->loop), a); if (e) return e; + } + if (p->_callback) { + e = (*v)(p->_callback, a); if (e) return e; + } + if (p->args) { + e = (*v)(p->args, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_6gevent_5libev_8corecext_child(PyObject *o) { + PyObject* tmp; + struct PyGeventChildObject *p = (struct PyGeventChildObject *)o; + if (likely(__pyx_ptype_6gevent_5libev_8corecext_watcher)) { if (__pyx_ptype_6gevent_5libev_8corecext_watcher->tp_clear) __pyx_ptype_6gevent_5libev_8corecext_watcher->tp_clear(o); } else __Pyx_call_next_tp_clear(o, __pyx_tp_clear_6gevent_5libev_8corecext_child); + tmp = ((PyObject*)p->loop); + p->loop = ((struct PyGeventLoopObject *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_callback); + p->_callback = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->args); + p->args = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_5child_ref(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_5child_3ref_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_5child_ref(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_5child_3ref_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_5child_callback(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_5child_8callback_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_5child_callback(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_5child_8callback_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_5child_priority(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_5child_8priority_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_5child_priority(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_5child_8priority_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_5child_active(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_5child_6active_1__get__(o); +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_5child_pending(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_5child_7pending_1__get__(o); +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_5child_pid(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_5child_3pid_1__get__(o); +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_5child_rpid(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_5child_4rpid_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_5child_rpid(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_5child_4rpid_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_5child_rstatus(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_5child_7rstatus_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_5child_rstatus(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_5child_7rstatus_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_5child_loop(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_5child_4loop_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_5child_loop(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_5child_4loop_3__set__(o, v); + } + else { + return __pyx_pw_6gevent_5libev_8corecext_5child_4loop_5__del__(o); + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_5child_args(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_5child_4args_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_5child_args(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_5child_4args_3__set__(o, v); + } + else { + return __pyx_pw_6gevent_5libev_8corecext_5child_4args_5__del__(o); + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_5child__flags(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_5child_6_flags_1__get__(o); +} + +static PyMethodDef __pyx_methods_6gevent_5libev_8corecext_child[] = { + {"stop", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_5child_1stop, METH_NOARGS, 0}, + {"feed", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_5child_3feed, METH_VARARGS|METH_KEYWORDS, 0}, + {"start", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_5child_5start, METH_VARARGS|METH_KEYWORDS, 0}, + {"_format", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_5child_9_format, METH_NOARGS, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_6gevent_5libev_8corecext_child[] = { + {(char *)"ref", __pyx_getprop_6gevent_5libev_8corecext_5child_ref, __pyx_setprop_6gevent_5libev_8corecext_5child_ref, (char *)0, 0}, + {(char *)"callback", __pyx_getprop_6gevent_5libev_8corecext_5child_callback, __pyx_setprop_6gevent_5libev_8corecext_5child_callback, (char *)0, 0}, + {(char *)"priority", __pyx_getprop_6gevent_5libev_8corecext_5child_priority, __pyx_setprop_6gevent_5libev_8corecext_5child_priority, (char *)0, 0}, + {(char *)"active", __pyx_getprop_6gevent_5libev_8corecext_5child_active, 0, (char *)0, 0}, + {(char *)"pending", __pyx_getprop_6gevent_5libev_8corecext_5child_pending, 0, (char *)0, 0}, + {(char *)"pid", __pyx_getprop_6gevent_5libev_8corecext_5child_pid, 0, (char *)0, 0}, + {(char *)"rpid", __pyx_getprop_6gevent_5libev_8corecext_5child_rpid, __pyx_setprop_6gevent_5libev_8corecext_5child_rpid, (char *)0, 0}, + {(char *)"rstatus", __pyx_getprop_6gevent_5libev_8corecext_5child_rstatus, __pyx_setprop_6gevent_5libev_8corecext_5child_rstatus, (char *)0, 0}, + {(char *)"loop", __pyx_getprop_6gevent_5libev_8corecext_5child_loop, __pyx_setprop_6gevent_5libev_8corecext_5child_loop, (char *)0, 0}, + {(char *)"args", __pyx_getprop_6gevent_5libev_8corecext_5child_args, __pyx_setprop_6gevent_5libev_8corecext_5child_args, (char *)0, 0}, + {(char *)"_flags", __pyx_getprop_6gevent_5libev_8corecext_5child__flags, 0, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; + +DL_EXPORT(PyTypeObject) PyGeventChild_Type = { + PyVarObject_HEAD_INIT(0, 0) + "gevent.libev.corecext.child", /*tp_name*/ + sizeof(struct PyGeventChildObject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_6gevent_5libev_8corecext_child, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + #if CYTHON_COMPILING_IN_PYPY + __pyx_pw_6gevent_5libev_8corecext_7watcher_1__repr__, /*tp_repr*/ + #else + 0, /*tp_repr*/ + #endif + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_6gevent_5libev_8corecext_child, /*tp_traverse*/ + __pyx_tp_clear_6gevent_5libev_8corecext_child, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_6gevent_5libev_8corecext_child, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_6gevent_5libev_8corecext_child, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + __pyx_pw_6gevent_5libev_8corecext_5child_7__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_6gevent_5libev_8corecext_child, /*tp_new*/ +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; + +static PyObject *__pyx_tp_new_6gevent_5libev_8corecext_stat(PyTypeObject *t, PyObject *a, PyObject *k) { + struct PyGeventStatObject *p; + PyObject *o = __pyx_tp_new_6gevent_5libev_8corecext_watcher(t, a, k); + if (unlikely(!o)) return 0; + p = ((struct PyGeventStatObject *)o); + p->loop = ((struct PyGeventLoopObject *)Py_None); Py_INCREF(Py_None); + p->_callback = Py_None; Py_INCREF(Py_None); + p->args = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->path = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->_paths = ((PyObject*)Py_None); Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_6gevent_5libev_8corecext_stat(PyObject *o) { + struct PyGeventStatObject *p = (struct PyGeventStatObject *)o; + #if PY_VERSION_HEX >= 0x030400a1 + if (unlikely(Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->loop); + Py_CLEAR(p->_callback); + Py_CLEAR(p->args); + Py_CLEAR(p->path); + Py_CLEAR(p->_paths); + #if CYTHON_USE_TYPE_SLOTS + if (PyType_IS_GC(Py_TYPE(o)->tp_base)) + #endif + PyObject_GC_Track(o); + __pyx_tp_dealloc_6gevent_5libev_8corecext_watcher(o); +} + +static int __pyx_tp_traverse_6gevent_5libev_8corecext_stat(PyObject *o, visitproc v, void *a) { + int e; + struct PyGeventStatObject *p = (struct PyGeventStatObject *)o; + e = ((likely(__pyx_ptype_6gevent_5libev_8corecext_watcher)) ? ((__pyx_ptype_6gevent_5libev_8corecext_watcher->tp_traverse) ? __pyx_ptype_6gevent_5libev_8corecext_watcher->tp_traverse(o, v, a) : 0) : __Pyx_call_next_tp_traverse(o, v, a, __pyx_tp_traverse_6gevent_5libev_8corecext_stat)); if (e) return e; + if (p->loop) { + e = (*v)(((PyObject*)p->loop), a); if (e) return e; + } + if (p->_callback) { + e = (*v)(p->_callback, a); if (e) return e; + } + if (p->args) { + e = (*v)(p->args, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_6gevent_5libev_8corecext_stat(PyObject *o) { + PyObject* tmp; + struct PyGeventStatObject *p = (struct PyGeventStatObject *)o; + if (likely(__pyx_ptype_6gevent_5libev_8corecext_watcher)) { if (__pyx_ptype_6gevent_5libev_8corecext_watcher->tp_clear) __pyx_ptype_6gevent_5libev_8corecext_watcher->tp_clear(o); } else __Pyx_call_next_tp_clear(o, __pyx_tp_clear_6gevent_5libev_8corecext_stat); + tmp = ((PyObject*)p->loop); + p->loop = ((struct PyGeventLoopObject *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_callback); + p->_callback = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->args); + p->args = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_4stat_ref(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_4stat_3ref_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_4stat_ref(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_4stat_3ref_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_4stat_callback(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_4stat_8callback_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_4stat_callback(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_4stat_8callback_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_4stat_priority(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_4stat_8priority_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_4stat_priority(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_4stat_8priority_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_4stat_active(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_4stat_6active_1__get__(o); +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_4stat_pending(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_4stat_7pending_1__get__(o); +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_4stat_attr(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_4stat_4attr_1__get__(o); +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_4stat_prev(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_4stat_4prev_1__get__(o); +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_4stat_interval(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_4stat_8interval_1__get__(o); +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_4stat_loop(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_4stat_4loop_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_4stat_loop(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_4stat_4loop_3__set__(o, v); + } + else { + return __pyx_pw_6gevent_5libev_8corecext_4stat_4loop_5__del__(o); + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_4stat_args(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_4stat_4args_1__get__(o); +} + +static int __pyx_setprop_6gevent_5libev_8corecext_4stat_args(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_6gevent_5libev_8corecext_4stat_4args_3__set__(o, v); + } + else { + return __pyx_pw_6gevent_5libev_8corecext_4stat_4args_5__del__(o); + } +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_4stat__flags(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_4stat_6_flags_1__get__(o); +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_4stat_path(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_4stat_4path_1__get__(o); +} + +static PyObject *__pyx_getprop_6gevent_5libev_8corecext_4stat__paths(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_6gevent_5libev_8corecext_4stat_6_paths_1__get__(o); +} + +static PyMethodDef __pyx_methods_6gevent_5libev_8corecext_stat[] = { + {"stop", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_4stat_1stop, METH_NOARGS, 0}, + {"feed", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_4stat_3feed, METH_VARARGS|METH_KEYWORDS, 0}, + {"start", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_4stat_5start, METH_VARARGS|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_6gevent_5libev_8corecext_stat[] = { + {(char *)"ref", __pyx_getprop_6gevent_5libev_8corecext_4stat_ref, __pyx_setprop_6gevent_5libev_8corecext_4stat_ref, (char *)0, 0}, + {(char *)"callback", __pyx_getprop_6gevent_5libev_8corecext_4stat_callback, __pyx_setprop_6gevent_5libev_8corecext_4stat_callback, (char *)0, 0}, + {(char *)"priority", __pyx_getprop_6gevent_5libev_8corecext_4stat_priority, __pyx_setprop_6gevent_5libev_8corecext_4stat_priority, (char *)0, 0}, + {(char *)"active", __pyx_getprop_6gevent_5libev_8corecext_4stat_active, 0, (char *)0, 0}, + {(char *)"pending", __pyx_getprop_6gevent_5libev_8corecext_4stat_pending, 0, (char *)0, 0}, + {(char *)"attr", __pyx_getprop_6gevent_5libev_8corecext_4stat_attr, 0, (char *)0, 0}, + {(char *)"prev", __pyx_getprop_6gevent_5libev_8corecext_4stat_prev, 0, (char *)0, 0}, + {(char *)"interval", __pyx_getprop_6gevent_5libev_8corecext_4stat_interval, 0, (char *)0, 0}, + {(char *)"loop", __pyx_getprop_6gevent_5libev_8corecext_4stat_loop, __pyx_setprop_6gevent_5libev_8corecext_4stat_loop, (char *)0, 0}, + {(char *)"args", __pyx_getprop_6gevent_5libev_8corecext_4stat_args, __pyx_setprop_6gevent_5libev_8corecext_4stat_args, (char *)0, 0}, + {(char *)"_flags", __pyx_getprop_6gevent_5libev_8corecext_4stat__flags, 0, (char *)0, 0}, + {(char *)"path", __pyx_getprop_6gevent_5libev_8corecext_4stat_path, 0, (char *)0, 0}, + {(char *)"_paths", __pyx_getprop_6gevent_5libev_8corecext_4stat__paths, 0, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; + +DL_EXPORT(PyTypeObject) PyGeventStat_Type = { + PyVarObject_HEAD_INIT(0, 0) + "gevent.libev.corecext.stat", /*tp_name*/ + sizeof(struct PyGeventStatObject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_6gevent_5libev_8corecext_stat, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + #if CYTHON_COMPILING_IN_PYPY + __pyx_pw_6gevent_5libev_8corecext_7watcher_1__repr__, /*tp_repr*/ + #else + 0, /*tp_repr*/ + #endif + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_6gevent_5libev_8corecext_stat, /*tp_traverse*/ + __pyx_tp_clear_6gevent_5libev_8corecext_stat, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_6gevent_5libev_8corecext_stat, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_6gevent_5libev_8corecext_stat, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + __pyx_pw_6gevent_5libev_8corecext_4stat_7__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_6gevent_5libev_8corecext_stat, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; + +static struct __pyx_obj_6gevent_5libev_8corecext___pyx_scope_struct__genexpr *__pyx_freelist_6gevent_5libev_8corecext___pyx_scope_struct__genexpr[8]; +static int __pyx_freecount_6gevent_5libev_8corecext___pyx_scope_struct__genexpr = 0; + +static PyObject *__pyx_tp_new_6gevent_5libev_8corecext___pyx_scope_struct__genexpr(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6gevent_5libev_8corecext___pyx_scope_struct__genexpr > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6gevent_5libev_8corecext___pyx_scope_struct__genexpr)))) { + o = (PyObject*)__pyx_freelist_6gevent_5libev_8corecext___pyx_scope_struct__genexpr[--__pyx_freecount_6gevent_5libev_8corecext___pyx_scope_struct__genexpr]; + memset(o, 0, sizeof(struct __pyx_obj_6gevent_5libev_8corecext___pyx_scope_struct__genexpr)); + (void) PyObject_INIT(o, t); + PyObject_GC_Track(o); + } else { + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + } + return o; +} + +static void __pyx_tp_dealloc_6gevent_5libev_8corecext___pyx_scope_struct__genexpr(PyObject *o) { + struct __pyx_obj_6gevent_5libev_8corecext___pyx_scope_struct__genexpr *p = (struct __pyx_obj_6gevent_5libev_8corecext___pyx_scope_struct__genexpr *)o; + PyObject_GC_UnTrack(o); + Py_CLEAR(p->__pyx_v_flag); + Py_CLEAR(p->__pyx_v_string); + if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6gevent_5libev_8corecext___pyx_scope_struct__genexpr < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6gevent_5libev_8corecext___pyx_scope_struct__genexpr)))) { + __pyx_freelist_6gevent_5libev_8corecext___pyx_scope_struct__genexpr[__pyx_freecount_6gevent_5libev_8corecext___pyx_scope_struct__genexpr++] = ((struct __pyx_obj_6gevent_5libev_8corecext___pyx_scope_struct__genexpr *)o); + } else { + (*Py_TYPE(o)->tp_free)(o); + } +} + +static int __pyx_tp_traverse_6gevent_5libev_8corecext___pyx_scope_struct__genexpr(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_6gevent_5libev_8corecext___pyx_scope_struct__genexpr *p = (struct __pyx_obj_6gevent_5libev_8corecext___pyx_scope_struct__genexpr *)o; + if (p->__pyx_v_flag) { + e = (*v)(p->__pyx_v_flag, a); if (e) return e; + } + if (p->__pyx_v_string) { + e = (*v)(p->__pyx_v_string, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_6gevent_5libev_8corecext___pyx_scope_struct__genexpr(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_6gevent_5libev_8corecext___pyx_scope_struct__genexpr *p = (struct __pyx_obj_6gevent_5libev_8corecext___pyx_scope_struct__genexpr *)o; + tmp = ((PyObject*)p->__pyx_v_flag); + p->__pyx_v_flag = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->__pyx_v_string); + p->__pyx_v_string = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyTypeObject __pyx_type_6gevent_5libev_8corecext___pyx_scope_struct__genexpr = { + PyVarObject_HEAD_INIT(0, 0) + "gevent.libev.corecext.__pyx_scope_struct__genexpr", /*tp_name*/ + sizeof(struct __pyx_obj_6gevent_5libev_8corecext___pyx_scope_struct__genexpr), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_6gevent_5libev_8corecext___pyx_scope_struct__genexpr, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_6gevent_5libev_8corecext___pyx_scope_struct__genexpr, /*tp_traverse*/ + __pyx_tp_clear_6gevent_5libev_8corecext___pyx_scope_struct__genexpr, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_6gevent_5libev_8corecext___pyx_scope_struct__genexpr, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; + +static PyMethodDef __pyx_methods[] = { + {"_flags_to_list", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_5_flags_to_list, METH_O, 0}, + {"_flags_to_int", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_7_flags_to_int, METH_O, 0}, + {"_check_flags", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_9_check_flags, METH_O, 0}, + {"_events_to_str", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_11_events_to_str, METH_O, 0}, + {"set_syserr_cb", (PyCFunction)__pyx_pw_6gevent_5libev_8corecext_21set_syserr_cb, METH_O, 0}, + {0, 0, 0, 0} +}; + +#if PY_MAJOR_VERSION >= 3 +static struct PyModuleDef __pyx_moduledef = { + #if PY_VERSION_HEX < 0x03020000 + { PyObject_HEAD_INIT(NULL) NULL, 0, NULL }, + #else + PyModuleDef_HEAD_INIT, + #endif + "corecext", + 0, /* m_doc */ + -1, /* m_size */ + __pyx_methods /* m_methods */, + NULL, /* m_reload */ + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ +}; +#endif + +static __Pyx_StringTabEntry __pyx_string_tab[] = { + {&__pyx_kp_s_, __pyx_k_, sizeof(__pyx_k_), 0, 0, 1, 0}, + {&__pyx_n_s_ASYNC, __pyx_k_ASYNC, sizeof(__pyx_k_ASYNC), 0, 0, 1, 1}, + {&__pyx_n_s_AttributeError, __pyx_k_AttributeError, sizeof(__pyx_k_AttributeError), 0, 0, 1, 1}, + {&__pyx_n_s_BACKEND_EPOLL, __pyx_k_BACKEND_EPOLL, sizeof(__pyx_k_BACKEND_EPOLL), 0, 0, 1, 1}, + {&__pyx_n_s_BACKEND_KQUEUE, __pyx_k_BACKEND_KQUEUE, sizeof(__pyx_k_BACKEND_KQUEUE), 0, 0, 1, 1}, + {&__pyx_n_s_BACKEND_POLL, __pyx_k_BACKEND_POLL, sizeof(__pyx_k_BACKEND_POLL), 0, 0, 1, 1}, + {&__pyx_n_s_BACKEND_PORT, __pyx_k_BACKEND_PORT, sizeof(__pyx_k_BACKEND_PORT), 0, 0, 1, 1}, + {&__pyx_n_s_BACKEND_SELECT, __pyx_k_BACKEND_SELECT, sizeof(__pyx_k_BACKEND_SELECT), 0, 0, 1, 1}, + {&__pyx_n_s_CHECK, __pyx_k_CHECK, sizeof(__pyx_k_CHECK), 0, 0, 1, 1}, + {&__pyx_n_s_CHILD, __pyx_k_CHILD, sizeof(__pyx_k_CHILD), 0, 0, 1, 1}, + {&__pyx_n_s_CLEANUP, __pyx_k_CLEANUP, sizeof(__pyx_k_CLEANUP), 0, 0, 1, 1}, + {&__pyx_n_s_CUSTOM, __pyx_k_CUSTOM, sizeof(__pyx_k_CUSTOM), 0, 0, 1, 1}, + {&__pyx_kp_s_C_Users_appveyor_AppData_Local_T, __pyx_k_C_Users_appveyor_AppData_Local_T, sizeof(__pyx_k_C_Users_appveyor_AppData_Local_T), 0, 0, 1, 0}, + {&__pyx_kp_s_Cannot_set_priority_of_an_active, __pyx_k_Cannot_set_priority_of_an_active, sizeof(__pyx_k_Cannot_set_priority_of_an_active), 0, 0, 1, 0}, + {&__pyx_n_s_EMBED, __pyx_k_EMBED, sizeof(__pyx_k_EMBED), 0, 0, 1, 1}, + {&__pyx_n_s_ERROR, __pyx_k_ERROR, sizeof(__pyx_k_ERROR), 0, 0, 1, 1}, + {&__pyx_n_s_EVENTS, __pyx_k_EVENTS, sizeof(__pyx_k_EVENTS), 0, 0, 1, 1}, +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + {&__pyx_n_s_EV_USE_4HEAP, __pyx_k_EV_USE_4HEAP, sizeof(__pyx_k_EV_USE_4HEAP), 0, 0, 1, 1}, + {&__pyx_n_s_EV_USE_CLOCK_SYSCALL, __pyx_k_EV_USE_CLOCK_SYSCALL, sizeof(__pyx_k_EV_USE_CLOCK_SYSCALL), 0, 0, 1, 1}, + {&__pyx_n_s_EV_USE_EVENTFD, __pyx_k_EV_USE_EVENTFD, sizeof(__pyx_k_EV_USE_EVENTFD), 0, 0, 1, 1}, + {&__pyx_n_s_EV_USE_FLOOR, __pyx_k_EV_USE_FLOOR, sizeof(__pyx_k_EV_USE_FLOOR), 0, 0, 1, 1}, + {&__pyx_n_s_EV_USE_INOTIFY, __pyx_k_EV_USE_INOTIFY, sizeof(__pyx_k_EV_USE_INOTIFY), 0, 0, 1, 1}, + {&__pyx_n_s_EV_USE_MONOTONIC, __pyx_k_EV_USE_MONOTONIC, sizeof(__pyx_k_EV_USE_MONOTONIC), 0, 0, 1, 1}, + {&__pyx_n_s_EV_USE_NANOSLEEP, __pyx_k_EV_USE_NANOSLEEP, sizeof(__pyx_k_EV_USE_NANOSLEEP), 0, 0, 1, 1}, + {&__pyx_n_s_EV_USE_REALTIME, __pyx_k_EV_USE_REALTIME, sizeof(__pyx_k_EV_USE_REALTIME), 0, 0, 1, 1}, + {&__pyx_n_s_EV_USE_SIGNALFD, __pyx_k_EV_USE_SIGNALFD, sizeof(__pyx_k_EV_USE_SIGNALFD), 0, 0, 1, 1}, +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + {&__pyx_kp_s_Expected_callable_not_r, __pyx_k_Expected_callable_not_r, sizeof(__pyx_k_Expected_callable_not_r), 0, 0, 1, 0}, + {&__pyx_kp_s_Expected_callable_or_None_got_r, __pyx_k_Expected_callable_or_None_got_r, sizeof(__pyx_k_Expected_callable_or_None_got_r), 0, 0, 1, 0}, + {&__pyx_n_s_FORK, __pyx_k_FORK, sizeof(__pyx_k_FORK), 0, 0, 1, 1}, + {&__pyx_n_s_FORKCHECK, __pyx_k_FORKCHECK, sizeof(__pyx_k_FORKCHECK), 0, 0, 1, 1}, + {&__pyx_n_s_IDLE, __pyx_k_IDLE, sizeof(__pyx_k_IDLE), 0, 0, 1, 1}, + {&__pyx_n_s_IOFDSET, __pyx_k_IOFDSET, sizeof(__pyx_k_IOFDSET), 0, 0, 1, 1}, + {&__pyx_kp_s_Invalid_backend_or_flag_s_Possib, __pyx_k_Invalid_backend_or_flag_s_Possib, sizeof(__pyx_k_Invalid_backend_or_flag_s_Possib), 0, 0, 1, 0}, + {&__pyx_kp_s_Invalid_value_for_backend_0x_x, __pyx_k_Invalid_value_for_backend_0x_x, sizeof(__pyx_k_Invalid_value_for_backend_0x_x), 0, 0, 1, 0}, + {&__pyx_n_s_KeyError, __pyx_k_KeyError, sizeof(__pyx_k_KeyError), 0, 0, 1, 1}, + {&__pyx_n_s_LIBEV_EMBED, __pyx_k_LIBEV_EMBED, sizeof(__pyx_k_LIBEV_EMBED), 0, 0, 1, 1}, + {&__pyx_n_s_MAXPRI, __pyx_k_MAXPRI, sizeof(__pyx_k_MAXPRI), 0, 0, 1, 1}, + {&__pyx_n_s_MINPRI, __pyx_k_MINPRI, sizeof(__pyx_k_MINPRI), 0, 0, 1, 1}, + {&__pyx_n_s_NOINOTIFY, __pyx_k_NOINOTIFY, sizeof(__pyx_k_NOINOTIFY), 0, 0, 1, 1}, + {&__pyx_n_s_NONE, __pyx_k_NONE, sizeof(__pyx_k_NONE), 0, 0, 1, 1}, + {&__pyx_n_s_NOSIGMASK, __pyx_k_NOSIGMASK, sizeof(__pyx_k_NOSIGMASK), 0, 0, 1, 1}, + {&__pyx_n_s_NSIG, __pyx_k_NSIG, sizeof(__pyx_k_NSIG), 0, 0, 1, 1}, + {&__pyx_n_s_PERIODIC, __pyx_k_PERIODIC, sizeof(__pyx_k_PERIODIC), 0, 0, 1, 1}, + {&__pyx_n_s_PREPARE, __pyx_k_PREPARE, sizeof(__pyx_k_PREPARE), 0, 0, 1, 1}, + {&__pyx_n_s_READ, __pyx_k_READ, sizeof(__pyx_k_READ), 0, 0, 1, 1}, + {&__pyx_n_s_READWRITE, __pyx_k_READWRITE, sizeof(__pyx_k_READWRITE), 0, 0, 1, 1}, + {&__pyx_n_s_SIGNAL, __pyx_k_SIGNAL, sizeof(__pyx_k_SIGNAL), 0, 0, 1, 1}, + {&__pyx_n_s_SIGNALFD, __pyx_k_SIGNALFD, sizeof(__pyx_k_SIGNALFD), 0, 0, 1, 1}, + {&__pyx_n_s_STAT, __pyx_k_STAT, sizeof(__pyx_k_STAT), 0, 0, 1, 1}, + {&__pyx_n_s_SYSERR_CALLBACK, __pyx_k_SYSERR_CALLBACK, sizeof(__pyx_k_SYSERR_CALLBACK), 0, 0, 1, 1}, + {&__pyx_n_s_SystemError, __pyx_k_SystemError, sizeof(__pyx_k_SystemError), 0, 0, 1, 1}, + {&__pyx_n_s_TIMER, __pyx_k_TIMER, sizeof(__pyx_k_TIMER), 0, 0, 1, 1}, + {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, + {&__pyx_n_s_UNDEF, __pyx_k_UNDEF, sizeof(__pyx_k_UNDEF), 0, 0, 1, 1}, + {&__pyx_kp_s_Unsupported_backend_s, __pyx_k_Unsupported_backend_s, sizeof(__pyx_k_Unsupported_backend_s), 0, 0, 1, 0}, + {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, + {&__pyx_n_s_WRITE, __pyx_k_WRITE, sizeof(__pyx_k_WRITE), 0, 0, 1, 1}, + {&__pyx_kp_s__21, __pyx_k__21, sizeof(__pyx_k__21), 0, 0, 1, 0}, +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + {&__pyx_kp_s__22, __pyx_k__22, sizeof(__pyx_k__22), 0, 0, 1, 0}, + {&__pyx_kp_s__23, __pyx_k__23, sizeof(__pyx_k__23), 0, 0, 1, 0}, +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + {&__pyx_kp_s__26, __pyx_k__26, sizeof(__pyx_k__26), 0, 0, 1, 0}, +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + {&__pyx_kp_s__27, __pyx_k__27, sizeof(__pyx_k__27), 0, 0, 1, 0}, +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + {&__pyx_kp_s__28, __pyx_k__28, sizeof(__pyx_k__28), 0, 0, 1, 0}, +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + {&__pyx_kp_s__3, __pyx_k__3, sizeof(__pyx_k__3), 0, 0, 1, 0}, + {&__pyx_kp_s__4, __pyx_k__4, sizeof(__pyx_k__4), 0, 0, 1, 0}, + {&__pyx_kp_s__5, __pyx_k__5, sizeof(__pyx_k__5), 0, 0, 1, 0}, + {&__pyx_n_s_active, __pyx_k_active, sizeof(__pyx_k_active), 0, 0, 1, 1}, + {&__pyx_kp_s_active_2, __pyx_k_active_2, sizeof(__pyx_k_active_2), 0, 0, 1, 0}, +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + {&__pyx_n_s_activecnt, __pyx_k_activecnt, sizeof(__pyx_k_activecnt), 0, 0, 1, 1}, +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + {&__pyx_n_s_after, __pyx_k_after, sizeof(__pyx_k_after), 0, 0, 1, 1}, + {&__pyx_n_s_all, __pyx_k_all, sizeof(__pyx_k_all), 0, 0, 1, 1}, + {&__pyx_n_s_args, __pyx_k_args, sizeof(__pyx_k_args), 0, 0, 1, 1}, + {&__pyx_kp_s_args_r, __pyx_k_args_r, sizeof(__pyx_k_args_r), 0, 0, 1, 0}, + {&__pyx_n_s_backend, __pyx_k_backend, sizeof(__pyx_k_backend), 0, 0, 1, 1}, + {&__pyx_n_s_basestring, __pyx_k_basestring, sizeof(__pyx_k_basestring), 0, 0, 1, 1}, + {&__pyx_n_s_builtins, __pyx_k_builtins, sizeof(__pyx_k_builtins), 0, 0, 1, 1}, + {&__pyx_n_s_callback, __pyx_k_callback, sizeof(__pyx_k_callback), 0, 0, 1, 1}, + {&__pyx_kp_s_callback_must_be_callable_not_No, __pyx_k_callback_must_be_callable_not_No, sizeof(__pyx_k_callback_must_be_callable_not_No), 0, 0, 1, 0}, + {&__pyx_kp_s_callback_r, __pyx_k_callback_r, sizeof(__pyx_k_callback_r), 0, 0, 1, 0}, +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + {&__pyx_kp_s_child_watchers_are_only_availabl, __pyx_k_child_watchers_are_only_availabl, sizeof(__pyx_k_child_watchers_are_only_availabl), 0, 0, 1, 0}, +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + {&__pyx_n_s_class, __pyx_k_class, sizeof(__pyx_k_class), 0, 0, 1, 1}, + {&__pyx_n_s_close, __pyx_k_close, sizeof(__pyx_k_close), 0, 0, 1, 1}, + {&__pyx_n_s_context, __pyx_k_context, sizeof(__pyx_k_context), 0, 0, 1, 1}, + {&__pyx_n_s_decode, __pyx_k_decode, sizeof(__pyx_k_decode), 0, 0, 1, 1}, + {&__pyx_n_s_default, __pyx_k_default, sizeof(__pyx_k_default), 0, 0, 1, 1}, + {&__pyx_kp_s_default_2, __pyx_k_default_2, sizeof(__pyx_k_default_2), 0, 0, 1, 0}, + {&__pyx_n_s_default_handle_error, __pyx_k_default_handle_error, sizeof(__pyx_k_default_handle_error), 0, 0, 1, 1}, + {&__pyx_n_s_destroyed, __pyx_k_destroyed, sizeof(__pyx_k_destroyed), 0, 0, 1, 1}, + {&__pyx_n_s_embeddable_backends, __pyx_k_embeddable_backends, sizeof(__pyx_k_embeddable_backends), 0, 0, 1, 1}, + {&__pyx_n_s_encode, __pyx_k_encode, sizeof(__pyx_k_encode), 0, 0, 1, 1}, + {&__pyx_n_s_epoll, __pyx_k_epoll, sizeof(__pyx_k_epoll), 0, 0, 1, 1}, + {&__pyx_n_s_errno, __pyx_k_errno, sizeof(__pyx_k_errno), 0, 0, 1, 1}, + {&__pyx_kp_s_ev_default_loop_s_failed, __pyx_k_ev_default_loop_s_failed, sizeof(__pyx_k_ev_default_loop_s_failed), 0, 0, 1, 0}, + {&__pyx_kp_s_ev_loop_new_s_failed, __pyx_k_ev_loop_new_s_failed, sizeof(__pyx_k_ev_loop_new_s_failed), 0, 0, 1, 0}, + {&__pyx_n_s_events, __pyx_k_events, sizeof(__pyx_k_events), 0, 0, 1, 1}, + {&__pyx_n_s_events_2, __pyx_k_events_2, sizeof(__pyx_k_events_2), 0, 0, 1, 1}, + {&__pyx_n_s_events_str, __pyx_k_events_str, sizeof(__pyx_k_events_str), 0, 0, 1, 1}, + {&__pyx_n_s_fd, __pyx_k_fd, sizeof(__pyx_k_fd), 0, 0, 1, 1}, +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + {&__pyx_kp_s_fd_must_be_non_negative_r, __pyx_k_fd_must_be_non_negative_r, sizeof(__pyx_k_fd_must_be_non_negative_r), 0, 0, 1, 0}, +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + {&__pyx_kp_s_fd_s_events_s, __pyx_k_fd_s_events_s, sizeof(__pyx_k_fd_s_events_s), 0, 0, 1, 0}, +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + {&__pyx_n_s_fileno, __pyx_k_fileno, sizeof(__pyx_k_fileno), 0, 0, 1, 1}, + {&__pyx_kp_s_fileno_2, __pyx_k_fileno_2, sizeof(__pyx_k_fileno_2), 0, 0, 1, 0}, +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + {&__pyx_n_s_flags, __pyx_k_flags, sizeof(__pyx_k_flags), 0, 0, 1, 1}, + {&__pyx_n_s_flags_2, __pyx_k_flags_2, sizeof(__pyx_k_flags_2), 0, 0, 1, 1}, + {&__pyx_n_s_flags_str2int, __pyx_k_flags_str2int, sizeof(__pyx_k_flags_str2int), 0, 0, 1, 1}, + {&__pyx_n_s_forkcheck, __pyx_k_forkcheck, sizeof(__pyx_k_forkcheck), 0, 0, 1, 1}, + {&__pyx_n_s_format, __pyx_k_format, sizeof(__pyx_k_format), 0, 0, 1, 1}, +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + {&__pyx_n_s_format_details, __pyx_k_format_details, sizeof(__pyx_k_format_details), 0, 0, 1, 1}, +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + {&__pyx_n_s_func, __pyx_k_func, sizeof(__pyx_k_func), 0, 0, 1, 1}, + {&__pyx_n_s_genexpr, __pyx_k_genexpr, sizeof(__pyx_k_genexpr), 0, 0, 1, 1}, + {&__pyx_n_s_get_header_version, __pyx_k_get_header_version, sizeof(__pyx_k_get_header_version), 0, 0, 1, 1}, + {&__pyx_n_s_get_version, __pyx_k_get_version, sizeof(__pyx_k_get_version), 0, 0, 1, 1}, + {&__pyx_n_s_getfilesystemencoding, __pyx_k_getfilesystemencoding, sizeof(__pyx_k_getfilesystemencoding), 0, 0, 1, 1}, + {&__pyx_kp_s_gevent_core_EVENTS, __pyx_k_gevent_core_EVENTS, sizeof(__pyx_k_gevent_core_EVENTS), 0, 0, 1, 0}, + {&__pyx_n_s_gevent_libev_corecext, __pyx_k_gevent_libev_corecext, sizeof(__pyx_k_gevent_libev_corecext), 0, 0, 1, 1}, + {&__pyx_n_s_handle_error, __pyx_k_handle_error, sizeof(__pyx_k_handle_error), 0, 0, 1, 1}, + {&__pyx_n_s_handle_syserr, __pyx_k_handle_syserr, sizeof(__pyx_k_handle_syserr), 0, 0, 1, 1}, + {&__pyx_n_s_hex, __pyx_k_hex, sizeof(__pyx_k_hex), 0, 0, 1, 1}, + {&__pyx_n_s_how, __pyx_k_how, sizeof(__pyx_k_how), 0, 0, 1, 1}, + {&__pyx_n_s_id, __pyx_k_id, sizeof(__pyx_k_id), 0, 0, 1, 1}, + {&__pyx_kp_s_illegal_event_mask_r, __pyx_k_illegal_event_mask_r, sizeof(__pyx_k_illegal_event_mask_r), 0, 0, 1, 0}, + {&__pyx_kp_s_illegal_signal_number_r, __pyx_k_illegal_signal_number_r, sizeof(__pyx_k_illegal_signal_number_r), 0, 0, 1, 0}, + {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, + {&__pyx_n_s_interval, __pyx_k_interval, sizeof(__pyx_k_interval), 0, 0, 1, 1}, + {&__pyx_kp_s_io_watcher_attribute_events_is, __pyx_k_io_watcher_attribute_events_is, sizeof(__pyx_k_io_watcher_attribute_events_is), 0, 0, 1, 0}, + {&__pyx_kp_s_io_watcher_attribute_fd_is_read, __pyx_k_io_watcher_attribute_fd_is_read, sizeof(__pyx_k_io_watcher_attribute_fd_is_read), 0, 0, 1, 0}, + {&__pyx_n_s_join, __pyx_k_join, sizeof(__pyx_k_join), 0, 0, 1, 1}, + {&__pyx_n_s_keys, __pyx_k_keys, sizeof(__pyx_k_keys), 0, 0, 1, 1}, + {&__pyx_n_s_kqueue, __pyx_k_kqueue, sizeof(__pyx_k_kqueue), 0, 0, 1, 1}, + {&__pyx_n_s_level, __pyx_k_level, sizeof(__pyx_k_level), 0, 0, 1, 1}, + {&__pyx_kp_s_libev_d_02d, __pyx_k_libev_d_02d, sizeof(__pyx_k_libev_d_02d), 0, 0, 1, 0}, + {&__pyx_n_s_loop, __pyx_k_loop, sizeof(__pyx_k_loop), 0, 0, 1, 1}, + {&__pyx_n_s_lower, __pyx_k_lower, sizeof(__pyx_k_lower), 0, 0, 1, 1}, + {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, + {&__pyx_n_s_message, __pyx_k_message, sizeof(__pyx_k_message), 0, 0, 1, 1}, + {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, + {&__pyx_n_s_noenv, __pyx_k_noenv, sizeof(__pyx_k_noenv), 0, 0, 1, 1}, + {&__pyx_n_s_noinotify, __pyx_k_noinotify, sizeof(__pyx_k_noinotify), 0, 0, 1, 1}, + {&__pyx_n_s_nosigmask, __pyx_k_nosigmask, sizeof(__pyx_k_nosigmask), 0, 0, 1, 1}, + {&__pyx_n_s_nowait, __pyx_k_nowait, sizeof(__pyx_k_nowait), 0, 0, 1, 1}, + {&__pyx_n_s_once, __pyx_k_once, sizeof(__pyx_k_once), 0, 0, 1, 1}, + {&__pyx_kp_s_operation_on_destroyed_loop, __pyx_k_operation_on_destroyed_loop, sizeof(__pyx_k_operation_on_destroyed_loop), 0, 0, 1, 0}, + {&__pyx_n_s_os, __pyx_k_os, sizeof(__pyx_k_os), 0, 0, 1, 1}, + {&__pyx_n_s_pass_events, __pyx_k_pass_events, sizeof(__pyx_k_pass_events), 0, 0, 1, 1}, + {&__pyx_n_s_path, __pyx_k_path, sizeof(__pyx_k_path), 0, 0, 1, 1}, + {&__pyx_n_s_pending, __pyx_k_pending, sizeof(__pyx_k_pending), 0, 0, 1, 1}, + {&__pyx_kp_s_pending_2, __pyx_k_pending_2, sizeof(__pyx_k_pending_2), 0, 0, 1, 0}, + {&__pyx_kp_s_pending_s, __pyx_k_pending_s, sizeof(__pyx_k_pending_s), 0, 0, 1, 0}, + {&__pyx_n_s_pendingcnt, __pyx_k_pendingcnt, sizeof(__pyx_k_pendingcnt), 0, 0, 1, 1}, +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + {&__pyx_n_s_pid, __pyx_k_pid, sizeof(__pyx_k_pid), 0, 0, 1, 1}, + {&__pyx_kp_s_pid_r_rstatus_r, __pyx_k_pid_r_rstatus_r, sizeof(__pyx_k_pid_r_rstatus_r), 0, 0, 1, 0}, +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + {&__pyx_n_s_poll, __pyx_k_poll, sizeof(__pyx_k_poll), 0, 0, 1, 1}, + {&__pyx_n_s_port, __pyx_k_port, sizeof(__pyx_k_port), 0, 0, 1, 1}, + {&__pyx_n_s_print_exc, __pyx_k_print_exc, sizeof(__pyx_k_print_exc), 0, 0, 1, 1}, + {&__pyx_n_s_print_exception, __pyx_k_print_exception, sizeof(__pyx_k_print_exception), 0, 0, 1, 1}, + {&__pyx_n_s_priority, __pyx_k_priority, sizeof(__pyx_k_priority), 0, 0, 1, 1}, + {&__pyx_n_s_ptr, __pyx_k_ptr, sizeof(__pyx_k_ptr), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_vtable, __pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 0, 1, 1}, + {&__pyx_n_s_recommended_backends, __pyx_k_recommended_backends, sizeof(__pyx_k_recommended_backends), 0, 0, 1, 1}, + {&__pyx_n_s_ref, __pyx_k_ref, sizeof(__pyx_k_ref), 0, 0, 1, 1}, +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + {&__pyx_kp_s_ref_2, __pyx_k_ref_2, sizeof(__pyx_k_ref_2), 0, 0, 1, 0}, +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + {&__pyx_n_s_repeat, __pyx_k_repeat, sizeof(__pyx_k_repeat), 0, 0, 1, 1}, + {&__pyx_kp_s_repeat_must_be_positive_or_zero, __pyx_k_repeat_must_be_positive_or_zero, sizeof(__pyx_k_repeat_must_be_positive_or_zero), 0, 0, 1, 0}, + {&__pyx_n_s_revents, __pyx_k_revents, sizeof(__pyx_k_revents), 0, 0, 1, 1}, +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + {&__pyx_n_s_rstatus, __pyx_k_rstatus, sizeof(__pyx_k_rstatus), 0, 0, 1, 1}, +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + {&__pyx_kp_s_s_at_0x_x_s, __pyx_k_s_at_0x_x_s, sizeof(__pyx_k_s_at_0x_x_s), 0, 0, 1, 0}, + {&__pyx_kp_s_s_at_0x_x_s_2, __pyx_k_s_at_0x_x_s_2, sizeof(__pyx_k_s_at_0x_x_s_2), 0, 0, 1, 0}, + {&__pyx_n_s_select, __pyx_k_select, sizeof(__pyx_k_select), 0, 0, 1, 1}, + {&__pyx_n_s_send, __pyx_k_send, sizeof(__pyx_k_send), 0, 0, 1, 1}, +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + {&__pyx_n_s_sigfd, __pyx_k_sigfd, sizeof(__pyx_k_sigfd), 0, 0, 1, 1}, + {&__pyx_kp_s_sigfd_2, __pyx_k_sigfd_2, sizeof(__pyx_k_sigfd_2), 0, 0, 1, 0}, +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + {&__pyx_n_s_signal, __pyx_k_signal, sizeof(__pyx_k_signal), 0, 0, 1, 1}, + {&__pyx_n_s_signalfd, __pyx_k_signalfd, sizeof(__pyx_k_signalfd), 0, 0, 1, 1}, + {&__pyx_n_s_signalmodule, __pyx_k_signalmodule, sizeof(__pyx_k_signalmodule), 0, 0, 1, 1}, + {&__pyx_n_s_signalnum, __pyx_k_signalnum, sizeof(__pyx_k_signalnum), 0, 0, 1, 1}, + {&__pyx_n_s_signum, __pyx_k_signum, sizeof(__pyx_k_signum), 0, 0, 1, 1}, + {&__pyx_n_s_split, __pyx_k_split, sizeof(__pyx_k_split), 0, 0, 1, 1}, + {&__pyx_n_s_stop_watchers, __pyx_k_stop_watchers, sizeof(__pyx_k_stop_watchers), 0, 0, 1, 1}, + {&__pyx_kp_s_stopped, __pyx_k_stopped, sizeof(__pyx_k_stopped), 0, 0, 1, 0}, + {&__pyx_n_s_strerror, __pyx_k_strerror, sizeof(__pyx_k_strerror), 0, 0, 1, 1}, + {&__pyx_n_s_strip, __pyx_k_strip, sizeof(__pyx_k_strip), 0, 0, 1, 1}, + {&__pyx_n_s_supported_backends, __pyx_k_supported_backends, sizeof(__pyx_k_supported_backends), 0, 0, 1, 1}, + {&__pyx_n_s_sys, __pyx_k_sys, sizeof(__pyx_k_sys), 0, 0, 1, 1}, + {&__pyx_n_s_tb, __pyx_k_tb, sizeof(__pyx_k_tb), 0, 0, 1, 1}, + {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, + {&__pyx_n_s_throw, __pyx_k_throw, sizeof(__pyx_k_throw), 0, 0, 1, 1}, + {&__pyx_n_s_time, __pyx_k_time, sizeof(__pyx_k_time), 0, 0, 1, 1}, +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + {&__pyx_n_s_trace, __pyx_k_trace, sizeof(__pyx_k_trace), 0, 0, 1, 1}, +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + {&__pyx_n_s_traceback, __pyx_k_traceback, sizeof(__pyx_k_traceback), 0, 0, 1, 1}, + {&__pyx_n_s_type, __pyx_k_type, sizeof(__pyx_k_type), 0, 0, 1, 1}, + {&__pyx_n_s_update, __pyx_k_update, sizeof(__pyx_k_update), 0, 0, 1, 1}, + {&__pyx_n_s_value, __pyx_k_value, sizeof(__pyx_k_value), 0, 0, 1, 1}, + {&__pyx_n_s_version_info, __pyx_k_version_info, sizeof(__pyx_k_version_info), 0, 0, 1, 1}, + {0, 0, 0, 0, 0, 0, 0} +}; +static int __Pyx_InitCachedBuiltins(void) { + __pyx_builtin___import__ = __Pyx_GetBuiltinName(__pyx_n_s_import); if (!__pyx_builtin___import__) __PYX_ERR(0, 16, __pyx_L1_error) + __pyx_builtin_KeyError = __Pyx_GetBuiltinName(__pyx_n_s_KeyError); if (!__pyx_builtin_KeyError) __PYX_ERR(0, 182, __pyx_L1_error) + __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(0, 183, __pyx_L1_error) + __pyx_builtin_hex = __Pyx_GetBuiltinName(__pyx_n_s_hex); if (!__pyx_builtin_hex) __PYX_ERR(0, 189, __pyx_L1_error) + __pyx_builtin_SystemError = __Pyx_GetBuiltinName(__pyx_n_s_SystemError); if (!__pyx_builtin_SystemError) __PYX_ERR(0, 278, __pyx_L1_error) + __pyx_builtin_id = __Pyx_GetBuiltinName(__pyx_n_s_id); if (!__pyx_builtin_id) __PYX_ERR(0, 431, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_builtin_AttributeError = __Pyx_GetBuiltinName(__pyx_n_s_AttributeError); if (!__pyx_builtin_AttributeError) __PYX_ERR(0, 561, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(0, 759, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_builtin_AttributeError = __Pyx_GetBuiltinName(__pyx_n_s_AttributeError); if (!__pyx_builtin_AttributeError) __PYX_ERR(0, 783, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + return 0; + __pyx_L1_error:; + return -1; +} + +static int __Pyx_InitCachedConstants(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); + + __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_s_); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__2); + __Pyx_GIVEREF(__pyx_tuple__2); + + __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 381, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__6); + __Pyx_GIVEREF(__pyx_tuple__6); + + __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(0, 397, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__7); + __Pyx_GIVEREF(__pyx_tuple__7); + + __pyx_tuple__8 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(0, 403, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__8); + __Pyx_GIVEREF(__pyx_tuple__8); + + __pyx_tuple__10 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(0, 409, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__10); + __Pyx_GIVEREF(__pyx_tuple__10); + + __pyx_tuple__11 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(0, 415, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__11); + __Pyx_GIVEREF(__pyx_tuple__11); + + __pyx_tuple__12 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(0, 421, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__12); + __Pyx_GIVEREF(__pyx_tuple__12); + + __pyx_tuple__13 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(0, 427, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__13); + __Pyx_GIVEREF(__pyx_tuple__13); + + __pyx_tuple__14 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(0, 438, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__14); + __Pyx_GIVEREF(__pyx_tuple__14); + + __pyx_tuple__15 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(0, 446, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__15); + __Pyx_GIVEREF(__pyx_tuple__15); + + __pyx_tuple__16 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(0, 454, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__16); + __Pyx_GIVEREF(__pyx_tuple__16); + + __pyx_tuple__17 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(0, 462, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__17); + __Pyx_GIVEREF(__pyx_tuple__17); + + __pyx_tuple__18 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__18)) __PYX_ERR(0, 470, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__18); + __Pyx_GIVEREF(__pyx_tuple__18); + + __pyx_tuple__19 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__19)) __PYX_ERR(0, 482, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__19); + __Pyx_GIVEREF(__pyx_tuple__19); + + __pyx_tuple__20 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__20)) __PYX_ERR(0, 534, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__20); + __Pyx_GIVEREF(__pyx_tuple__20); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__24 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__24)) __PYX_ERR(0, 737, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__22 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(0, 587, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__22); + __Pyx_GIVEREF(__pyx_tuple__22); + + __pyx_tuple__23 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__23)) __PYX_ERR(0, 595, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__23); + __Pyx_GIVEREF(__pyx_tuple__23); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__24 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__24)) __PYX_ERR(0, 604, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__24 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__24)) __PYX_ERR(0, 613, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__24); + __Pyx_GIVEREF(__pyx_tuple__24); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__25 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__25)) __PYX_ERR(0, 613, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__25 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__25)) __PYX_ERR(0, 765, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__25 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__25)) __PYX_ERR(0, 621, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__25); + __Pyx_GIVEREF(__pyx_tuple__25); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__26 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__26)) __PYX_ERR(0, 621, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__26 = PyTuple_Pack(1, __pyx_kp_s_Cannot_set_priority_of_an_active); if (unlikely(!__pyx_tuple__26)) __PYX_ERR(0, 783, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__26); + __Pyx_GIVEREF(__pyx_tuple__26); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__29 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__29)) __PYX_ERR(0, 737, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__27 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__27)) __PYX_ERR(0, 789, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__27); + __Pyx_GIVEREF(__pyx_tuple__27); + + __pyx_tuple__28 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__28)) __PYX_ERR(0, 803, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__28 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__28)) __PYX_ERR(0, 737, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__28); + __Pyx_GIVEREF(__pyx_tuple__28); + +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__29 = PyTuple_Pack(1, __pyx_kp_s_callback_must_be_callable_not_No); if (unlikely(!__pyx_tuple__29)) __PYX_ERR(0, 805, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__29 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__29)) __PYX_ERR(0, 765, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__29); + __Pyx_GIVEREF(__pyx_tuple__29); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__30 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__30)) __PYX_ERR(0, 765, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__30 = PyTuple_Pack(1, __pyx_kp_s_io_watcher_attribute_fd_is_read); if (unlikely(!__pyx_tuple__30)) __PYX_ERR(0, 871, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__30 = PyTuple_Pack(1, __pyx_kp_s_Cannot_set_priority_of_an_active); if (unlikely(!__pyx_tuple__30)) __PYX_ERR(0, 783, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__30); + __Pyx_GIVEREF(__pyx_tuple__30); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__31 = PyTuple_Pack(1, __pyx_kp_s_Cannot_set_priority_of_an_active); if (unlikely(!__pyx_tuple__31)) __PYX_ERR(0, 783, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__31 = PyTuple_Pack(1, __pyx_kp_s_io_watcher_attribute_events_is); if (unlikely(!__pyx_tuple__31)) __PYX_ERR(0, 883, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__31 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__31)) __PYX_ERR(0, 789, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__31); + __Pyx_GIVEREF(__pyx_tuple__31); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__32 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__32)) __PYX_ERR(0, 789, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__32 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__32)) __PYX_ERR(0, 922, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__32 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__32)) __PYX_ERR(0, 803, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__32); + __Pyx_GIVEREF(__pyx_tuple__32); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__33 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__33)) __PYX_ERR(0, 803, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__33 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__33)) __PYX_ERR(0, 950, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__33 = PyTuple_Pack(1, __pyx_kp_s_callback_must_be_callable_not_No); if (unlikely(!__pyx_tuple__33)) __PYX_ERR(0, 805, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__33); + __Pyx_GIVEREF(__pyx_tuple__33); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__34 = PyTuple_Pack(1, __pyx_kp_s_callback_must_be_callable_not_No); if (unlikely(!__pyx_tuple__34)) __PYX_ERR(0, 805, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__34 = PyTuple_Pack(1, __pyx_kp_s_Cannot_set_priority_of_an_active); if (unlikely(!__pyx_tuple__34)) __PYX_ERR(0, 968, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__34 = PyTuple_Pack(1, __pyx_kp_s_io_watcher_attribute_fd_is_read); if (unlikely(!__pyx_tuple__34)) __PYX_ERR(0, 871, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__34); + __Pyx_GIVEREF(__pyx_tuple__34); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__35 = PyTuple_Pack(1, __pyx_kp_s_io_watcher_attribute_fd_is_read); if (unlikely(!__pyx_tuple__35)) __PYX_ERR(0, 871, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__35 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__35)) __PYX_ERR(0, 974, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__35 = PyTuple_Pack(1, __pyx_kp_s_io_watcher_attribute_events_is); if (unlikely(!__pyx_tuple__35)) __PYX_ERR(0, 883, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__35); + __Pyx_GIVEREF(__pyx_tuple__35); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__36 = PyTuple_Pack(1, __pyx_kp_s_io_watcher_attribute_events_is); if (unlikely(!__pyx_tuple__36)) __PYX_ERR(0, 883, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__36 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__36)) __PYX_ERR(0, 988, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__36 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__36)) __PYX_ERR(0, 922, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__36); + __Pyx_GIVEREF(__pyx_tuple__36); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__37 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__37)) __PYX_ERR(0, 922, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__37 = PyTuple_Pack(1, __pyx_kp_s_callback_must_be_callable_not_No); if (unlikely(!__pyx_tuple__37)) __PYX_ERR(0, 990, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__37 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__37)) __PYX_ERR(0, 950, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__37); + __Pyx_GIVEREF(__pyx_tuple__37); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__38 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__38)) __PYX_ERR(0, 950, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__38 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__38)) __PYX_ERR(0, 1036, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__38 = PyTuple_Pack(1, __pyx_kp_s_Cannot_set_priority_of_an_active); if (unlikely(!__pyx_tuple__38)) __PYX_ERR(0, 968, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__38); + __Pyx_GIVEREF(__pyx_tuple__38); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__39 = PyTuple_Pack(1, __pyx_kp_s_Cannot_set_priority_of_an_active); if (unlikely(!__pyx_tuple__39)) __PYX_ERR(0, 968, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__39 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__39)) __PYX_ERR(0, 1067, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__39 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__39)) __PYX_ERR(0, 974, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__39); + __Pyx_GIVEREF(__pyx_tuple__39); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__40 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__40)) __PYX_ERR(0, 974, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__40 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__40)) __PYX_ERR(0, 1095, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__40 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__40)) __PYX_ERR(0, 988, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__40); + __Pyx_GIVEREF(__pyx_tuple__40); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__41 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__41)) __PYX_ERR(0, 988, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__41 = PyTuple_Pack(1, __pyx_kp_s_Cannot_set_priority_of_an_active); if (unlikely(!__pyx_tuple__41)) __PYX_ERR(0, 1113, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__41 = PyTuple_Pack(1, __pyx_kp_s_callback_must_be_callable_not_No); if (unlikely(!__pyx_tuple__41)) __PYX_ERR(0, 990, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__41); + __Pyx_GIVEREF(__pyx_tuple__41); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__42 = PyTuple_Pack(1, __pyx_kp_s_callback_must_be_callable_not_No); if (unlikely(!__pyx_tuple__42)) __PYX_ERR(0, 990, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__42 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__42)) __PYX_ERR(0, 1119, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__42 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__42)) __PYX_ERR(0, 1036, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__42); + __Pyx_GIVEREF(__pyx_tuple__42); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__43 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__43)) __PYX_ERR(0, 1036, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__43 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__43)) __PYX_ERR(0, 1133, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__43 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__43)) __PYX_ERR(0, 1067, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__43); + __Pyx_GIVEREF(__pyx_tuple__43); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__44 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__44)) __PYX_ERR(0, 1067, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__44 = PyTuple_Pack(1, __pyx_kp_s_callback_must_be_callable_not_No); if (unlikely(!__pyx_tuple__44)) __PYX_ERR(0, 1135, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__44 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__44)) __PYX_ERR(0, 1095, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__44); + __Pyx_GIVEREF(__pyx_tuple__44); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__45 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__45)) __PYX_ERR(0, 1095, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__45 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__45)) __PYX_ERR(0, 1192, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__45 = PyTuple_Pack(1, __pyx_kp_s_Cannot_set_priority_of_an_active); if (unlikely(!__pyx_tuple__45)) __PYX_ERR(0, 1113, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__45); + __Pyx_GIVEREF(__pyx_tuple__45); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__46 = PyTuple_Pack(1, __pyx_kp_s_Cannot_set_priority_of_an_active); if (unlikely(!__pyx_tuple__46)) __PYX_ERR(0, 1113, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__46 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__46)) __PYX_ERR(0, 1220, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__46 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__46)) __PYX_ERR(0, 1119, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__46); + __Pyx_GIVEREF(__pyx_tuple__46); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__47 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__47)) __PYX_ERR(0, 1119, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__47 = PyTuple_Pack(1, __pyx_kp_s_Cannot_set_priority_of_an_active); if (unlikely(!__pyx_tuple__47)) __PYX_ERR(0, 1238, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__47 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__47)) __PYX_ERR(0, 1133, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__47); + __Pyx_GIVEREF(__pyx_tuple__47); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__48 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__48)) __PYX_ERR(0, 1133, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__48 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__48)) __PYX_ERR(0, 1244, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__48 = PyTuple_Pack(1, __pyx_kp_s_callback_must_be_callable_not_No); if (unlikely(!__pyx_tuple__48)) __PYX_ERR(0, 1135, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__48); + __Pyx_GIVEREF(__pyx_tuple__48); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__49 = PyTuple_Pack(1, __pyx_kp_s_callback_must_be_callable_not_No); if (unlikely(!__pyx_tuple__49)) __PYX_ERR(0, 1135, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__49 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__49)) __PYX_ERR(0, 1258, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__49 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__49)) __PYX_ERR(0, 1192, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__49); + __Pyx_GIVEREF(__pyx_tuple__49); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__50 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__50)) __PYX_ERR(0, 1192, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__50 = PyTuple_Pack(1, __pyx_kp_s_callback_must_be_callable_not_No); if (unlikely(!__pyx_tuple__50)) __PYX_ERR(0, 1260, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__50 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__50)) __PYX_ERR(0, 1220, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__50); + __Pyx_GIVEREF(__pyx_tuple__50); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__51 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__51)) __PYX_ERR(0, 1220, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__51 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__51)) __PYX_ERR(0, 1311, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__51 = PyTuple_Pack(1, __pyx_kp_s_Cannot_set_priority_of_an_active); if (unlikely(!__pyx_tuple__51)) __PYX_ERR(0, 1238, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__51); + __Pyx_GIVEREF(__pyx_tuple__51); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__52 = PyTuple_Pack(1, __pyx_kp_s_Cannot_set_priority_of_an_active); if (unlikely(!__pyx_tuple__52)) __PYX_ERR(0, 1238, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__52 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__52)) __PYX_ERR(0, 1339, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__52 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__52)) __PYX_ERR(0, 1244, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__52); + __Pyx_GIVEREF(__pyx_tuple__52); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__53 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__53)) __PYX_ERR(0, 1244, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__53 = PyTuple_Pack(1, __pyx_kp_s_Cannot_set_priority_of_an_active); if (unlikely(!__pyx_tuple__53)) __PYX_ERR(0, 1357, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__53 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__53)) __PYX_ERR(0, 1258, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__53); + __Pyx_GIVEREF(__pyx_tuple__53); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__54 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__54)) __PYX_ERR(0, 1258, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__54 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__54)) __PYX_ERR(0, 1363, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__54 = PyTuple_Pack(1, __pyx_kp_s_callback_must_be_callable_not_No); if (unlikely(!__pyx_tuple__54)) __PYX_ERR(0, 1260, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__54); + __Pyx_GIVEREF(__pyx_tuple__54); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__55 = PyTuple_Pack(1, __pyx_kp_s_callback_must_be_callable_not_No); if (unlikely(!__pyx_tuple__55)) __PYX_ERR(0, 1260, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__55 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__55)) __PYX_ERR(0, 1377, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__55 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__55)) __PYX_ERR(0, 1311, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__55); + __Pyx_GIVEREF(__pyx_tuple__55); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__56 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__56)) __PYX_ERR(0, 1311, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__56 = PyTuple_Pack(1, __pyx_kp_s_callback_must_be_callable_not_No); if (unlikely(!__pyx_tuple__56)) __PYX_ERR(0, 1379, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__56 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__56)) __PYX_ERR(0, 1339, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__56); + __Pyx_GIVEREF(__pyx_tuple__56); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__57 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__57)) __PYX_ERR(0, 1339, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__57 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__57)) __PYX_ERR(0, 1430, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__57 = PyTuple_Pack(1, __pyx_kp_s_Cannot_set_priority_of_an_active); if (unlikely(!__pyx_tuple__57)) __PYX_ERR(0, 1357, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__57); + __Pyx_GIVEREF(__pyx_tuple__57); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__58 = PyTuple_Pack(1, __pyx_kp_s_Cannot_set_priority_of_an_active); if (unlikely(!__pyx_tuple__58)) __PYX_ERR(0, 1357, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__58 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__58)) __PYX_ERR(0, 1458, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__58 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__58)) __PYX_ERR(0, 1363, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__58); + __Pyx_GIVEREF(__pyx_tuple__58); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__59 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__59)) __PYX_ERR(0, 1363, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__59 = PyTuple_Pack(1, __pyx_kp_s_Cannot_set_priority_of_an_active); if (unlikely(!__pyx_tuple__59)) __PYX_ERR(0, 1476, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__59 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__59)) __PYX_ERR(0, 1377, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__59); + __Pyx_GIVEREF(__pyx_tuple__59); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__60 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__60)) __PYX_ERR(0, 1377, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__60 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__60)) __PYX_ERR(0, 1482, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__60 = PyTuple_Pack(1, __pyx_kp_s_callback_must_be_callable_not_No); if (unlikely(!__pyx_tuple__60)) __PYX_ERR(0, 1379, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__60); + __Pyx_GIVEREF(__pyx_tuple__60); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__61 = PyTuple_Pack(1, __pyx_kp_s_callback_must_be_callable_not_No); if (unlikely(!__pyx_tuple__61)) __PYX_ERR(0, 1379, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__61 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__61)) __PYX_ERR(0, 1496, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__61 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__61)) __PYX_ERR(0, 1430, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__61); + __Pyx_GIVEREF(__pyx_tuple__61); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__62 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__62)) __PYX_ERR(0, 1430, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__62 = PyTuple_Pack(1, __pyx_kp_s_callback_must_be_callable_not_No); if (unlikely(!__pyx_tuple__62)) __PYX_ERR(0, 1498, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__62 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__62)) __PYX_ERR(0, 1458, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__62); + __Pyx_GIVEREF(__pyx_tuple__62); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__63 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__63)) __PYX_ERR(0, 1458, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__63 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__63)) __PYX_ERR(0, 1549, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__63 = PyTuple_Pack(1, __pyx_kp_s_Cannot_set_priority_of_an_active); if (unlikely(!__pyx_tuple__63)) __PYX_ERR(0, 1476, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__63); + __Pyx_GIVEREF(__pyx_tuple__63); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__64 = PyTuple_Pack(1, __pyx_kp_s_Cannot_set_priority_of_an_active); if (unlikely(!__pyx_tuple__64)) __PYX_ERR(0, 1476, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__64 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__64)) __PYX_ERR(0, 1577, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__64 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__64)) __PYX_ERR(0, 1482, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__64); + __Pyx_GIVEREF(__pyx_tuple__64); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__65 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__65)) __PYX_ERR(0, 1482, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__65 = PyTuple_Pack(1, __pyx_kp_s_Cannot_set_priority_of_an_active); if (unlikely(!__pyx_tuple__65)) __PYX_ERR(0, 1595, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__65 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__65)) __PYX_ERR(0, 1496, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__65); + __Pyx_GIVEREF(__pyx_tuple__65); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__66 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__66)) __PYX_ERR(0, 1496, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__66 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__66)) __PYX_ERR(0, 1601, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__66 = PyTuple_Pack(1, __pyx_kp_s_callback_must_be_callable_not_No); if (unlikely(!__pyx_tuple__66)) __PYX_ERR(0, 1498, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__66); + __Pyx_GIVEREF(__pyx_tuple__66); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__67 = PyTuple_Pack(1, __pyx_kp_s_callback_must_be_callable_not_No); if (unlikely(!__pyx_tuple__67)) __PYX_ERR(0, 1498, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__67 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__67)) __PYX_ERR(0, 1615, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__67 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__67)) __PYX_ERR(0, 1549, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__67); + __Pyx_GIVEREF(__pyx_tuple__67); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__68 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__68)) __PYX_ERR(0, 1549, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__68 = PyTuple_Pack(1, __pyx_kp_s_callback_must_be_callable_not_No); if (unlikely(!__pyx_tuple__68)) __PYX_ERR(0, 1617, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__68 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__68)) __PYX_ERR(0, 1577, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__68); + __Pyx_GIVEREF(__pyx_tuple__68); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__69 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__69)) __PYX_ERR(0, 1577, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__69 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__69)) __PYX_ERR(0, 1668, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__69 = PyTuple_Pack(1, __pyx_kp_s_Cannot_set_priority_of_an_active); if (unlikely(!__pyx_tuple__69)) __PYX_ERR(0, 1595, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__69); + __Pyx_GIVEREF(__pyx_tuple__69); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__70 = PyTuple_Pack(1, __pyx_kp_s_Cannot_set_priority_of_an_active); if (unlikely(!__pyx_tuple__70)) __PYX_ERR(0, 1595, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__70 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__70)) __PYX_ERR(0, 1696, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__70 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__70)) __PYX_ERR(0, 1601, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__70); + __Pyx_GIVEREF(__pyx_tuple__70); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__71 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__71)) __PYX_ERR(0, 1601, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__71 = PyTuple_Pack(1, __pyx_kp_s_Cannot_set_priority_of_an_active); if (unlikely(!__pyx_tuple__71)) __PYX_ERR(0, 1714, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__71 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__71)) __PYX_ERR(0, 1615, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__71); + __Pyx_GIVEREF(__pyx_tuple__71); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__72 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__72)) __PYX_ERR(0, 1615, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__72 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__72)) __PYX_ERR(0, 1720, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__72 = PyTuple_Pack(1, __pyx_kp_s_callback_must_be_callable_not_No); if (unlikely(!__pyx_tuple__72)) __PYX_ERR(0, 1617, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__72); + __Pyx_GIVEREF(__pyx_tuple__72); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__73 = PyTuple_Pack(1, __pyx_kp_s_callback_must_be_callable_not_No); if (unlikely(!__pyx_tuple__73)) __PYX_ERR(0, 1617, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__73 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__73)) __PYX_ERR(0, 1734, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__73 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__73)) __PYX_ERR(0, 1668, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__73); + __Pyx_GIVEREF(__pyx_tuple__73); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__74 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__74)) __PYX_ERR(0, 1668, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__74 = PyTuple_Pack(1, __pyx_kp_s_callback_must_be_callable_not_No); if (unlikely(!__pyx_tuple__74)) __PYX_ERR(0, 1736, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__74 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__74)) __PYX_ERR(0, 1696, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__74); + __Pyx_GIVEREF(__pyx_tuple__74); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__75 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__75)) __PYX_ERR(0, 1696, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__75 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__75)) __PYX_ERR(0, 1771, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__75 = PyTuple_Pack(1, __pyx_kp_s_Cannot_set_priority_of_an_active); if (unlikely(!__pyx_tuple__75)) __PYX_ERR(0, 1714, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__75); + __Pyx_GIVEREF(__pyx_tuple__75); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__76 = PyTuple_Pack(1, __pyx_kp_s_Cannot_set_priority_of_an_active); if (unlikely(!__pyx_tuple__76)) __PYX_ERR(0, 1714, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__76 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__76)) __PYX_ERR(0, 1794, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__76 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__76)) __PYX_ERR(0, 1939, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__76 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__76)) __PYX_ERR(0, 1720, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__76); + __Pyx_GIVEREF(__pyx_tuple__76); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__77 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__77)) __PYX_ERR(0, 1720, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__77 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__77)) __PYX_ERR(0, 1822, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__77 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__77)) __PYX_ERR(0, 1967, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__77 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__77)) __PYX_ERR(0, 1734, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__77); + __Pyx_GIVEREF(__pyx_tuple__77); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__78 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__78)) __PYX_ERR(0, 1734, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__78 = PyTuple_Pack(1, __pyx_kp_s_Cannot_set_priority_of_an_active); if (unlikely(!__pyx_tuple__78)) __PYX_ERR(0, 1840, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__78 = PyTuple_Pack(1, __pyx_kp_s_Cannot_set_priority_of_an_active); if (unlikely(!__pyx_tuple__78)) __PYX_ERR(0, 1985, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__78 = PyTuple_Pack(1, __pyx_kp_s_callback_must_be_callable_not_No); if (unlikely(!__pyx_tuple__78)) __PYX_ERR(0, 1736, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__78); + __Pyx_GIVEREF(__pyx_tuple__78); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__79 = PyTuple_Pack(1, __pyx_kp_s_callback_must_be_callable_not_No); if (unlikely(!__pyx_tuple__79)) __PYX_ERR(0, 1736, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__79 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__79)) __PYX_ERR(0, 1846, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__79 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__79)) __PYX_ERR(0, 1991, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__79 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__79)) __PYX_ERR(0, 1771, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__79); + __Pyx_GIVEREF(__pyx_tuple__79); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__80 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__80)) __PYX_ERR(0, 1771, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__80 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__80)) __PYX_ERR(0, 1860, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__80 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__80)) __PYX_ERR(0, 2005, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__80 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__80)) __PYX_ERR(0, 1939, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__80 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__80)) __PYX_ERR(0, 1794, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__80); + __Pyx_GIVEREF(__pyx_tuple__80); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__81 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__81)) __PYX_ERR(0, 1794, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__81 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__81)) __PYX_ERR(0, 1939, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__81 = PyTuple_Pack(1, __pyx_kp_s_callback_must_be_callable_not_No); if (unlikely(!__pyx_tuple__81)) __PYX_ERR(0, 1862, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__81 = PyTuple_Pack(1, __pyx_kp_s_callback_must_be_callable_not_No); if (unlikely(!__pyx_tuple__81)) __PYX_ERR(0, 2007, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__81 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__81)) __PYX_ERR(0, 1967, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__81 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__81)) __PYX_ERR(0, 1822, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__81); + __Pyx_GIVEREF(__pyx_tuple__81); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__82 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__82)) __PYX_ERR(0, 1822, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__82 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__82)) __PYX_ERR(0, 1967, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__82 = PyTuple_Pack(1, __pyx_kp_s_child_watchers_are_only_availabl); if (unlikely(!__pyx_tuple__82)) __PYX_ERR(0, 1886, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__82 = PyTuple_Pack(1, __pyx_n_s_sys); if (unlikely(!__pyx_tuple__82)) __PYX_ERR(0, 16, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__82 = PyTuple_Pack(1, __pyx_kp_s_Cannot_set_priority_of_an_active); if (unlikely(!__pyx_tuple__82)) __PYX_ERR(0, 1985, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__82 = PyTuple_Pack(1, __pyx_kp_s_Cannot_set_priority_of_an_active); if (unlikely(!__pyx_tuple__82)) __PYX_ERR(0, 1840, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__82); + __Pyx_GIVEREF(__pyx_tuple__82); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__83 = PyTuple_Pack(1, __pyx_kp_s_Cannot_set_priority_of_an_active); if (unlikely(!__pyx_tuple__83)) __PYX_ERR(0, 1840, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__83 = PyTuple_Pack(1, __pyx_kp_s_Cannot_set_priority_of_an_active); if (unlikely(!__pyx_tuple__83)) __PYX_ERR(0, 1985, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__83 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__83)) __PYX_ERR(0, 1939, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__83 = PyTuple_Pack(1, __pyx_n_s_os); if (unlikely(!__pyx_tuple__83)) __PYX_ERR(0, 17, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__83 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__83)) __PYX_ERR(0, 1991, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__83 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__83)) __PYX_ERR(0, 1846, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__83); + __Pyx_GIVEREF(__pyx_tuple__83); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__84 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__84)) __PYX_ERR(0, 1846, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__84 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__84)) __PYX_ERR(0, 1991, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__84 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__84)) __PYX_ERR(0, 1967, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__84 = PyTuple_Pack(1, __pyx_n_s_traceback); if (unlikely(!__pyx_tuple__84)) __PYX_ERR(0, 18, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__84 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__84)) __PYX_ERR(0, 2005, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__84 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__84)) __PYX_ERR(0, 1860, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__84); + __Pyx_GIVEREF(__pyx_tuple__84); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__85 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__85)) __PYX_ERR(0, 1860, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__85 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__85)) __PYX_ERR(0, 2005, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__85 = PyTuple_Pack(1, __pyx_kp_s_Cannot_set_priority_of_an_active); if (unlikely(!__pyx_tuple__85)) __PYX_ERR(0, 1985, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__85 = PyTuple_Pack(1, __pyx_n_s_signal); if (unlikely(!__pyx_tuple__85)) __PYX_ERR(0, 19, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__85 = PyTuple_Pack(1, __pyx_kp_s_callback_must_be_callable_not_No); if (unlikely(!__pyx_tuple__85)) __PYX_ERR(0, 2007, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__85 = PyTuple_Pack(1, __pyx_kp_s_callback_must_be_callable_not_No); if (unlikely(!__pyx_tuple__85)) __PYX_ERR(0, 1862, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__85); + __Pyx_GIVEREF(__pyx_tuple__85); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__86 = PyTuple_Pack(1, __pyx_kp_s_callback_must_be_callable_not_No); if (unlikely(!__pyx_tuple__86)) __PYX_ERR(0, 1862, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__86 = PyTuple_Pack(1, __pyx_kp_s_callback_must_be_callable_not_No); if (unlikely(!__pyx_tuple__86)) __PYX_ERR(0, 2007, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__86 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__86)) __PYX_ERR(0, 1991, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__86 = PyTuple_Pack(1, __pyx_n_s_sys); if (unlikely(!__pyx_tuple__86)) __PYX_ERR(0, 16, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__86 = PyTuple_Pack(1, __pyx_kp_s_child_watchers_are_only_availabl); if (unlikely(!__pyx_tuple__86)) __PYX_ERR(0, 1886, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__86); + __Pyx_GIVEREF(__pyx_tuple__86); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__87 = PyTuple_Pack(1, __pyx_kp_s_child_watchers_are_only_availabl); if (unlikely(!__pyx_tuple__87)) __PYX_ERR(0, 1886, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__87 = PyTuple_Pack(1, __pyx_n_s_sys); if (unlikely(!__pyx_tuple__87)) __PYX_ERR(0, 16, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__87 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__87)) __PYX_ERR(0, 2005, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__87 = PyTuple_Pack(1, __pyx_n_s_os); if (unlikely(!__pyx_tuple__87)) __PYX_ERR(0, 17, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__87 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__87)) __PYX_ERR(0, 1939, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__87); + __Pyx_GIVEREF(__pyx_tuple__87); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__88 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__88)) __PYX_ERR(0, 1939, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__88 = PyTuple_Pack(1, __pyx_n_s_os); if (unlikely(!__pyx_tuple__88)) __PYX_ERR(0, 17, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__88 = PyTuple_Pack(1, __pyx_kp_s_callback_must_be_callable_not_No); if (unlikely(!__pyx_tuple__88)) __PYX_ERR(0, 2007, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__88 = PyTuple_Pack(1, __pyx_n_s_traceback); if (unlikely(!__pyx_tuple__88)) __PYX_ERR(0, 18, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__88 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__88)) __PYX_ERR(0, 1967, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__88); + __Pyx_GIVEREF(__pyx_tuple__88); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__89 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__89)) __PYX_ERR(0, 1967, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__89 = PyTuple_Pack(1, __pyx_n_s_traceback); if (unlikely(!__pyx_tuple__89)) __PYX_ERR(0, 18, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__89 = PyTuple_Pack(1, __pyx_n_s_sys); if (unlikely(!__pyx_tuple__89)) __PYX_ERR(0, 16, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__89 = PyTuple_Pack(1, __pyx_n_s_signal); if (unlikely(!__pyx_tuple__89)) __PYX_ERR(0, 19, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__89 = PyTuple_Pack(1, __pyx_kp_s_Cannot_set_priority_of_an_active); if (unlikely(!__pyx_tuple__89)) __PYX_ERR(0, 1985, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__89); + __Pyx_GIVEREF(__pyx_tuple__89); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__90 = PyTuple_Pack(1, __pyx_kp_s_Cannot_set_priority_of_an_active); if (unlikely(!__pyx_tuple__90)) __PYX_ERR(0, 1985, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_tuple__90 = PyTuple_Pack(1, __pyx_n_s_signal); if (unlikely(!__pyx_tuple__90)) __PYX_ERR(0, 19, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__90 = PyTuple_Pack(1, __pyx_n_s_os); if (unlikely(!__pyx_tuple__90)) __PYX_ERR(0, 17, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_codeobj__90 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_Users_appveyor_AppData_Local_T, __pyx_n_s_get_version, 107, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__90)) __PYX_ERR(0, 107, __pyx_L1_error) + + __pyx_codeobj__91 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_Users_appveyor_AppData_Local_T, __pyx_n_s_get_header_version, 111, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__91)) __PYX_ERR(0, 111, __pyx_L1_error) + + __pyx_codeobj__92 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_Users_appveyor_AppData_Local_T, __pyx_n_s_supported_backends, 220, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__92)) __PYX_ERR(0, 220, __pyx_L1_error) + + __pyx_codeobj__93 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_Users_appveyor_AppData_Local_T, __pyx_n_s_recommended_backends, 224, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__93)) __PYX_ERR(0, 224, __pyx_L1_error) + + __pyx_codeobj__94 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_Users_appveyor_AppData_Local_T, __pyx_n_s_embeddable_backends, 228, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__94)) __PYX_ERR(0, 228, __pyx_L1_error) + + __pyx_codeobj__95 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_Users_appveyor_AppData_Local_T, __pyx_n_s_time, 232, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__95)) __PYX_ERR(0, 232, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__90 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__90)) __PYX_ERR(0, 1991, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__90); + __Pyx_GIVEREF(__pyx_tuple__90); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__91 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__91)) __PYX_ERR(0, 1991, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__91 = PyTuple_Pack(1, __pyx_n_s_traceback); if (unlikely(!__pyx_tuple__91)) __PYX_ERR(0, 18, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__91 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__91)) __PYX_ERR(0, 2005, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__91); + __Pyx_GIVEREF(__pyx_tuple__91); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__92 = PyTuple_Pack(1, __pyx_kp_s_operation_on_destroyed_loop); if (unlikely(!__pyx_tuple__92)) __PYX_ERR(0, 2005, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__92 = PyTuple_Pack(1, __pyx_n_s_signal); if (unlikely(!__pyx_tuple__92)) __PYX_ERR(0, 19, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__92 = PyTuple_Pack(1, __pyx_kp_s_callback_must_be_callable_not_No); if (unlikely(!__pyx_tuple__92)) __PYX_ERR(0, 2007, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__92); + __Pyx_GIVEREF(__pyx_tuple__92); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__93 = PyTuple_Pack(1, __pyx_kp_s_callback_must_be_callable_not_No); if (unlikely(!__pyx_tuple__93)) __PYX_ERR(0, 2007, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_codeobj__93 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_Users_appveyor_AppData_Local_T, __pyx_n_s_get_version, 107, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__93)) __PYX_ERR(0, 107, __pyx_L1_error) + + __pyx_codeobj__94 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_Users_appveyor_AppData_Local_T, __pyx_n_s_get_header_version, 111, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__94)) __PYX_ERR(0, 111, __pyx_L1_error) + + __pyx_codeobj__95 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_Users_appveyor_AppData_Local_T, __pyx_n_s_supported_backends, 220, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__95)) __PYX_ERR(0, 220, __pyx_L1_error) + + __pyx_codeobj__96 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_Users_appveyor_AppData_Local_T, __pyx_n_s_recommended_backends, 224, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__96)) __PYX_ERR(0, 224, __pyx_L1_error) + + __pyx_codeobj__97 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_Users_appveyor_AppData_Local_T, __pyx_n_s_embeddable_backends, 228, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__97)) __PYX_ERR(0, 228, __pyx_L1_error) + + __pyx_codeobj__98 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_Users_appveyor_AppData_Local_T, __pyx_n_s_time, 232, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__98)) __PYX_ERR(0, 232, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_codeobj__86 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_Users_appveyor_AppData_Local_T, __pyx_n_s_get_version, 107, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__86)) __PYX_ERR(0, 107, __pyx_L1_error) + + __pyx_codeobj__87 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_Users_appveyor_AppData_Local_T, __pyx_n_s_get_header_version, 111, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__87)) __PYX_ERR(0, 111, __pyx_L1_error) + + __pyx_codeobj__88 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_Users_appveyor_AppData_Local_T, __pyx_n_s_supported_backends, 220, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__88)) __PYX_ERR(0, 220, __pyx_L1_error) + + __pyx_codeobj__89 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_Users_appveyor_AppData_Local_T, __pyx_n_s_recommended_backends, 224, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__89)) __PYX_ERR(0, 224, __pyx_L1_error) + + __pyx_codeobj__90 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_Users_appveyor_AppData_Local_T, __pyx_n_s_embeddable_backends, 228, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__90)) __PYX_ERR(0, 228, __pyx_L1_error) + + __pyx_codeobj__91 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_Users_appveyor_AppData_Local_T, __pyx_n_s_time, 232, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__91)) __PYX_ERR(0, 232, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__93 = PyTuple_Pack(1, __pyx_n_s_sys); if (unlikely(!__pyx_tuple__93)) __PYX_ERR(0, 16, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__93); + __Pyx_GIVEREF(__pyx_tuple__93); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__94 = PyTuple_Pack(1, __pyx_n_s_sys); if (unlikely(!__pyx_tuple__94)) __PYX_ERR(0, 16, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__94 = PyTuple_Pack(1, __pyx_n_s_os); if (unlikely(!__pyx_tuple__94)) __PYX_ERR(0, 17, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__94); + __Pyx_GIVEREF(__pyx_tuple__94); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__95 = PyTuple_Pack(1, __pyx_n_s_os); if (unlikely(!__pyx_tuple__95)) __PYX_ERR(0, 17, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__95 = PyTuple_Pack(1, __pyx_n_s_traceback); if (unlikely(!__pyx_tuple__95)) __PYX_ERR(0, 18, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__95); + __Pyx_GIVEREF(__pyx_tuple__95); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__96 = PyTuple_Pack(1, __pyx_n_s_traceback); if (unlikely(!__pyx_tuple__96)) __PYX_ERR(0, 18, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__96 = PyTuple_Pack(1, __pyx_n_s_signal); if (unlikely(!__pyx_tuple__96)) __PYX_ERR(0, 19, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_tuple__96); + __Pyx_GIVEREF(__pyx_tuple__96); + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_tuple__97 = PyTuple_Pack(1, __pyx_n_s_signal); if (unlikely(!__pyx_tuple__97)) __PYX_ERR(0, 19, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__97); + __Pyx_GIVEREF(__pyx_tuple__97); + + __pyx_codeobj__98 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_Users_appveyor_AppData_Local_T, __pyx_n_s_get_version, 107, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__98)) __PYX_ERR(0, 107, __pyx_L1_error) + + __pyx_codeobj__99 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_Users_appveyor_AppData_Local_T, __pyx_n_s_get_header_version, 111, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__99)) __PYX_ERR(0, 111, __pyx_L1_error) + + __pyx_codeobj__100 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_Users_appveyor_AppData_Local_T, __pyx_n_s_supported_backends, 220, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__100)) __PYX_ERR(0, 220, __pyx_L1_error) + + __pyx_codeobj__101 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_Users_appveyor_AppData_Local_T, __pyx_n_s_recommended_backends, 224, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__101)) __PYX_ERR(0, 224, __pyx_L1_error) + + __pyx_codeobj__102 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_Users_appveyor_AppData_Local_T, __pyx_n_s_embeddable_backends, 228, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__102)) __PYX_ERR(0, 228, __pyx_L1_error) + + __pyx_codeobj__103 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_Users_appveyor_AppData_Local_T, __pyx_n_s_time, 232, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__103)) __PYX_ERR(0, 232, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_codeobj__91 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_Users_appveyor_AppData_Local_T, __pyx_n_s_get_version, 107, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__91)) __PYX_ERR(0, 107, __pyx_L1_error) + + __pyx_codeobj__92 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_Users_appveyor_AppData_Local_T, __pyx_n_s_get_header_version, 111, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__92)) __PYX_ERR(0, 111, __pyx_L1_error) + + __pyx_codeobj__93 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_Users_appveyor_AppData_Local_T, __pyx_n_s_supported_backends, 220, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__93)) __PYX_ERR(0, 220, __pyx_L1_error) + + __pyx_codeobj__94 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_Users_appveyor_AppData_Local_T, __pyx_n_s_recommended_backends, 224, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__94)) __PYX_ERR(0, 224, __pyx_L1_error) + + __pyx_codeobj__95 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_Users_appveyor_AppData_Local_T, __pyx_n_s_embeddable_backends, 228, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__95)) __PYX_ERR(0, 228, __pyx_L1_error) + + __pyx_codeobj__96 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_Users_appveyor_AppData_Local_T, __pyx_n_s_time, 232, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__96)) __PYX_ERR(0, 232, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_codeobj__97 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_Users_appveyor_AppData_Local_T, __pyx_n_s_get_version, 107, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__97)) __PYX_ERR(0, 107, __pyx_L1_error) + + __pyx_codeobj__98 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_Users_appveyor_AppData_Local_T, __pyx_n_s_get_header_version, 111, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__98)) __PYX_ERR(0, 111, __pyx_L1_error) + + __pyx_codeobj__99 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_Users_appveyor_AppData_Local_T, __pyx_n_s_supported_backends, 220, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__99)) __PYX_ERR(0, 220, __pyx_L1_error) + + __pyx_codeobj__100 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_Users_appveyor_AppData_Local_T, __pyx_n_s_recommended_backends, 224, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__100)) __PYX_ERR(0, 224, __pyx_L1_error) + + __pyx_codeobj__101 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_Users_appveyor_AppData_Local_T, __pyx_n_s_embeddable_backends, 228, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__101)) __PYX_ERR(0, 228, __pyx_L1_error) + + __pyx_codeobj__102 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_Users_appveyor_AppData_Local_T, __pyx_n_s_time, 232, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__102)) __PYX_ERR(0, 232, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_InitGlobals(void) { + if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); + __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_3 = PyInt_FromLong(3); if (unlikely(!__pyx_int_3)) __PYX_ERR(0, 1, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_int_neg_1 = PyInt_FromLong(-1); if (unlikely(!__pyx_int_neg_1)) __PYX_ERR(0, 1, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + return 0; + __pyx_L1_error:; + return -1; +} + +#if PY_MAJOR_VERSION < 3 +PyMODINIT_FUNC initcorecext(void); /*proto*/ +PyMODINIT_FUNC initcorecext(void) +#else +PyMODINIT_FUNC PyInit_corecext(void); /*proto*/ +PyMODINIT_FUNC PyInit_corecext(void) +#endif +{ + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11 = NULL; + PyObject *__pyx_t_12 = NULL; + PyObject *__pyx_t_13 = NULL; + PyObject *__pyx_t_14 = NULL; + PyObject *__pyx_t_15 = NULL; + PyObject *__pyx_t_16 = NULL; + PyObject *__pyx_t_17 = NULL; + PyObject *__pyx_t_18 = NULL; + __Pyx_RefNannyDeclarations + #if CYTHON_REFNANNY + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); + if (!__Pyx_RefNanny) { + PyErr_Clear(); + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); + if (!__Pyx_RefNanny) + Py_FatalError("failed to import 'refnanny' module"); + } + #endif + __Pyx_RefNannySetupContext("PyMODINIT_FUNC PyInit_corecext(void)", 0); + if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) + #ifdef __Pyx_CyFunction_USED + if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_FusedFunction_USED + if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Coroutine_USED + if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Generator_USED + if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_StopAsyncIteration_USED + if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + /*--- Library function declarations ---*/ + /*--- Threads initialization code ---*/ + #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS + #ifdef WITH_THREAD /* Python build with threading support? */ + PyEval_InitThreads(); + #endif + #endif + /*--- Module creation code ---*/ + #if PY_MAJOR_VERSION < 3 + __pyx_m = Py_InitModule4("corecext", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); + #else + __pyx_m = PyModule_Create(&__pyx_moduledef); + #endif + if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_d); + __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) + #if CYTHON_COMPILING_IN_PYPY + Py_INCREF(__pyx_b); + #endif + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error); + /*--- Initialize various global constants etc. ---*/ + if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) + if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + if (__pyx_module_is_main_gevent__libev__corecext) { + if (PyObject_SetAttrString(__pyx_m, "__name__", __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + } + #if PY_MAJOR_VERSION >= 3 + { + PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) + if (!PyDict_GetItemString(modules, "gevent.libev.corecext")) { + if (unlikely(PyDict_SetItemString(modules, "gevent.libev.corecext", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + } + } + #endif + /*--- Builtin init code ---*/ + if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Constants init code ---*/ + if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Global init code ---*/ + __pyx_v_6gevent_5libev_8corecext_integer_types = ((PyObject*)Py_None); Py_INCREF(Py_None); + GEVENT_CORE_EVENTS = Py_None; Py_INCREF(Py_None); + /*--- Variable export code ---*/ + /*--- Function export code ---*/ + /*--- Type init code ---*/ + if (PyType_Ready(&__pyx_type_6gevent_5libev_8corecext__EVENTSType) < 0) __PYX_ERR(0, 97, __pyx_L1_error) + __pyx_type_6gevent_5libev_8corecext__EVENTSType.tp_print = 0; + __pyx_ptype_6gevent_5libev_8corecext__EVENTSType = &__pyx_type_6gevent_5libev_8corecext__EVENTSType; + __pyx_vtabptr_6gevent_5libev_8corecext_loop = &__pyx_vtable_6gevent_5libev_8corecext_loop; + __pyx_vtable_6gevent_5libev_8corecext_loop._run_callbacks = (PyObject *(*)(struct PyGeventLoopObject *))__pyx_f_6gevent_5libev_8corecext_4loop__run_callbacks; + __pyx_vtable_6gevent_5libev_8corecext_loop.handle_error = (PyObject *(*)(struct PyGeventLoopObject *, PyObject *, PyObject *, PyObject *, PyObject *, int __pyx_skip_dispatch))__pyx_f_6gevent_5libev_8corecext_4loop_handle_error; + __pyx_vtable_6gevent_5libev_8corecext_loop._default_handle_error = (PyObject *(*)(struct PyGeventLoopObject *, PyObject *, PyObject *, PyObject *, PyObject *, int __pyx_skip_dispatch))__pyx_f_6gevent_5libev_8corecext_4loop__default_handle_error; + if (PyType_Ready(&PyGeventLoop_Type) < 0) __PYX_ERR(0, 246, __pyx_L1_error) + PyGeventLoop_Type.tp_print = 0; + if (__Pyx_SetVtable(PyGeventLoop_Type.tp_dict, __pyx_vtabptr_6gevent_5libev_8corecext_loop) < 0) __PYX_ERR(0, 246, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "loop", (PyObject *)&PyGeventLoop_Type) < 0) __PYX_ERR(0, 246, __pyx_L1_error) + __pyx_ptype_6gevent_5libev_8corecext_loop = &PyGeventLoop_Type; + if (PyType_Ready(&PyGeventCallback_Type) < 0) __PYX_ERR(0, 627, __pyx_L1_error) + PyGeventCallback_Type.tp_print = 0; + if (PyObject_SetAttrString(__pyx_m, "callback", (PyObject *)&PyGeventCallback_Type) < 0) __PYX_ERR(0, 627, __pyx_L1_error) + __pyx_ptype_6gevent_5libev_8corecext_callback = &PyGeventCallback_Type; + if (PyType_Ready(&PyGeventWatcher_Type) < 0) __PYX_ERR(0, 695, __pyx_L1_error) + PyGeventWatcher_Type.tp_print = 0; + if (PyObject_SetAttrString(__pyx_m, "watcher", (PyObject *)&PyGeventWatcher_Type) < 0) __PYX_ERR(0, 695, __pyx_L1_error) + __pyx_ptype_6gevent_5libev_8corecext_watcher = &PyGeventWatcher_Type; + PyGeventIO_Type.tp_base = __pyx_ptype_6gevent_5libev_8corecext_watcher; + if (PyType_Ready(&PyGeventIO_Type) < 0) __PYX_ERR(0, 720, __pyx_L1_error) + PyGeventIO_Type.tp_print = 0; + if (PyObject_SetAttrString(__pyx_m, "io", (PyObject *)&PyGeventIO_Type) < 0) __PYX_ERR(0, 720, __pyx_L1_error) + __pyx_ptype_6gevent_5libev_8corecext_io = &PyGeventIO_Type; + PyGeventTimer_Type.tp_base = __pyx_ptype_6gevent_5libev_8corecext_watcher; + if (PyType_Ready(&PyGeventTimer_Type) < 0) __PYX_ERR(0, 905, __pyx_L1_error) + PyGeventTimer_Type.tp_print = 0; + if (PyObject_SetAttrString(__pyx_m, "timer", (PyObject *)&PyGeventTimer_Type) < 0) __PYX_ERR(0, 905, __pyx_L1_error) + __pyx_ptype_6gevent_5libev_8corecext_timer = &PyGeventTimer_Type; + PyGeventSignal_Type.tp_base = __pyx_ptype_6gevent_5libev_8corecext_watcher; + if (PyType_Ready(&PyGeventSignal_Type) < 0) __PYX_ERR(0, 1050, __pyx_L1_error) + PyGeventSignal_Type.tp_print = 0; + if (PyObject_SetAttrString(__pyx_m, "signal", (PyObject *)&PyGeventSignal_Type) < 0) __PYX_ERR(0, 1050, __pyx_L1_error) + __pyx_ptype_6gevent_5libev_8corecext_signal = &PyGeventSignal_Type; + PyGeventIdle_Type.tp_base = __pyx_ptype_6gevent_5libev_8corecext_watcher; + if (PyType_Ready(&PyGeventIdle_Type) < 0) __PYX_ERR(0, 1175, __pyx_L1_error) + PyGeventIdle_Type.tp_print = 0; + if (PyObject_SetAttrString(__pyx_m, "idle", (PyObject *)&PyGeventIdle_Type) < 0) __PYX_ERR(0, 1175, __pyx_L1_error) + __pyx_ptype_6gevent_5libev_8corecext_idle = &PyGeventIdle_Type; + PyGeventPrepare_Type.tp_base = __pyx_ptype_6gevent_5libev_8corecext_watcher; + if (PyType_Ready(&PyGeventPrepare_Type) < 0) __PYX_ERR(0, 1294, __pyx_L1_error) + PyGeventPrepare_Type.tp_print = 0; + if (PyObject_SetAttrString(__pyx_m, "prepare", (PyObject *)&PyGeventPrepare_Type) < 0) __PYX_ERR(0, 1294, __pyx_L1_error) + __pyx_ptype_6gevent_5libev_8corecext_prepare = &PyGeventPrepare_Type; + PyGeventCheck_Type.tp_base = __pyx_ptype_6gevent_5libev_8corecext_watcher; + if (PyType_Ready(&PyGeventCheck_Type) < 0) __PYX_ERR(0, 1413, __pyx_L1_error) + PyGeventCheck_Type.tp_print = 0; + if (PyObject_SetAttrString(__pyx_m, "check", (PyObject *)&PyGeventCheck_Type) < 0) __PYX_ERR(0, 1413, __pyx_L1_error) + __pyx_ptype_6gevent_5libev_8corecext_check = &PyGeventCheck_Type; + PyGeventFork_Type.tp_base = __pyx_ptype_6gevent_5libev_8corecext_watcher; + if (PyType_Ready(&PyGeventFork_Type) < 0) __PYX_ERR(0, 1532, __pyx_L1_error) + PyGeventFork_Type.tp_print = 0; + if (PyObject_SetAttrString(__pyx_m, "fork", (PyObject *)&PyGeventFork_Type) < 0) __PYX_ERR(0, 1532, __pyx_L1_error) + __pyx_ptype_6gevent_5libev_8corecext_fork = &PyGeventFork_Type; + PyGeventAsync_Type.tp_base = __pyx_ptype_6gevent_5libev_8corecext_watcher; + if (PyType_Ready(&PyGeventAsync_Type) < 0) __PYX_ERR(0, 1651, __pyx_L1_error) + PyGeventAsync_Type.tp_print = 0; + if (PyObject_SetAttrString(__pyx_m, "async", (PyObject *)&PyGeventAsync_Type) < 0) __PYX_ERR(0, 1651, __pyx_L1_error) + __pyx_ptype_6gevent_5libev_8corecext_async = &PyGeventAsync_Type; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + PyGeventChild_Type.tp_base = __pyx_ptype_6gevent_5libev_8corecext_watcher; + if (PyType_Ready(&PyGeventChild_Type) < 0) __PYX_ERR(0, 1777, __pyx_L1_error) + PyGeventChild_Type.tp_print = 0; + if (PyObject_SetAttrString(__pyx_m, "child", (PyObject *)&PyGeventChild_Type) < 0) __PYX_ERR(0, 1777, __pyx_L1_error) + __pyx_ptype_6gevent_5libev_8corecext_child = &PyGeventChild_Type; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + PyGeventStat_Type.tp_base = __pyx_ptype_6gevent_5libev_8corecext_watcher; + if (PyType_Ready(&PyGeventStat_Type) < 0) __PYX_ERR(0, 1922, __pyx_L1_error) + PyGeventStat_Type.tp_print = 0; + if (PyObject_SetAttrString(__pyx_m, "stat", (PyObject *)&PyGeventStat_Type) < 0) __PYX_ERR(0, 1922, __pyx_L1_error) + __pyx_ptype_6gevent_5libev_8corecext_stat = &PyGeventStat_Type; + if (PyType_Ready(&__pyx_type_6gevent_5libev_8corecext___pyx_scope_struct__genexpr) < 0) __PYX_ERR(0, 128, __pyx_L1_error) + __pyx_type_6gevent_5libev_8corecext___pyx_scope_struct__genexpr.tp_print = 0; + __pyx_ptype_6gevent_5libev_8corecext___pyx_scope_struct__genexpr = &__pyx_type_6gevent_5libev_8corecext___pyx_scope_struct__genexpr; + /*--- Type import code ---*/ + /*--- Variable import code ---*/ + /*--- Function import code ---*/ + /*--- Execution code ---*/ + #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) + if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + + __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_level, __pyx_int_0) < 0) __PYX_ERR(0, 16, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin___import__, __pyx_tuple__94, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 16, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin___import__, __pyx_tuple__87, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 16, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin___import__, __pyx_tuple__89, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 16, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin___import__, __pyx_tuple__82, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 16, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin___import__, __pyx_tuple__86, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 16, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin___import__, __pyx_tuple__93, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 16, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_sys, __pyx_t_2) < 0) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_level, __pyx_int_0) < 0) __PYX_ERR(0, 17, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin___import__, __pyx_tuple__95, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 17, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin___import__, __pyx_tuple__88, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 17, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin___import__, __pyx_tuple__90, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 17, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin___import__, __pyx_tuple__83, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 17, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin___import__, __pyx_tuple__87, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 17, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin___import__, __pyx_tuple__94, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 17, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_os, __pyx_t_1) < 0) __PYX_ERR(0, 17, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 18, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_level, __pyx_int_0) < 0) __PYX_ERR(0, 18, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin___import__, __pyx_tuple__96, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 18, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin___import__, __pyx_tuple__89, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 18, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin___import__, __pyx_tuple__91, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 18, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin___import__, __pyx_tuple__84, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 18, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin___import__, __pyx_tuple__88, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 18, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin___import__, __pyx_tuple__95, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 18, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_traceback, __pyx_t_2) < 0) __PYX_ERR(0, 18, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 19, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_level, __pyx_int_0) < 0) __PYX_ERR(0, 19, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin___import__, __pyx_tuple__97, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 19, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin___import__, __pyx_tuple__90, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 19, __pyx_L1_error) +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin___import__, __pyx_tuple__92, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 19, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin___import__, __pyx_tuple__85, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 19, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin___import__, __pyx_tuple__89, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 19, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin___import__, __pyx_tuple__96, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 19, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_signalmodule, __pyx_t_1) < 0) __PYX_ERR(0, 19, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + __pyx_t_1 = PyList_New(7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_get_version); + __Pyx_GIVEREF(__pyx_n_s_get_version); + PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_get_version); + __Pyx_INCREF(__pyx_n_s_get_header_version); + __Pyx_GIVEREF(__pyx_n_s_get_header_version); + PyList_SET_ITEM(__pyx_t_1, 1, __pyx_n_s_get_header_version); + __Pyx_INCREF(__pyx_n_s_supported_backends); + __Pyx_GIVEREF(__pyx_n_s_supported_backends); + PyList_SET_ITEM(__pyx_t_1, 2, __pyx_n_s_supported_backends); + __Pyx_INCREF(__pyx_n_s_recommended_backends); + __Pyx_GIVEREF(__pyx_n_s_recommended_backends); + PyList_SET_ITEM(__pyx_t_1, 3, __pyx_n_s_recommended_backends); + __Pyx_INCREF(__pyx_n_s_embeddable_backends); + __Pyx_GIVEREF(__pyx_n_s_embeddable_backends); + PyList_SET_ITEM(__pyx_t_1, 4, __pyx_n_s_embeddable_backends); + __Pyx_INCREF(__pyx_n_s_time); + __Pyx_GIVEREF(__pyx_n_s_time); + PyList_SET_ITEM(__pyx_t_1, 5, __pyx_n_s_time); + __Pyx_INCREF(__pyx_n_s_loop); + __Pyx_GIVEREF(__pyx_n_s_loop); + PyList_SET_ITEM(__pyx_t_1, 6, __pyx_n_s_loop); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_all, __pyx_t_1) < 0) __PYX_ERR(0, 22, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_sys); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_version_info); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_GetItemInt(__pyx_t_2, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyObject_RichCompare(__pyx_t_1, __pyx_int_3, Py_GE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_3) { + + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 33, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(((PyObject *)(&PyInt_Type))); + __Pyx_GIVEREF(((PyObject *)(&PyInt_Type))); + PyTuple_SET_ITEM(__pyx_t_2, 0, ((PyObject *)(&PyInt_Type))); + __Pyx_XGOTREF(__pyx_v_6gevent_5libev_8corecext_integer_types); + __Pyx_DECREF_SET(__pyx_v_6gevent_5libev_8corecext_integer_types, ((PyObject*)__pyx_t_2)); + __Pyx_GIVEREF(__pyx_t_2); + __pyx_t_2 = 0; + + goto __pyx_L2; + } + + /*else*/ { + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 35, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(((PyObject *)(&PyInt_Type))); + __Pyx_GIVEREF(((PyObject *)(&PyInt_Type))); + PyTuple_SET_ITEM(__pyx_t_2, 0, ((PyObject *)(&PyInt_Type))); + __Pyx_INCREF(((PyObject *)(&PyLong_Type))); + __Pyx_GIVEREF(((PyObject *)(&PyLong_Type))); + PyTuple_SET_ITEM(__pyx_t_2, 1, ((PyObject *)(&PyLong_Type))); + __Pyx_XGOTREF(__pyx_v_6gevent_5libev_8corecext_integer_types); + __Pyx_DECREF_SET(__pyx_v_6gevent_5libev_8corecext_integer_types, ((PyObject*)__pyx_t_2)); + __Pyx_GIVEREF(__pyx_t_2); + __pyx_t_2 = 0; + } + __pyx_L2:; + + __pyx_t_2 = __Pyx_PyInt_From_int(EV_UNDEF); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 61, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_UNDEF, __pyx_t_2) < 0) __PYX_ERR(0, 61, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + __pyx_t_2 = __Pyx_PyInt_From_int(EV_NONE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 62, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_NONE, __pyx_t_2) < 0) __PYX_ERR(0, 62, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + __pyx_t_2 = __Pyx_PyInt_From_int(EV_READ); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 63, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_READ, __pyx_t_2) < 0) __PYX_ERR(0, 63, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + __pyx_t_2 = __Pyx_PyInt_From_int(EV_WRITE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 64, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_WRITE, __pyx_t_2) < 0) __PYX_ERR(0, 64, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + __pyx_t_2 = __Pyx_PyInt_From_int(EV_TIMER); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 65, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_TIMER, __pyx_t_2) < 0) __PYX_ERR(0, 65, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + __pyx_t_2 = __Pyx_PyInt_From_int(EV_PERIODIC); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 66, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_PERIODIC, __pyx_t_2) < 0) __PYX_ERR(0, 66, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + __pyx_t_2 = __Pyx_PyInt_From_int(EV_SIGNAL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 67, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_SIGNAL, __pyx_t_2) < 0) __PYX_ERR(0, 67, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + __pyx_t_2 = __Pyx_PyInt_From_int(EV_CHILD); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 68, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_CHILD, __pyx_t_2) < 0) __PYX_ERR(0, 68, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + __pyx_t_2 = __Pyx_PyInt_From_int(EV_STAT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 69, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_STAT, __pyx_t_2) < 0) __PYX_ERR(0, 69, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + __pyx_t_2 = __Pyx_PyInt_From_int(EV_IDLE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 70, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_IDLE, __pyx_t_2) < 0) __PYX_ERR(0, 70, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + __pyx_t_2 = __Pyx_PyInt_From_int(EV_PREPARE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 71, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_PREPARE, __pyx_t_2) < 0) __PYX_ERR(0, 71, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + __pyx_t_2 = __Pyx_PyInt_From_int(EV_CHECK); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 72, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_CHECK, __pyx_t_2) < 0) __PYX_ERR(0, 72, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + __pyx_t_2 = __Pyx_PyInt_From_int(EV_EMBED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 73, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_EMBED, __pyx_t_2) < 0) __PYX_ERR(0, 73, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + __pyx_t_2 = __Pyx_PyInt_From_int(EV_FORK); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 74, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_FORK, __pyx_t_2) < 0) __PYX_ERR(0, 74, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + __pyx_t_2 = __Pyx_PyInt_From_int(EV_CLEANUP); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 75, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_CLEANUP, __pyx_t_2) < 0) __PYX_ERR(0, 75, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + __pyx_t_2 = __Pyx_PyInt_From_int(EV_ASYNC); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 76, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ASYNC, __pyx_t_2) < 0) __PYX_ERR(0, 76, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + __pyx_t_2 = __Pyx_PyInt_From_int(EV_CUSTOM); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 77, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_CUSTOM, __pyx_t_2) < 0) __PYX_ERR(0, 77, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + __pyx_t_2 = __Pyx_PyInt_From_int(EV_ERROR); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 78, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ERROR, __pyx_t_2) < 0) __PYX_ERR(0, 78, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + __pyx_t_2 = __Pyx_PyInt_From_int((EV_READ | EV_WRITE)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 80, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_READWRITE, __pyx_t_2) < 0) __PYX_ERR(0, 80, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + __pyx_t_2 = __Pyx_PyInt_From_int(EV_MINPRI); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 82, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_MINPRI, __pyx_t_2) < 0) __PYX_ERR(0, 82, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + __pyx_t_2 = __Pyx_PyInt_From_int(EV_MAXPRI); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 83, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_MAXPRI, __pyx_t_2) < 0) __PYX_ERR(0, 83, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + __pyx_t_2 = __Pyx_PyInt_From_int(EVBACKEND_PORT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 85, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_BACKEND_PORT, __pyx_t_2) < 0) __PYX_ERR(0, 85, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + __pyx_t_2 = __Pyx_PyInt_From_int(EVBACKEND_KQUEUE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 86, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_BACKEND_KQUEUE, __pyx_t_2) < 0) __PYX_ERR(0, 86, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + __pyx_t_2 = __Pyx_PyInt_From_int(EVBACKEND_EPOLL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_BACKEND_EPOLL, __pyx_t_2) < 0) __PYX_ERR(0, 87, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + __pyx_t_2 = __Pyx_PyInt_From_int(EVBACKEND_POLL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 88, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_BACKEND_POLL, __pyx_t_2) < 0) __PYX_ERR(0, 88, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + __pyx_t_2 = __Pyx_PyInt_From_int(EVBACKEND_SELECT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 89, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_BACKEND_SELECT, __pyx_t_2) < 0) __PYX_ERR(0, 89, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + __pyx_t_2 = __Pyx_PyInt_From_int(EVFLAG_FORKCHECK); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 90, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_FORKCHECK, __pyx_t_2) < 0) __PYX_ERR(0, 90, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + __pyx_t_2 = __Pyx_PyInt_From_int(EVFLAG_NOINOTIFY); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 91, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_NOINOTIFY, __pyx_t_2) < 0) __PYX_ERR(0, 91, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + __pyx_t_2 = __Pyx_PyInt_From_int(EVFLAG_SIGNALFD); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 92, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_SIGNALFD, __pyx_t_2) < 0) __PYX_ERR(0, 92, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + __pyx_t_2 = __Pyx_PyInt_From_int(EVFLAG_NOSIGMASK); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 93, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_NOSIGMASK, __pyx_t_2) < 0) __PYX_ERR(0, 93, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6gevent_5libev_8corecext__EVENTSType), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 103, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_XGOTREF(GEVENT_CORE_EVENTS); + __Pyx_DECREF_SET(GEVENT_CORE_EVENTS, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __pyx_t_2 = 0; + + if (PyDict_SetItem(__pyx_d, __pyx_n_s_EVENTS, GEVENT_CORE_EVENTS) < 0) __PYX_ERR(0, 104, __pyx_L1_error) + + __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_6gevent_5libev_8corecext_1get_version, NULL, __pyx_n_s_gevent_libev_corecext); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 107, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_version, __pyx_t_2) < 0) __PYX_ERR(0, 107, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_6gevent_5libev_8corecext_3get_header_version, NULL, __pyx_n_s_gevent_libev_corecext); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 111, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_header_version, __pyx_t_2) < 0) __PYX_ERR(0, 111, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + __pyx_t_2 = __Pyx_PyInt_From_int(EVBACKEND_PORT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 116, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 116, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); + __Pyx_INCREF(__pyx_n_s_port); + __Pyx_GIVEREF(__pyx_n_s_port); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_n_s_port); + __pyx_t_2 = 0; + + __pyx_t_2 = __Pyx_PyInt_From_int(EVBACKEND_KQUEUE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 117, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 117, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2); + __Pyx_INCREF(__pyx_n_s_kqueue); + __Pyx_GIVEREF(__pyx_n_s_kqueue); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_n_s_kqueue); + __pyx_t_2 = 0; + + __pyx_t_2 = __Pyx_PyInt_From_int(EVBACKEND_EPOLL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 118, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 118, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_2); + __Pyx_INCREF(__pyx_n_s_epoll); + __Pyx_GIVEREF(__pyx_n_s_epoll); + PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_n_s_epoll); + __pyx_t_2 = 0; + + __pyx_t_2 = __Pyx_PyInt_From_int(EVBACKEND_POLL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 119, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 119, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_2); + __Pyx_INCREF(__pyx_n_s_poll); + __Pyx_GIVEREF(__pyx_n_s_poll); + PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_n_s_poll); + __pyx_t_2 = 0; + + __pyx_t_2 = __Pyx_PyInt_From_int(EVBACKEND_SELECT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 120, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 120, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_2); + __Pyx_INCREF(__pyx_n_s_select); + __Pyx_GIVEREF(__pyx_n_s_select); + PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_n_s_select); + __pyx_t_2 = 0; + + __pyx_t_2 = __Pyx_PyInt_From_int(EVFLAG_NOENV); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 121, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 121, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_2); + __Pyx_INCREF(__pyx_n_s_noenv); + __Pyx_GIVEREF(__pyx_n_s_noenv); + PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_n_s_noenv); + __pyx_t_2 = 0; + + __pyx_t_2 = __Pyx_PyInt_From_int(EVFLAG_FORKCHECK); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 122, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_9 = PyTuple_New(2); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 122, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_2); + __Pyx_INCREF(__pyx_n_s_forkcheck); + __Pyx_GIVEREF(__pyx_n_s_forkcheck); + PyTuple_SET_ITEM(__pyx_t_9, 1, __pyx_n_s_forkcheck); + __pyx_t_2 = 0; + + __pyx_t_2 = __Pyx_PyInt_From_int(EVFLAG_NOINOTIFY); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 123, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = PyTuple_New(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 123, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_2); + __Pyx_INCREF(__pyx_n_s_noinotify); + __Pyx_GIVEREF(__pyx_n_s_noinotify); + PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_n_s_noinotify); + __pyx_t_2 = 0; + + __pyx_t_2 = __Pyx_PyInt_From_int(EVFLAG_SIGNALFD); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 124, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_11 = PyTuple_New(2); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 124, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_2); + __Pyx_INCREF(__pyx_n_s_signalfd); + __Pyx_GIVEREF(__pyx_n_s_signalfd); + PyTuple_SET_ITEM(__pyx_t_11, 1, __pyx_n_s_signalfd); + __pyx_t_2 = 0; + + __pyx_t_2 = __Pyx_PyInt_From_int(EVFLAG_NOSIGMASK); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 125, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_12 = PyTuple_New(2); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 125, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_2); + __Pyx_INCREF(__pyx_n_s_nosigmask); + __Pyx_GIVEREF(__pyx_n_s_nosigmask); + PyTuple_SET_ITEM(__pyx_t_12, 1, __pyx_n_s_nosigmask); + __pyx_t_2 = 0; + + __pyx_t_2 = PyList_New(10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 116, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_1); + PyList_SET_ITEM(__pyx_t_2, 0, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_4); + PyList_SET_ITEM(__pyx_t_2, 1, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + PyList_SET_ITEM(__pyx_t_2, 2, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_6); + PyList_SET_ITEM(__pyx_t_2, 3, __pyx_t_6); + __Pyx_GIVEREF(__pyx_t_7); + PyList_SET_ITEM(__pyx_t_2, 4, __pyx_t_7); + __Pyx_GIVEREF(__pyx_t_8); + PyList_SET_ITEM(__pyx_t_2, 5, __pyx_t_8); + __Pyx_GIVEREF(__pyx_t_9); + PyList_SET_ITEM(__pyx_t_2, 6, __pyx_t_9); + __Pyx_GIVEREF(__pyx_t_10); + PyList_SET_ITEM(__pyx_t_2, 7, __pyx_t_10); + __Pyx_GIVEREF(__pyx_t_11); + PyList_SET_ITEM(__pyx_t_2, 8, __pyx_t_11); + __Pyx_GIVEREF(__pyx_t_12); + PyList_SET_ITEM(__pyx_t_2, 9, __pyx_t_12); + __pyx_t_1 = 0; + __pyx_t_4 = 0; + __pyx_t_5 = 0; + __pyx_t_6 = 0; + __pyx_t_7 = 0; + __pyx_t_8 = 0; + __pyx_t_9 = 0; + __pyx_t_10 = 0; + __pyx_t_11 = 0; + __pyx_t_12 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_flags, __pyx_t_2) < 0) __PYX_ERR(0, 116, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + __pyx_t_2 = __pyx_pf_6gevent_5libev_8corecext_22genexpr(NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 128, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_12 = __Pyx_Generator_Next(__pyx_t_2); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 128, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_flags_str2int, __pyx_t_12) < 0) __PYX_ERR(0, 128, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + + __pyx_t_12 = __Pyx_PyInt_From_int(EV_READ); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_12); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_12); + __Pyx_INCREF(__pyx_n_s_READ); + __Pyx_GIVEREF(__pyx_n_s_READ); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_n_s_READ); + __pyx_t_12 = 0; + + __pyx_t_12 = __Pyx_PyInt_From_int(EV_WRITE); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 132, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_11 = PyTuple_New(2); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 132, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_GIVEREF(__pyx_t_12); + PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_12); + __Pyx_INCREF(__pyx_n_s_WRITE); + __Pyx_GIVEREF(__pyx_n_s_WRITE); + PyTuple_SET_ITEM(__pyx_t_11, 1, __pyx_n_s_WRITE); + __pyx_t_12 = 0; + + __pyx_t_12 = __Pyx_PyInt_From_int(EV__IOFDSET); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 133, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_10 = PyTuple_New(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 133, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_GIVEREF(__pyx_t_12); + PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_12); + __Pyx_INCREF(__pyx_n_s_IOFDSET); + __Pyx_GIVEREF(__pyx_n_s_IOFDSET); + PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_n_s_IOFDSET); + __pyx_t_12 = 0; + + __pyx_t_12 = __Pyx_PyInt_From_int(EV_PERIODIC); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 134, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_9 = PyTuple_New(2); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 134, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GIVEREF(__pyx_t_12); + PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_12); + __Pyx_INCREF(__pyx_n_s_PERIODIC); + __Pyx_GIVEREF(__pyx_n_s_PERIODIC); + PyTuple_SET_ITEM(__pyx_t_9, 1, __pyx_n_s_PERIODIC); + __pyx_t_12 = 0; + + __pyx_t_12 = __Pyx_PyInt_From_int(EV_SIGNAL); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 135, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 135, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_12); + PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_12); + __Pyx_INCREF(__pyx_n_s_SIGNAL); + __Pyx_GIVEREF(__pyx_n_s_SIGNAL); + PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_n_s_SIGNAL); + __pyx_t_12 = 0; + + __pyx_t_12 = __Pyx_PyInt_From_int(EV_CHILD); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_12); + PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_12); + __Pyx_INCREF(__pyx_n_s_CHILD); + __Pyx_GIVEREF(__pyx_n_s_CHILD); + PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_n_s_CHILD); + __pyx_t_12 = 0; + + __pyx_t_12 = __Pyx_PyInt_From_int(EV_STAT); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 137, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 137, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_12); + PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_12); + __Pyx_INCREF(__pyx_n_s_STAT); + __Pyx_GIVEREF(__pyx_n_s_STAT); + PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_n_s_STAT); + __pyx_t_12 = 0; + + __pyx_t_12 = __Pyx_PyInt_From_int(EV_IDLE); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_12); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_12); + __Pyx_INCREF(__pyx_n_s_IDLE); + __Pyx_GIVEREF(__pyx_n_s_IDLE); + PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_n_s_IDLE); + __pyx_t_12 = 0; + + __pyx_t_12 = __Pyx_PyInt_From_int(EV_PREPARE); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 139, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 139, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_12); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_12); + __Pyx_INCREF(__pyx_n_s_PREPARE); + __Pyx_GIVEREF(__pyx_n_s_PREPARE); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_n_s_PREPARE); + __pyx_t_12 = 0; + + __pyx_t_12 = __Pyx_PyInt_From_int(EV_CHECK); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 140, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 140, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_12); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_12); + __Pyx_INCREF(__pyx_n_s_CHECK); + __Pyx_GIVEREF(__pyx_n_s_CHECK); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_n_s_CHECK); + __pyx_t_12 = 0; + + __pyx_t_12 = __Pyx_PyInt_From_int(EV_EMBED); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 141, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_13 = PyTuple_New(2); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 141, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_GIVEREF(__pyx_t_12); + PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_12); + __Pyx_INCREF(__pyx_n_s_EMBED); + __Pyx_GIVEREF(__pyx_n_s_EMBED); + PyTuple_SET_ITEM(__pyx_t_13, 1, __pyx_n_s_EMBED); + __pyx_t_12 = 0; + + __pyx_t_12 = __Pyx_PyInt_From_int(EV_FORK); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 142, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_14 = PyTuple_New(2); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 142, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_14); + __Pyx_GIVEREF(__pyx_t_12); + PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_12); + __Pyx_INCREF(__pyx_n_s_FORK); + __Pyx_GIVEREF(__pyx_n_s_FORK); + PyTuple_SET_ITEM(__pyx_t_14, 1, __pyx_n_s_FORK); + __pyx_t_12 = 0; + + __pyx_t_12 = __Pyx_PyInt_From_int(EV_CLEANUP); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 143, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_15 = PyTuple_New(2); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 143, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + __Pyx_GIVEREF(__pyx_t_12); + PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_12); + __Pyx_INCREF(__pyx_n_s_CLEANUP); + __Pyx_GIVEREF(__pyx_n_s_CLEANUP); + PyTuple_SET_ITEM(__pyx_t_15, 1, __pyx_n_s_CLEANUP); + __pyx_t_12 = 0; + + __pyx_t_12 = __Pyx_PyInt_From_int(EV_ASYNC); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_16 = PyTuple_New(2); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_16); + __Pyx_GIVEREF(__pyx_t_12); + PyTuple_SET_ITEM(__pyx_t_16, 0, __pyx_t_12); + __Pyx_INCREF(__pyx_n_s_ASYNC); + __Pyx_GIVEREF(__pyx_n_s_ASYNC); + PyTuple_SET_ITEM(__pyx_t_16, 1, __pyx_n_s_ASYNC); + __pyx_t_12 = 0; + + __pyx_t_12 = __Pyx_PyInt_From_int(EV_CUSTOM); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 145, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_17 = PyTuple_New(2); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 145, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __Pyx_GIVEREF(__pyx_t_12); + PyTuple_SET_ITEM(__pyx_t_17, 0, __pyx_t_12); + __Pyx_INCREF(__pyx_n_s_CUSTOM); + __Pyx_GIVEREF(__pyx_n_s_CUSTOM); + PyTuple_SET_ITEM(__pyx_t_17, 1, __pyx_n_s_CUSTOM); + __pyx_t_12 = 0; + + __pyx_t_12 = __Pyx_PyInt_From_int(EV_ERROR); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_18 = PyTuple_New(2); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_18); + __Pyx_GIVEREF(__pyx_t_12); + PyTuple_SET_ITEM(__pyx_t_18, 0, __pyx_t_12); + __Pyx_INCREF(__pyx_n_s_ERROR); + __Pyx_GIVEREF(__pyx_n_s_ERROR); + PyTuple_SET_ITEM(__pyx_t_18, 1, __pyx_n_s_ERROR); + __pyx_t_12 = 0; + + __pyx_t_12 = PyList_New(16); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_GIVEREF(__pyx_t_2); + PyList_SET_ITEM(__pyx_t_12, 0, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_11); + PyList_SET_ITEM(__pyx_t_12, 1, __pyx_t_11); + __Pyx_GIVEREF(__pyx_t_10); + PyList_SET_ITEM(__pyx_t_12, 2, __pyx_t_10); + __Pyx_GIVEREF(__pyx_t_9); + PyList_SET_ITEM(__pyx_t_12, 3, __pyx_t_9); + __Pyx_GIVEREF(__pyx_t_8); + PyList_SET_ITEM(__pyx_t_12, 4, __pyx_t_8); + __Pyx_GIVEREF(__pyx_t_7); + PyList_SET_ITEM(__pyx_t_12, 5, __pyx_t_7); + __Pyx_GIVEREF(__pyx_t_6); + PyList_SET_ITEM(__pyx_t_12, 6, __pyx_t_6); + __Pyx_GIVEREF(__pyx_t_5); + PyList_SET_ITEM(__pyx_t_12, 7, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); + PyList_SET_ITEM(__pyx_t_12, 8, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_1); + PyList_SET_ITEM(__pyx_t_12, 9, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_13); + PyList_SET_ITEM(__pyx_t_12, 10, __pyx_t_13); + __Pyx_GIVEREF(__pyx_t_14); + PyList_SET_ITEM(__pyx_t_12, 11, __pyx_t_14); + __Pyx_GIVEREF(__pyx_t_15); + PyList_SET_ITEM(__pyx_t_12, 12, __pyx_t_15); + __Pyx_GIVEREF(__pyx_t_16); + PyList_SET_ITEM(__pyx_t_12, 13, __pyx_t_16); + __Pyx_GIVEREF(__pyx_t_17); + PyList_SET_ITEM(__pyx_t_12, 14, __pyx_t_17); + __Pyx_GIVEREF(__pyx_t_18); + PyList_SET_ITEM(__pyx_t_12, 15, __pyx_t_18); + __pyx_t_2 = 0; + __pyx_t_11 = 0; + __pyx_t_10 = 0; + __pyx_t_9 = 0; + __pyx_t_8 = 0; + __pyx_t_7 = 0; + __pyx_t_6 = 0; + __pyx_t_5 = 0; + __pyx_t_4 = 0; + __pyx_t_1 = 0; + __pyx_t_13 = 0; + __pyx_t_14 = 0; + __pyx_t_15 = 0; + __pyx_t_16 = 0; + __pyx_t_17 = 0; + __pyx_t_18 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_events, __pyx_t_12) < 0) __PYX_ERR(0, 131, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + + __pyx_t_12 = __Pyx_GetModuleGlobalName(__pyx_n_s_sys); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 162, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_t_12, __pyx_n_s_version_info); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 162, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_18); + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_t_12 = __Pyx_GetItemInt(__pyx_t_18, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 162, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + __pyx_t_18 = PyObject_RichCompare(__pyx_t_12, __pyx_int_3, Py_GE); __Pyx_XGOTREF(__pyx_t_18); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 162, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_18); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 162, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + if (__pyx_t_3) { + + __pyx_t_18 = PyTuple_New(2); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 163, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_18); + __Pyx_INCREF(((PyObject *)(&PyBytes_Type))); + __Pyx_GIVEREF(((PyObject *)(&PyBytes_Type))); + PyTuple_SET_ITEM(__pyx_t_18, 0, ((PyObject *)(&PyBytes_Type))); + __Pyx_INCREF(((PyObject *)(&PyString_Type))); + __Pyx_GIVEREF(((PyObject *)(&PyString_Type))); + PyTuple_SET_ITEM(__pyx_t_18, 1, ((PyObject *)(&PyString_Type))); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_basestring, __pyx_t_18) < 0) __PYX_ERR(0, 163, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + + goto __pyx_L3; + } + + /*else*/ { + __pyx_t_18 = __Pyx_GetModuleGlobalName(__pyx_n_s_builtins); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 165, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_18); + __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_18, __pyx_n_s_basestring); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 165, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_basestring, __pyx_t_12) < 0) __PYX_ERR(0, 165, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + } + __pyx_L3:; + + __pyx_t_12 = PyCFunction_NewEx(&__pyx_mdef_6gevent_5libev_8corecext_13supported_backends, NULL, __pyx_n_s_gevent_libev_corecext); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 220, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_supported_backends, __pyx_t_12) < 0) __PYX_ERR(0, 220, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + + __pyx_t_12 = PyCFunction_NewEx(&__pyx_mdef_6gevent_5libev_8corecext_15recommended_backends, NULL, __pyx_n_s_gevent_libev_corecext); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_recommended_backends, __pyx_t_12) < 0) __PYX_ERR(0, 224, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + + __pyx_t_12 = PyCFunction_NewEx(&__pyx_mdef_6gevent_5libev_8corecext_17embeddable_backends, NULL, __pyx_n_s_gevent_libev_corecext); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 228, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_embeddable_backends, __pyx_t_12) < 0) __PYX_ERR(0, 228, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + + __pyx_t_12 = PyCFunction_NewEx(&__pyx_mdef_6gevent_5libev_8corecext_19time, NULL, __pyx_n_s_gevent_libev_corecext); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_time, __pyx_t_12) < 0) __PYX_ERR(0, 232, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + + __pyx_v_6gevent_5libev_8corecext__default_loop_destroyed = 0; + + __pyx_k__9 = EVBREAK_ONE; + + if (PyDict_SetItem(__pyx_d, __pyx_n_s_SYSERR_CALLBACK, Py_None) < 0) __PYX_ERR(0, 2072, __pyx_L1_error) + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBEV_EMBED, Py_False) < 0) __PYX_ERR(0, 2109, __pyx_L1_error) +#endif /* (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBEV_EMBED, Py_True) < 0) __PYX_ERR(0, 2098, __pyx_L1_error) + + __pyx_t_12 = __Pyx_PyInt_From_int(EV_USE_FLOOR); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2099, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_EV_USE_FLOOR, __pyx_t_12) < 0) __PYX_ERR(0, 2099, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + + __pyx_t_12 = __Pyx_PyInt_From_int(EV_USE_CLOCK_SYSCALL); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2100, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_EV_USE_CLOCK_SYSCALL, __pyx_t_12) < 0) __PYX_ERR(0, 2100, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + + __pyx_t_12 = __Pyx_PyInt_From_int(EV_USE_REALTIME); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2101, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_EV_USE_REALTIME, __pyx_t_12) < 0) __PYX_ERR(0, 2101, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + + __pyx_t_12 = __Pyx_PyInt_From_int(EV_USE_MONOTONIC); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2102, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_EV_USE_MONOTONIC, __pyx_t_12) < 0) __PYX_ERR(0, 2102, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + + __pyx_t_12 = __Pyx_PyInt_From_int(EV_USE_NANOSLEEP); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2103, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_EV_USE_NANOSLEEP, __pyx_t_12) < 0) __PYX_ERR(0, 2103, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + + __pyx_t_12 = __Pyx_PyInt_From_int(EV_USE_INOTIFY); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2104, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_EV_USE_INOTIFY, __pyx_t_12) < 0) __PYX_ERR(0, 2104, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + + __pyx_t_12 = __Pyx_PyInt_From_int(EV_USE_SIGNALFD); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2105, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_EV_USE_SIGNALFD, __pyx_t_12) < 0) __PYX_ERR(0, 2105, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + + __pyx_t_12 = __Pyx_PyInt_From_int(EV_USE_EVENTFD); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2106, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_EV_USE_EVENTFD, __pyx_t_12) < 0) __PYX_ERR(0, 2106, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + + __pyx_t_12 = __Pyx_PyInt_From_int(EV_USE_4HEAP); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2107, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_EV_USE_4HEAP, __pyx_t_12) < 0) __PYX_ERR(0, 2107, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + + __pyx_t_12 = PyDict_New(); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_12) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + + /*--- Wrapped vars code ---*/ + + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_XDECREF(__pyx_t_13); + __Pyx_XDECREF(__pyx_t_14); + __Pyx_XDECREF(__pyx_t_15); + __Pyx_XDECREF(__pyx_t_16); + __Pyx_XDECREF(__pyx_t_17); + __Pyx_XDECREF(__pyx_t_18); + if (__pyx_m) { + if (__pyx_d) { + __Pyx_AddTraceback("init gevent.libev.corecext", __pyx_clineno, __pyx_lineno, __pyx_filename); + } + Py_DECREF(__pyx_m); __pyx_m = 0; + } else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_ImportError, "init gevent.libev.corecext"); + } + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + #if PY_MAJOR_VERSION < 3 + return; + #else + return __pyx_m; + #endif +} + +/* --- Runtime support code --- */ +/* Refnanny */ +#if CYTHON_REFNANNY +static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { + PyObject *m = NULL, *p = NULL; + void *r = NULL; + m = PyImport_ImportModule((char *)modname); + if (!m) goto end; + p = PyObject_GetAttrString(m, (char *)"RefNannyAPI"); + if (!p) goto end; + r = PyLong_AsVoidPtr(p); +end: + Py_XDECREF(p); + Py_XDECREF(m); + return (__Pyx_RefNannyAPIStruct *)r; +} +#endif + +/* GetBuiltinName */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name) { + PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); + if (unlikely(!result)) { + PyErr_Format(PyExc_NameError, +#if PY_MAJOR_VERSION >= 3 + "name '%U' is not defined", name); +#else + "name '%.200s' is not defined", PyString_AS_STRING(name)); +#endif + } + return result; +} + +/* GetModuleGlobalName */ +static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name) { + PyObject *result; +#if !CYTHON_AVOID_BORROWED_REFS + result = PyDict_GetItem(__pyx_d, name); + if (likely(result)) { + Py_INCREF(result); + } else { +#else + result = PyObject_GetItem(__pyx_d, name); + if (!result) { + PyErr_Clear(); +#endif + result = __Pyx_GetBuiltinName(name); + } + return result; +} + +/* RaiseTooManyValuesToUnpack */ + static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { + PyErr_Format(PyExc_ValueError, + "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); +} + +/* RaiseNeedMoreValuesToUnpack */ + static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { + PyErr_Format(PyExc_ValueError, + "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", + index, (index == 1) ? "" : "s"); +} + +/* IterFinish */ + static CYTHON_INLINE int __Pyx_IterFinish(void) { +#if CYTHON_FAST_THREAD_STATE + PyThreadState *tstate = PyThreadState_GET(); + PyObject* exc_type = tstate->curexc_type; + if (unlikely(exc_type)) { + if (likely(exc_type == PyExc_StopIteration) || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)) { + PyObject *exc_value, *exc_tb; + exc_value = tstate->curexc_value; + exc_tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; + Py_DECREF(exc_type); + Py_XDECREF(exc_value); + Py_XDECREF(exc_tb); + return 0; + } else { + return -1; + } + } + return 0; +#else + if (unlikely(PyErr_Occurred())) { + if (likely(PyErr_ExceptionMatches(PyExc_StopIteration))) { + PyErr_Clear(); + return 0; + } else { + return -1; + } + } + return 0; +#endif +} + +/* UnpackItemEndCheck */ + static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) { + if (unlikely(retval)) { + Py_DECREF(retval); + __Pyx_RaiseTooManyValuesError(expected); + return -1; + } else { + return __Pyx_IterFinish(); + } + return 0; +} + +/* PyObjectCall */ + #if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *result; + ternaryfunc call = func->ob_type->tp_call; + if (unlikely(!call)) + return PyObject_Call(func, arg, kw); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = (*call)(func, arg, kw); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* PyCFunctionFastCall */ + #if CYTHON_FAST_PYCCALL +static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) { + PyCFunctionObject *func = (PyCFunctionObject*)func_obj; + PyCFunction meth = PyCFunction_GET_FUNCTION(func); + PyObject *self = PyCFunction_GET_SELF(func); + assert(PyCFunction_Check(func)); + assert(METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST))); + assert(nargs >= 0); + assert(nargs == 0 || args != NULL); +/* _PyCFunction_FastCallDict() must not be called with an exception set, + because it may clear it (directly or indirectly) and so the + caller loses its exception */ + assert(!PyErr_Occurred()); + return (*((__Pyx_PyCFunctionFast)meth)) (self, args, nargs, NULL); +} +#endif // CYTHON_FAST_PYCCALL + +/* PyFunctionFastCall */ + #if CYTHON_FAST_PYCALL +#include "frameobject.h" +static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, + PyObject *globals) { + PyFrameObject *f; + PyThreadState *tstate = PyThreadState_GET(); + PyObject **fastlocals; + Py_ssize_t i; + PyObject *result; + assert(globals != NULL); +/* XXX Perhaps we should create a specialized + PyFrame_New() that doesn't take locals, but does + take builtins without sanity checking them. + */ + assert(tstate != NULL); + f = PyFrame_New(tstate, co, globals, NULL); + if (f == NULL) { + return NULL; + } + fastlocals = f->f_localsplus; + for (i = 0; i < na; i++) { + Py_INCREF(*args); + fastlocals[i] = *args++; + } + result = PyEval_EvalFrameEx(f,0); + ++tstate->recursion_depth; + Py_DECREF(f); + --tstate->recursion_depth; + return result; +} +#if 1 || PY_VERSION_HEX < 0x030600B1 +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, int nargs, PyObject *kwargs) { + PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); + PyObject *globals = PyFunction_GET_GLOBALS(func); + PyObject *argdefs = PyFunction_GET_DEFAULTS(func); + PyObject *closure; +#if PY_MAJOR_VERSION >= 3 + PyObject *kwdefs; +#endif + PyObject *kwtuple, **k; + PyObject **d; + Py_ssize_t nd; + Py_ssize_t nk; + PyObject *result; + assert(kwargs == NULL || PyDict_Check(kwargs)); + nk = kwargs ? PyDict_Size(kwargs) : 0; + if (Py_EnterRecursiveCall((char*)" while calling a Python object")) { + return NULL; + } + if ( +#if PY_MAJOR_VERSION >= 3 + co->co_kwonlyargcount == 0 && +#endif + likely(kwargs == NULL || nk == 0) && + co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { + if (argdefs == NULL && co->co_argcount == nargs) { + result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); + goto done; + } + else if (nargs == 0 && argdefs != NULL + && co->co_argcount == Py_SIZE(argdefs)) { +/* function called with no arguments, but all parameters have + a default value: use default values as arguments .*/ + args = &PyTuple_GET_ITEM(argdefs, 0); + result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); + goto done; + } + } + if (kwargs != NULL) { + Py_ssize_t pos, i; + kwtuple = PyTuple_New(2 * nk); + if (kwtuple == NULL) { + result = NULL; + goto done; + } + k = &PyTuple_GET_ITEM(kwtuple, 0); + pos = i = 0; + while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { + Py_INCREF(k[i]); + Py_INCREF(k[i+1]); + i += 2; + } + nk = i / 2; + } + else { + kwtuple = NULL; + k = NULL; + } + closure = PyFunction_GET_CLOSURE(func); +#if PY_MAJOR_VERSION >= 3 + kwdefs = PyFunction_GET_KW_DEFAULTS(func); +#endif + if (argdefs != NULL) { + d = &PyTuple_GET_ITEM(argdefs, 0); + nd = Py_SIZE(argdefs); + } + else { + d = NULL; + nd = 0; + } +#if PY_MAJOR_VERSION >= 3 + result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, + args, nargs, + k, (int)nk, + d, (int)nd, kwdefs, closure); +#else + result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, + args, nargs, + k, (int)nk, + d, (int)nd, closure); +#endif + Py_XDECREF(kwtuple); +done: + Py_LeaveRecursiveCall(); + return result; +} +#endif // CPython < 3.6 +#endif // CYTHON_FAST_PYCALL + +/* PyObjectCallMethO */ + #if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { + PyObject *self, *result; + PyCFunction cfunc; + cfunc = PyCFunction_GET_FUNCTION(func); + self = PyCFunction_GET_SELF(func); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = cfunc(self, arg); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* PyObjectCallOneArg */ + #if CYTHON_COMPILING_IN_CPYTHON +static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_New(1); + if (unlikely(!args)) return NULL; + Py_INCREF(arg); + PyTuple_SET_ITEM(args, 0, arg); + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { +#if CYTHON_FAST_PYCALL + if (PyFunction_Check(func)) { + return __Pyx_PyFunction_FastCall(func, &arg, 1); + } +#endif +#ifdef __Pyx_CyFunction_USED + if (likely(PyCFunction_Check(func) || PyObject_TypeCheck(func, __pyx_CyFunctionType))) { +#else + if (likely(PyCFunction_Check(func))) { +#endif + if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { + return __Pyx_PyObject_CallMethO(func, arg); +#if CYTHON_FAST_PYCCALL + } else if (PyCFunction_GET_FLAGS(func) & METH_FASTCALL) { + return __Pyx_PyCFunction_FastCall(func, &arg, 1); +#endif + } + } + return __Pyx__PyObject_CallOneArg(func, arg); +} +#else +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_Pack(1, arg); + if (unlikely(!args)) return NULL; + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +#endif + +/* PyObjectCallNoArg */ + #if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { +#if CYTHON_FAST_PYCALL + if (PyFunction_Check(func)) { + return __Pyx_PyFunction_FastCall(func, NULL, 0); + } +#endif +#ifdef __Pyx_CyFunction_USED + if (likely(PyCFunction_Check(func) || PyObject_TypeCheck(func, __pyx_CyFunctionType))) { +#else + if (likely(PyCFunction_Check(func))) { +#endif + if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) { + return __Pyx_PyObject_CallMethO(func, NULL); + } + } + return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL); +} +#endif + +/* SaveResetException */ + #if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + *type = tstate->exc_type; + *value = tstate->exc_value; + *tb = tstate->exc_traceback; + Py_XINCREF(*type); + Py_XINCREF(*value); + Py_XINCREF(*tb); +} +static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = type; + tstate->exc_value = value; + tstate->exc_traceback = tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +} +#endif + +/* PyErrExceptionMatches */ + #if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) { + PyObject *exc_type = tstate->curexc_type; + if (exc_type == err) return 1; + if (unlikely(!exc_type)) return 0; + return PyErr_GivenExceptionMatches(exc_type, err); +} +#endif + +/* GetException */ + #if CYTHON_FAST_THREAD_STATE +static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { +#else +static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) { +#endif + PyObject *local_type, *local_value, *local_tb; +#if CYTHON_FAST_THREAD_STATE + PyObject *tmp_type, *tmp_value, *tmp_tb; + local_type = tstate->curexc_type; + local_value = tstate->curexc_value; + local_tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +#else + PyErr_Fetch(&local_type, &local_value, &local_tb); +#endif + PyErr_NormalizeException(&local_type, &local_value, &local_tb); +#if CYTHON_FAST_THREAD_STATE + if (unlikely(tstate->curexc_type)) +#else + if (unlikely(PyErr_Occurred())) +#endif + goto bad; + #if PY_MAJOR_VERSION >= 3 + if (local_tb) { + if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) + goto bad; + } + #endif + Py_XINCREF(local_tb); + Py_XINCREF(local_type); + Py_XINCREF(local_value); + *type = local_type; + *value = local_value; + *tb = local_tb; +#if CYTHON_FAST_THREAD_STATE + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = local_type; + tstate->exc_value = local_value; + tstate->exc_traceback = local_tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +#else + PyErr_SetExcInfo(local_type, local_value, local_tb); +#endif + return 0; +bad: + *type = 0; + *value = 0; + *tb = 0; + Py_XDECREF(local_type); + Py_XDECREF(local_value); + Py_XDECREF(local_tb); + return -1; +} + +/* StringJoin */ + #if !CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyBytes_Join(PyObject* sep, PyObject* values) { + return PyObject_CallMethodObjArgs(sep, __pyx_n_s_join, values, NULL); +} +#endif + +/* PyErrFetchRestore */ + #if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + tmp_type = tstate->curexc_type; + tmp_value = tstate->curexc_value; + tmp_tb = tstate->curexc_traceback; + tstate->curexc_type = type; + tstate->curexc_value = value; + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +} +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + *type = tstate->curexc_type; + *value = tstate->curexc_value; + *tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +} +#endif + +/* RaiseException */ + #if PY_MAJOR_VERSION < 3 +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, + CYTHON_UNUSED PyObject *cause) { + __Pyx_PyThreadState_declare + Py_XINCREF(type); + if (!value || value == Py_None) + value = NULL; + else + Py_INCREF(value); + if (!tb || tb == Py_None) + tb = NULL; + else { + Py_INCREF(tb); + if (!PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto raise_error; + } + } + if (PyType_Check(type)) { +#if CYTHON_COMPILING_IN_PYPY + if (!value) { + Py_INCREF(Py_None); + value = Py_None; + } +#endif + PyErr_NormalizeException(&type, &value, &tb); + } else { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto raise_error; + } + value = type; + type = (PyObject*) Py_TYPE(type); + Py_INCREF(type); + if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto raise_error; + } + } + __Pyx_PyThreadState_assign + __Pyx_ErrRestore(type, value, tb); + return; +raise_error: + Py_XDECREF(value); + Py_XDECREF(type); + Py_XDECREF(tb); + return; +} +#else +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { + PyObject* owned_instance = NULL; + if (tb == Py_None) { + tb = 0; + } else if (tb && !PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto bad; + } + if (value == Py_None) + value = 0; + if (PyExceptionInstance_Check(type)) { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto bad; + } + value = type; + type = (PyObject*) Py_TYPE(value); + } else if (PyExceptionClass_Check(type)) { + PyObject *instance_class = NULL; + if (value && PyExceptionInstance_Check(value)) { + instance_class = (PyObject*) Py_TYPE(value); + if (instance_class != type) { + int is_subclass = PyObject_IsSubclass(instance_class, type); + if (!is_subclass) { + instance_class = NULL; + } else if (unlikely(is_subclass == -1)) { + goto bad; + } else { + type = instance_class; + } + } + } + if (!instance_class) { + PyObject *args; + if (!value) + args = PyTuple_New(0); + else if (PyTuple_Check(value)) { + Py_INCREF(value); + args = value; + } else + args = PyTuple_Pack(1, value); + if (!args) + goto bad; + owned_instance = PyObject_Call(type, args, NULL); + Py_DECREF(args); + if (!owned_instance) + goto bad; + value = owned_instance; + if (!PyExceptionInstance_Check(value)) { + PyErr_Format(PyExc_TypeError, + "calling %R should have returned an instance of " + "BaseException, not %R", + type, Py_TYPE(value)); + goto bad; + } + } + } else { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto bad; + } +#if PY_VERSION_HEX >= 0x03030000 + if (cause) { +#else + if (cause && cause != Py_None) { +#endif + PyObject *fixed_cause; + if (cause == Py_None) { + fixed_cause = NULL; + } else if (PyExceptionClass_Check(cause)) { + fixed_cause = PyObject_CallObject(cause, NULL); + if (fixed_cause == NULL) + goto bad; + } else if (PyExceptionInstance_Check(cause)) { + fixed_cause = cause; + Py_INCREF(fixed_cause); + } else { + PyErr_SetString(PyExc_TypeError, + "exception causes must derive from " + "BaseException"); + goto bad; + } + PyException_SetCause(value, fixed_cause); + } + PyErr_SetObject(type, value); + if (tb) { +#if CYTHON_COMPILING_IN_PYPY + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); + Py_INCREF(tb); + PyErr_Restore(tmp_type, tmp_value, tb); + Py_XDECREF(tmp_tb); +#else + PyThreadState *tstate = PyThreadState_GET(); + PyObject* tmp_tb = tstate->curexc_traceback; + if (tb != tmp_tb) { + Py_INCREF(tb); + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_tb); + } +#endif + } +bad: + Py_XDECREF(owned_instance); + return; +} +#endif + +/* RaiseDoubleKeywords */ + static void __Pyx_RaiseDoubleKeywordsError( + const char* func_name, + PyObject* kw_name) +{ + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION >= 3 + "%s() got multiple values for keyword argument '%U'", func_name, kw_name); + #else + "%s() got multiple values for keyword argument '%s'", func_name, + PyString_AsString(kw_name)); + #endif +} + +/* ParseKeywords */ + static int __Pyx_ParseOptionalKeywords( + PyObject *kwds, + PyObject **argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + const char* function_name) +{ + PyObject *key = 0, *value = 0; + Py_ssize_t pos = 0; + PyObject*** name; + PyObject*** first_kw_arg = argnames + num_pos_args; + while (PyDict_Next(kwds, &pos, &key, &value)) { + name = first_kw_arg; + while (*name && (**name != key)) name++; + if (*name) { + values[name-argnames] = value; + continue; + } + name = first_kw_arg; + #if PY_MAJOR_VERSION < 3 + if (likely(PyString_CheckExact(key)) || likely(PyString_Check(key))) { + while (*name) { + if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) + && _PyString_Eq(**name, key)) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + if ((**argname == key) || ( + (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) + && _PyString_Eq(**argname, key))) { + goto arg_passed_twice; + } + argname++; + } + } + } else + #endif + if (likely(PyUnicode_Check(key))) { + while (*name) { + int cmp = (**name == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (PyUnicode_GET_SIZE(**name) != PyUnicode_GET_SIZE(key)) ? 1 : + #endif + PyUnicode_Compare(**name, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + int cmp = (**argname == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (PyUnicode_GET_SIZE(**argname) != PyUnicode_GET_SIZE(key)) ? 1 : + #endif + PyUnicode_Compare(**argname, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) goto arg_passed_twice; + argname++; + } + } + } else + goto invalid_keyword_type; + if (kwds2) { + if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; + } else { + goto invalid_keyword; + } + } + return 0; +arg_passed_twice: + __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; +invalid_keyword_type: + PyErr_Format(PyExc_TypeError, + "%.200s() keywords must be strings", function_name); + goto bad; +invalid_keyword: + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION < 3 + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif +bad: + return -1; +} + +/* RaiseArgTupleInvalid */ + static void __Pyx_RaiseArgtupleInvalid( + const char* func_name, + int exact, + Py_ssize_t num_min, + Py_ssize_t num_max, + Py_ssize_t num_found) +{ + Py_ssize_t num_expected; + const char *more_or_less; + if (num_found < num_min) { + num_expected = num_min; + more_or_less = "at least"; + } else { + num_expected = num_max; + more_or_less = "at most"; + } + if (exact) { + more_or_less = "exactly"; + } + PyErr_Format(PyExc_TypeError, + "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", + func_name, more_or_less, num_expected, + (num_expected == 1) ? "" : "s", num_found); +} + +/* ExtTypeTest */ + static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + if (likely(PyObject_TypeCheck(obj, type))) + return 1; + PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s", + Py_TYPE(obj)->tp_name, type->tp_name); + return 0; +} + +/* WriteUnraisableException */ + static void __Pyx_WriteUnraisable(const char *name, CYTHON_UNUSED int clineno, + CYTHON_UNUSED int lineno, CYTHON_UNUSED const char *filename, + int full_traceback, CYTHON_UNUSED int nogil) { + PyObject *old_exc, *old_val, *old_tb; + PyObject *ctx; + __Pyx_PyThreadState_declare +#ifdef WITH_THREAD + PyGILState_STATE state; + if (nogil) + state = PyGILState_Ensure(); +#ifdef _MSC_VER + else state = (PyGILState_STATE)-1; +#endif +#endif + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&old_exc, &old_val, &old_tb); + if (full_traceback) { + Py_XINCREF(old_exc); + Py_XINCREF(old_val); + Py_XINCREF(old_tb); + __Pyx_ErrRestore(old_exc, old_val, old_tb); + PyErr_PrintEx(1); + } + #if PY_MAJOR_VERSION < 3 + ctx = PyString_FromString(name); + #else + ctx = PyUnicode_FromString(name); + #endif + __Pyx_ErrRestore(old_exc, old_val, old_tb); + if (!ctx) { + PyErr_WriteUnraisable(Py_None); + } else { + PyErr_WriteUnraisable(ctx); + Py_DECREF(ctx); + } +#ifdef WITH_THREAD + if (nogil) + PyGILState_Release(state); +#endif +} + +/* GetItemInt */ + static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { + PyObject *r; + if (!j) return NULL; + r = PyObject_GetItem(o, j); + Py_DECREF(j); + return r; +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (wraparound & unlikely(i < 0)) i += PyList_GET_SIZE(o); + if ((!boundscheck) || likely((0 <= i) & (i < PyList_GET_SIZE(o)))) { + PyObject *r = PyList_GET_ITEM(o, i); + Py_INCREF(r); + return r; + } + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +#else + return PySequence_GetItem(o, i); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (wraparound & unlikely(i < 0)) i += PyTuple_GET_SIZE(o); + if ((!boundscheck) || likely((0 <= i) & (i < PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, i); + Py_INCREF(r); + return r; + } + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +#else + return PySequence_GetItem(o, i); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS + if (is_list || PyList_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); + if ((!boundscheck) || (likely((n >= 0) & (n < PyList_GET_SIZE(o))))) { + PyObject *r = PyList_GET_ITEM(o, n); + Py_INCREF(r); + return r; + } + } + else if (PyTuple_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); + if ((!boundscheck) || likely((n >= 0) & (n < PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, n); + Py_INCREF(r); + return r; + } + } else { + PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; + if (likely(m && m->sq_item)) { + if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { + Py_ssize_t l = m->sq_length(o); + if (likely(l >= 0)) { + i += l; + } else { + if (!PyErr_ExceptionMatches(PyExc_OverflowError)) + return NULL; + PyErr_Clear(); + } + } + return m->sq_item(o, i); + } + } +#else + if (is_list || PySequence_Check(o)) { + return PySequence_GetItem(o, i); + } +#endif + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +} + +/* GetAttr */ + static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *o, PyObject *n) { +#if CYTHON_COMPILING_IN_CPYTHON +#if PY_MAJOR_VERSION >= 3 + if (likely(PyUnicode_Check(n))) +#else + if (likely(PyString_Check(n))) +#endif + return __Pyx_PyObject_GetAttrStr(o, n); +#endif + return PyObject_GetAttr(o, n); +} + +/* GetAttr3 */ + static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *o, PyObject *n, PyObject *d) { + PyObject *r = __Pyx_GetAttr(o, n); + if (unlikely(!r)) { + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) + goto bad; + PyErr_Clear(); + r = d; + Py_INCREF(d); + } + return r; +bad: + return NULL; +} + +/* ArgTypeTest */ + static void __Pyx_RaiseArgumentTypeInvalid(const char* name, PyObject *obj, PyTypeObject *type) { + PyErr_Format(PyExc_TypeError, + "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", + name, type->tp_name, Py_TYPE(obj)->tp_name); +} +static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed, + const char *name, int exact) +{ + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + if (none_allowed && obj == Py_None) return 1; + else if (exact) { + if (likely(Py_TYPE(obj) == type)) return 1; + #if PY_MAJOR_VERSION == 2 + else if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1; + #endif + } + else { + if (likely(PyObject_TypeCheck(obj, type))) return 1; + } + __Pyx_RaiseArgumentTypeInvalid(name, obj, type); + return 0; +} + +/* SwapException */ + #if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = *type; + tstate->exc_value = *value; + tstate->exc_traceback = *tb; + *type = tmp_type; + *value = tmp_value; + *tb = tmp_tb; +} +#else +static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_GetExcInfo(&tmp_type, &tmp_value, &tmp_tb); + PyErr_SetExcInfo(*type, *value, *tb); + *type = tmp_type; + *value = tmp_value; + *tb = tmp_tb; +} +#endif + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) +/* KeywordStringCheck */ + static CYTHON_INLINE int __Pyx_CheckKeywordStrings( + PyObject *kwdict, + const char* function_name, + int kw_allowed) +{ + PyObject* key = 0; + Py_ssize_t pos = 0; +#if CYTHON_COMPILING_IN_PYPY + if (!kw_allowed && PyDict_Next(kwdict, &pos, &key, 0)) + goto invalid_keyword; + return 1; +#else + while (PyDict_Next(kwdict, &pos, &key, 0)) { + #if PY_MAJOR_VERSION < 3 + if (unlikely(!PyString_CheckExact(key)) && unlikely(!PyString_Check(key))) + #endif + if (unlikely(!PyUnicode_Check(key))) + goto invalid_keyword_type; + } + if ((!kw_allowed) && unlikely(key)) + goto invalid_keyword; + return 1; +invalid_keyword_type: + PyErr_Format(PyExc_TypeError, + "%.200s() keywords must be strings", function_name); + return 0; +#endif +invalid_keyword: + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION < 3 + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif + return 0; +} + +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) +/* CallNextTpTraverse */ + static int __Pyx_call_next_tp_traverse(PyObject* obj, visitproc v, void *a, traverseproc current_tp_traverse) { + PyTypeObject* type = Py_TYPE(obj); + while (type && type->tp_traverse != current_tp_traverse) + type = type->tp_base; + while (type && type->tp_traverse == current_tp_traverse) + type = type->tp_base; + if (type && type->tp_traverse) + return type->tp_traverse(obj, v, a); + return 0; +} + +/* CallNextTpClear */ + static void __Pyx_call_next_tp_clear(PyObject* obj, inquiry current_tp_clear) { + PyTypeObject* type = Py_TYPE(obj); + while (type && type->tp_clear != current_tp_clear) + type = type->tp_base; + while (type && type->tp_clear == current_tp_clear) + type = type->tp_base; + if (type && type->tp_clear) + type->tp_clear(obj); +} + +/* SetVTable */ + static int __Pyx_SetVtable(PyObject *dict, void *vtable) { +#if PY_VERSION_HEX >= 0x02070000 + PyObject *ob = PyCapsule_New(vtable, 0, 0); +#else + PyObject *ob = PyCObject_FromVoidPtr(vtable, 0); +#endif + if (!ob) + goto bad; + if (PyDict_SetItem(dict, __pyx_n_s_pyx_vtable, ob) < 0) + goto bad; + Py_DECREF(ob); + return 0; +bad: + Py_XDECREF(ob); + return -1; +} + +/* CodeObjectCache */ + static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { + int start = 0, mid = 0, end = count - 1; + if (end >= 0 && code_line > entries[end].code_line) { + return count; + } + while (start < end) { + mid = start + (end - start) / 2; + if (code_line < entries[mid].code_line) { + end = mid; + } else if (code_line > entries[mid].code_line) { + start = mid + 1; + } else { + return mid; + } + } + if (code_line <= entries[mid].code_line) { + return mid; + } else { + return mid + 1; + } +} +static PyCodeObject *__pyx_find_code_object(int code_line) { + PyCodeObject* code_object; + int pos; + if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { + return NULL; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { + return NULL; + } + code_object = __pyx_code_cache.entries[pos].code_object; + Py_INCREF(code_object); + return code_object; +} +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { + int pos, i; + __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; + if (unlikely(!code_line)) { + return; + } + if (unlikely(!entries)) { + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); + if (likely(entries)) { + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = 64; + __pyx_code_cache.count = 1; + entries[0].code_line = code_line; + entries[0].code_object = code_object; + Py_INCREF(code_object); + } + return; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { + PyCodeObject* tmp = entries[pos].code_object; + entries[pos].code_object = code_object; + Py_DECREF(tmp); + return; + } + if (__pyx_code_cache.count == __pyx_code_cache.max_count) { + int new_max = __pyx_code_cache.max_count + 64; + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( + __pyx_code_cache.entries, (size_t)new_max*sizeof(__Pyx_CodeObjectCacheEntry)); + if (unlikely(!entries)) { + return; + } + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = new_max; + } + for (i=__pyx_code_cache.count; i>pos; i--) { + entries[i] = entries[i-1]; + } + entries[pos].code_line = code_line; + entries[pos].code_object = code_object; + __pyx_code_cache.count++; + Py_INCREF(code_object); +} + +/* AddTraceback */ + #include "compile.h" +#include "frameobject.h" +#include "traceback.h" +static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( + const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyObject *py_srcfile = 0; + PyObject *py_funcname = 0; + #if PY_MAJOR_VERSION < 3 + py_srcfile = PyString_FromString(filename); + #else + py_srcfile = PyUnicode_FromString(filename); + #endif + if (!py_srcfile) goto bad; + if (c_line) { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #else + py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #endif + } + else { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromString(funcname); + #else + py_funcname = PyUnicode_FromString(funcname); + #endif + } + if (!py_funcname) goto bad; + py_code = __Pyx_PyCode_New( + 0, + 0, + 0, + 0, + 0, + __pyx_empty_bytes, /*PyObject *code,*/ + __pyx_empty_tuple, /*PyObject *consts,*/ + __pyx_empty_tuple, /*PyObject *names,*/ + __pyx_empty_tuple, /*PyObject *varnames,*/ + __pyx_empty_tuple, /*PyObject *freevars,*/ + __pyx_empty_tuple, /*PyObject *cellvars,*/ + py_srcfile, /*PyObject *filename,*/ + py_funcname, /*PyObject *name,*/ + py_line, + __pyx_empty_bytes /*PyObject *lnotab*/ + ); + Py_DECREF(py_srcfile); + Py_DECREF(py_funcname); + return py_code; +bad: + Py_XDECREF(py_srcfile); + Py_XDECREF(py_funcname); + return NULL; +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyFrameObject *py_frame = 0; + py_code = __pyx_find_code_object(c_line ? c_line : py_line); + if (!py_code) { + py_code = __Pyx_CreateCodeObjectForTraceback( + funcname, c_line, py_line, filename); + if (!py_code) goto bad; + __pyx_insert_code_object(c_line ? c_line : py_line, py_code); + } + py_frame = PyFrame_New( + PyThreadState_GET(), /*PyThreadState *tstate,*/ + py_code, /*PyCodeObject *code,*/ + __pyx_d, /*PyObject *globals,*/ + 0 /*PyObject *locals*/ + ); + if (!py_frame) goto bad; + __Pyx_PyFrame_SetLineNumber(py_frame, py_line); + PyTraceBack_Here(py_frame); +bad: + Py_XDECREF(py_code); + Py_XDECREF(py_frame); +} + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { + const long neg_one = (long) -1, const_zero = (long) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(long) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(long) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(long) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(long), + little, !is_unsigned); + } +} + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { + const int neg_one = (int) -1, const_zero = (int) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(int) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(int) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(int) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(int), + little, !is_unsigned); + } +} + +/* CIntFromPyVerify */ + #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) +#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) +#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ + {\ + func_type value = func_value;\ + if (sizeof(target_type) < sizeof(func_type)) {\ + if (unlikely(value != (func_type) (target_type) value)) {\ + func_type zero = 0;\ + if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ + return (target_type) -1;\ + if (is_unsigned && unlikely(value < zero))\ + goto raise_neg_overflow;\ + else\ + goto raise_overflow;\ + }\ + }\ + return (target_type) value;\ + } + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_int(unsigned int value) { + const unsigned int neg_one = (unsigned int) -1, const_zero = (unsigned int) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(unsigned int) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(unsigned int) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(unsigned int) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(unsigned int) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(unsigned int) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(unsigned int), +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + little, !is_unsigned); + } +} + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_vfd_socket_t(vfd_socket_t value) { + const vfd_socket_t neg_one = (vfd_socket_t) -1, const_zero = (vfd_socket_t) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(vfd_socket_t) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(vfd_socket_t) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(vfd_socket_t) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(vfd_socket_t) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(vfd_socket_t) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(vfd_socket_t), +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + little, !is_unsigned); + } +} + +/* CIntFromPy */ + static CYTHON_INLINE unsigned int __Pyx_PyInt_As_unsigned_int(PyObject *x) { + const unsigned int neg_one = (unsigned int) -1, const_zero = (unsigned int) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(unsigned int) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(unsigned int, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (unsigned int) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (unsigned int) 0; + case 1: __PYX_VERIFY_RETURN_INT(unsigned int, digit, digits[0]) + case 2: + if (8 * sizeof(unsigned int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(unsigned int) >= 2 * PyLong_SHIFT) { + return (unsigned int) (((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(unsigned int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(unsigned int) >= 3 * PyLong_SHIFT) { + return (unsigned int) (((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(unsigned int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(unsigned int) >= 4 * PyLong_SHIFT) { + return (unsigned int) (((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (unsigned int) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(unsigned int) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(unsigned int, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(unsigned int) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(unsigned int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (unsigned int) 0; + case -1: __PYX_VERIFY_RETURN_INT(unsigned int, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(unsigned int, digit, +digits[0]) + case -2: + if (8 * sizeof(unsigned int) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT) { + return (unsigned int) (((unsigned int)-1)*(((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(unsigned int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT) { + return (unsigned int) ((((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT) { + return (unsigned int) (((unsigned int)-1)*(((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(unsigned int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT) { + return (unsigned int) ((((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(unsigned int) - 1 > 4 * PyLong_SHIFT) { + return (unsigned int) (((unsigned int)-1)*(((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(unsigned int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(unsigned int) - 1 > 4 * PyLong_SHIFT) { + return (unsigned int) ((((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); + } + } + break; + } +#endif + if (sizeof(unsigned int) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(unsigned int, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(unsigned int) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(unsigned int, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + unsigned int val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (unsigned int) -1; + } + } else { + unsigned int val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (unsigned int) -1; + val = __Pyx_PyInt_As_unsigned_int(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to unsigned int"); + return (unsigned int) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to unsigned int"); + return (unsigned int) -1; +} + +/* CIntFromPy */ + static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { + const int neg_one = (int) -1, const_zero = (int) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(int) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (int) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { + return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { + return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { + return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(int) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) + case -2: + if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + } +#endif + if (sizeof(int) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + int val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (int) -1; + } + } else { + int val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (int) -1; + val = __Pyx_PyInt_As_int(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to int"); + return (int) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to int"); + return (int) -1; +} + +/* CIntFromPy */ + static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *x) { + const size_t neg_one = (size_t) -1, const_zero = (size_t) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(size_t) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(size_t, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (size_t) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (size_t) 0; + case 1: __PYX_VERIFY_RETURN_INT(size_t, digit, digits[0]) + case 2: + if (8 * sizeof(size_t) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(size_t) >= 2 * PyLong_SHIFT) { + return (size_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(size_t) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(size_t) >= 3 * PyLong_SHIFT) { + return (size_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(size_t) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(size_t) >= 4 * PyLong_SHIFT) { + return (size_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (size_t) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(size_t) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(size_t) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (size_t) 0; + case -1: __PYX_VERIFY_RETURN_INT(size_t, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(size_t, digit, +digits[0]) + case -2: + if (8 * sizeof(size_t) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) { + return (size_t) (((size_t)-1)*(((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(size_t) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) { + return (size_t) ((((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) { + return (size_t) (((size_t)-1)*(((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(size_t) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) { + return (size_t) ((((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT) { + return (size_t) (((size_t)-1)*(((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(size_t) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT) { + return (size_t) ((((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); + } + } + break; + } +#endif + if (sizeof(size_t) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(size_t, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(size_t) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(size_t, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + size_t val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (size_t) -1; + } + } else { + size_t val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (size_t) -1; + val = __Pyx_PyInt_As_size_t(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to size_t"); + return (size_t) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to size_t"); + return (size_t) -1; +} + +/* CIntFromPy */ +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) + static CYTHON_INLINE vfd_socket_t __Pyx_PyInt_As_vfd_socket_t(PyObject *x) { + const vfd_socket_t neg_one = (vfd_socket_t) -1, const_zero = (vfd_socket_t) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(vfd_socket_t) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(vfd_socket_t, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (vfd_socket_t) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (vfd_socket_t) 0; + case 1: __PYX_VERIFY_RETURN_INT(vfd_socket_t, digit, digits[0]) + case 2: + if (8 * sizeof(vfd_socket_t) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(vfd_socket_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(vfd_socket_t) >= 2 * PyLong_SHIFT) { + return (vfd_socket_t) (((((vfd_socket_t)digits[1]) << PyLong_SHIFT) | (vfd_socket_t)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(vfd_socket_t) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(vfd_socket_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(vfd_socket_t) >= 3 * PyLong_SHIFT) { + return (vfd_socket_t) (((((((vfd_socket_t)digits[2]) << PyLong_SHIFT) | (vfd_socket_t)digits[1]) << PyLong_SHIFT) | (vfd_socket_t)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(vfd_socket_t) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(vfd_socket_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(vfd_socket_t) >= 4 * PyLong_SHIFT) { + return (vfd_socket_t) (((((((((vfd_socket_t)digits[3]) << PyLong_SHIFT) | (vfd_socket_t)digits[2]) << PyLong_SHIFT) | (vfd_socket_t)digits[1]) << PyLong_SHIFT) | (vfd_socket_t)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (vfd_socket_t) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(vfd_socket_t) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(vfd_socket_t, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(vfd_socket_t) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(vfd_socket_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (vfd_socket_t) 0; + case -1: __PYX_VERIFY_RETURN_INT(vfd_socket_t, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(vfd_socket_t, digit, +digits[0]) + case -2: + if (8 * sizeof(vfd_socket_t) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(vfd_socket_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(vfd_socket_t) - 1 > 2 * PyLong_SHIFT) { + return (vfd_socket_t) (((vfd_socket_t)-1)*(((((vfd_socket_t)digits[1]) << PyLong_SHIFT) | (vfd_socket_t)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(vfd_socket_t) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(vfd_socket_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(vfd_socket_t) - 1 > 2 * PyLong_SHIFT) { + return (vfd_socket_t) ((((((vfd_socket_t)digits[1]) << PyLong_SHIFT) | (vfd_socket_t)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(vfd_socket_t) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(vfd_socket_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(vfd_socket_t) - 1 > 3 * PyLong_SHIFT) { + return (vfd_socket_t) (((vfd_socket_t)-1)*(((((((vfd_socket_t)digits[2]) << PyLong_SHIFT) | (vfd_socket_t)digits[1]) << PyLong_SHIFT) | (vfd_socket_t)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(vfd_socket_t) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(vfd_socket_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(vfd_socket_t) - 1 > 3 * PyLong_SHIFT) { + return (vfd_socket_t) ((((((((vfd_socket_t)digits[2]) << PyLong_SHIFT) | (vfd_socket_t)digits[1]) << PyLong_SHIFT) | (vfd_socket_t)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(vfd_socket_t) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(vfd_socket_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(vfd_socket_t) - 1 > 4 * PyLong_SHIFT) { + return (vfd_socket_t) (((vfd_socket_t)-1)*(((((((((vfd_socket_t)digits[3]) << PyLong_SHIFT) | (vfd_socket_t)digits[2]) << PyLong_SHIFT) | (vfd_socket_t)digits[1]) << PyLong_SHIFT) | (vfd_socket_t)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(vfd_socket_t) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(vfd_socket_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(vfd_socket_t) - 1 > 4 * PyLong_SHIFT) { + return (vfd_socket_t) ((((((((((vfd_socket_t)digits[3]) << PyLong_SHIFT) | (vfd_socket_t)digits[2]) << PyLong_SHIFT) | (vfd_socket_t)digits[1]) << PyLong_SHIFT) | (vfd_socket_t)digits[0]))); + } + } + break; + } +#endif + if (sizeof(vfd_socket_t) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(vfd_socket_t, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(vfd_socket_t) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(vfd_socket_t, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + vfd_socket_t val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (vfd_socket_t) -1; + } + } else { + vfd_socket_t val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (vfd_socket_t) -1; + val = __Pyx_PyInt_As_vfd_socket_t(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to vfd_socket_t"); + return (vfd_socket_t) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to vfd_socket_t"); + return (vfd_socket_t) -1; +} + +/* CIntFromPy */ +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) */ +#if (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) + static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { + const long neg_one = (long) -1, const_zero = (long) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(long) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (long) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { + return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { + return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { + return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (long) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(long) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) + case -2: + if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + } +#endif + if (sizeof(long) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + long val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (long) -1; + } + } else { + long val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (long) -1; + val = __Pyx_PyInt_As_long(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to long"); + return (long) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to long"); + return (long) -1; +} + +/* FetchCommonType */ + static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) { + PyObject* fake_module; + PyTypeObject* cached_type = NULL; + fake_module = PyImport_AddModule((char*) "_cython_" CYTHON_ABI); + if (!fake_module) return NULL; + Py_INCREF(fake_module); + cached_type = (PyTypeObject*) PyObject_GetAttrString(fake_module, type->tp_name); + if (cached_type) { + if (!PyType_Check((PyObject*)cached_type)) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s is not a type object", + type->tp_name); + goto bad; + } + if (cached_type->tp_basicsize != type->tp_basicsize) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s has the wrong size, try recompiling", + type->tp_name); + goto bad; + } + } else { + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; + PyErr_Clear(); + if (PyType_Ready(type) < 0) goto bad; + if (PyObject_SetAttrString(fake_module, type->tp_name, (PyObject*) type) < 0) + goto bad; + Py_INCREF(type); + cached_type = type; + } +done: + Py_DECREF(fake_module); + return cached_type; +bad: + Py_XDECREF(cached_type); + cached_type = NULL; + goto done; +} + +/* PyObjectCallMethod1 */ + static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg) { + PyObject *method, *result = NULL; + method = __Pyx_PyObject_GetAttrStr(obj, method_name); + if (unlikely(!method)) goto done; +#if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(method))) { + PyObject *self = PyMethod_GET_SELF(method); + if (likely(self)) { + PyObject *args; + PyObject *function = PyMethod_GET_FUNCTION(method); + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(function)) { + PyObject *args[2] = {self, arg}; + result = __Pyx_PyFunction_FastCall(function, args, 2); + goto done; + } + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(function)) { + PyObject *args[2] = {self, arg}; + result = __Pyx_PyCFunction_FastCall(function, args, 2); + goto done; + } + #endif + args = PyTuple_New(2); + if (unlikely(!args)) goto done; + Py_INCREF(self); + PyTuple_SET_ITEM(args, 0, self); + Py_INCREF(arg); + PyTuple_SET_ITEM(args, 1, arg); + Py_INCREF(function); + Py_DECREF(method); method = NULL; + result = __Pyx_PyObject_Call(function, args, NULL); + Py_DECREF(args); + Py_DECREF(function); + return result; + } + } +#endif + result = __Pyx_PyObject_CallOneArg(method, arg); +done: + Py_XDECREF(method); + return result; +} + +/* CoroutineBase */ + #include +#include +static PyObject *__Pyx_Coroutine_Send(PyObject *self, PyObject *value); +static PyObject *__Pyx_Coroutine_Close(PyObject *self); +static PyObject *__Pyx_Coroutine_Throw(PyObject *gen, PyObject *args); +#define __Pyx_Coroutine_Undelegate(gen) Py_CLEAR((gen)->yieldfrom) +#if 1 || PY_VERSION_HEX < 0x030300B0 +static int __Pyx_PyGen_FetchStopIterationValue(PyObject **pvalue) { + PyObject *et, *ev, *tb; + PyObject *value = NULL; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&et, &ev, &tb); + if (!et) { + Py_XDECREF(tb); + Py_XDECREF(ev); + Py_INCREF(Py_None); + *pvalue = Py_None; + return 0; + } + if (likely(et == PyExc_StopIteration)) { + if (!ev) { + Py_INCREF(Py_None); + value = Py_None; + } +#if PY_VERSION_HEX >= 0x030300A0 + else if (Py_TYPE(ev) == (PyTypeObject*)PyExc_StopIteration) { + value = ((PyStopIterationObject *)ev)->value; + Py_INCREF(value); + Py_DECREF(ev); + } +#endif + else if (unlikely(PyTuple_Check(ev))) { + if (PyTuple_GET_SIZE(ev) >= 1) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + value = PyTuple_GET_ITEM(ev, 0); + Py_INCREF(value); +#else + value = PySequence_ITEM(ev, 0); +#endif + } else { + Py_INCREF(Py_None); + value = Py_None; + } + Py_DECREF(ev); + } + else if (!PyObject_TypeCheck(ev, (PyTypeObject*)PyExc_StopIteration)) { + value = ev; + } + if (likely(value)) { + Py_XDECREF(tb); + Py_DECREF(et); + *pvalue = value; + return 0; + } + } else if (!PyErr_GivenExceptionMatches(et, PyExc_StopIteration)) { + __Pyx_ErrRestore(et, ev, tb); + return -1; + } + PyErr_NormalizeException(&et, &ev, &tb); + if (unlikely(!PyObject_TypeCheck(ev, (PyTypeObject*)PyExc_StopIteration))) { + __Pyx_ErrRestore(et, ev, tb); + return -1; + } + Py_XDECREF(tb); + Py_DECREF(et); +#if PY_VERSION_HEX >= 0x030300A0 + value = ((PyStopIterationObject *)ev)->value; + Py_INCREF(value); + Py_DECREF(ev); +#else + { + PyObject* args = __Pyx_PyObject_GetAttrStr(ev, __pyx_n_s_args); + Py_DECREF(ev); + if (likely(args)) { + value = PySequence_GetItem(args, 0); + Py_DECREF(args); + } + if (unlikely(!value)) { + __Pyx_ErrRestore(NULL, NULL, NULL); + Py_INCREF(Py_None); + value = Py_None; + } + } +#endif + *pvalue = value; + return 0; +} +#endif +static CYTHON_INLINE +void __Pyx_Coroutine_ExceptionClear(__pyx_CoroutineObject *self) { + PyObject *exc_type = self->exc_type; + PyObject *exc_value = self->exc_value; + PyObject *exc_traceback = self->exc_traceback; + self->exc_type = NULL; + self->exc_value = NULL; + self->exc_traceback = NULL; + Py_XDECREF(exc_type); + Py_XDECREF(exc_value); + Py_XDECREF(exc_traceback); +} +static CYTHON_INLINE +int __Pyx_Coroutine_CheckRunning(__pyx_CoroutineObject *gen) { + if (unlikely(gen->is_running)) { + PyErr_SetString(PyExc_ValueError, + "generator already executing"); + return 1; + } + return 0; +} +static CYTHON_INLINE +PyObject *__Pyx_Coroutine_SendEx(__pyx_CoroutineObject *self, PyObject *value) { + PyObject *retval; + __Pyx_PyThreadState_declare + assert(!self->is_running); + if (unlikely(self->resume_label == 0)) { + if (unlikely(value && value != Py_None)) { + PyErr_SetString(PyExc_TypeError, + "can't send non-None value to a " + "just-started generator"); + return NULL; + } + } + if (unlikely(self->resume_label == -1)) { + PyErr_SetNone(PyExc_StopIteration); + return NULL; + } + __Pyx_PyThreadState_assign + if (value) { +#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_PYSTON +#else + if (self->exc_traceback) { + PyTracebackObject *tb = (PyTracebackObject *) self->exc_traceback; + PyFrameObject *f = tb->tb_frame; + Py_XINCREF(__pyx_tstate->frame); + assert(f->f_back == NULL); + f->f_back = __pyx_tstate->frame; + } +#endif + __Pyx_ExceptionSwap(&self->exc_type, &self->exc_value, + &self->exc_traceback); + } else { + __Pyx_Coroutine_ExceptionClear(self); + } + self->is_running = 1; + retval = self->body((PyObject *) self, value); + self->is_running = 0; + if (retval) { + __Pyx_ExceptionSwap(&self->exc_type, &self->exc_value, + &self->exc_traceback); +#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_PYSTON +#else + if (self->exc_traceback) { + PyTracebackObject *tb = (PyTracebackObject *) self->exc_traceback; + PyFrameObject *f = tb->tb_frame; + Py_CLEAR(f->f_back); + } +#endif + } else { + __Pyx_Coroutine_ExceptionClear(self); + } + return retval; +} +static CYTHON_INLINE +PyObject *__Pyx_Coroutine_MethodReturn(PyObject *retval) { + if (unlikely(!retval && !PyErr_Occurred())) { + PyErr_SetNone(PyExc_StopIteration); + } + return retval; +} +static CYTHON_INLINE +PyObject *__Pyx_Coroutine_FinishDelegation(__pyx_CoroutineObject *gen) { + PyObject *ret; + PyObject *val = NULL; + __Pyx_Coroutine_Undelegate(gen); + __Pyx_PyGen_FetchStopIterationValue(&val); + ret = __Pyx_Coroutine_SendEx(gen, val); + Py_XDECREF(val); + return ret; +} +static PyObject *__Pyx_Coroutine_Send(PyObject *self, PyObject *value) { + PyObject *retval; + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject*) self; + PyObject *yf = gen->yieldfrom; + if (unlikely(__Pyx_Coroutine_CheckRunning(gen))) + return NULL; + if (yf) { + PyObject *ret; + gen->is_running = 1; + #ifdef __Pyx_Generator_USED + if (__Pyx_Generator_CheckExact(yf)) { + ret = __Pyx_Coroutine_Send(yf, value); + } else + #endif + #ifdef __Pyx_Coroutine_USED + if (__Pyx_Coroutine_CheckExact(yf)) { + ret = __Pyx_Coroutine_Send(yf, value); + } else + #endif + { + if (value == Py_None) + ret = Py_TYPE(yf)->tp_iternext(yf); + else + ret = __Pyx_PyObject_CallMethod1(yf, __pyx_n_s_send, value); + } + gen->is_running = 0; + if (likely(ret)) { + return ret; + } + retval = __Pyx_Coroutine_FinishDelegation(gen); + } else { + retval = __Pyx_Coroutine_SendEx(gen, value); + } + return __Pyx_Coroutine_MethodReturn(retval); +} +static int __Pyx_Coroutine_CloseIter(__pyx_CoroutineObject *gen, PyObject *yf) { + PyObject *retval = NULL; + int err = 0; + #ifdef __Pyx_Generator_USED + if (__Pyx_Generator_CheckExact(yf)) { + retval = __Pyx_Coroutine_Close(yf); + if (!retval) + return -1; + } else + #endif + #ifdef __Pyx_Coroutine_USED + if (__Pyx_Coroutine_CheckExact(yf)) { + retval = __Pyx_Coroutine_Close(yf); + if (!retval) + return -1; + } else + #endif + { + PyObject *meth; + gen->is_running = 1; + meth = __Pyx_PyObject_GetAttrStr(yf, __pyx_n_s_close); + if (unlikely(!meth)) { + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_WriteUnraisable(yf); + } + PyErr_Clear(); + } else { + retval = PyObject_CallFunction(meth, NULL); + Py_DECREF(meth); + if (!retval) + err = -1; + } + gen->is_running = 0; + } + Py_XDECREF(retval); + return err; +} +static PyObject *__Pyx_Generator_Next(PyObject *self) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject*) self; + PyObject *yf = gen->yieldfrom; + if (unlikely(__Pyx_Coroutine_CheckRunning(gen))) + return NULL; + if (yf) { + PyObject *ret; + gen->is_running = 1; + #ifdef __Pyx_Generator_USED + if (__Pyx_Generator_CheckExact(yf)) { + ret = __Pyx_Generator_Next(yf); + } else + #endif + ret = Py_TYPE(yf)->tp_iternext(yf); + gen->is_running = 0; + if (likely(ret)) { + return ret; + } + return __Pyx_Coroutine_FinishDelegation(gen); + } + return __Pyx_Coroutine_SendEx(gen, Py_None); +} +static PyObject *__Pyx_Coroutine_Close(PyObject *self) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + PyObject *retval, *raised_exception; + PyObject *yf = gen->yieldfrom; + int err = 0; + if (unlikely(__Pyx_Coroutine_CheckRunning(gen))) + return NULL; + if (yf) { + Py_INCREF(yf); + err = __Pyx_Coroutine_CloseIter(gen, yf); + __Pyx_Coroutine_Undelegate(gen); + Py_DECREF(yf); + } + if (err == 0) + PyErr_SetNone(PyExc_GeneratorExit); + retval = __Pyx_Coroutine_SendEx(gen, NULL); + if (retval) { + Py_DECREF(retval); + PyErr_SetString(PyExc_RuntimeError, + "generator ignored GeneratorExit"); + return NULL; + } + raised_exception = PyErr_Occurred(); + if (!raised_exception + || raised_exception == PyExc_StopIteration + || raised_exception == PyExc_GeneratorExit + || PyErr_GivenExceptionMatches(raised_exception, PyExc_GeneratorExit) + || PyErr_GivenExceptionMatches(raised_exception, PyExc_StopIteration)) + { + if (raised_exception) PyErr_Clear(); + Py_INCREF(Py_None); + return Py_None; + } + return NULL; +} +static PyObject *__Pyx_Coroutine_Throw(PyObject *self, PyObject *args) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + PyObject *typ; + PyObject *tb = NULL; + PyObject *val = NULL; + PyObject *yf = gen->yieldfrom; + if (!PyArg_UnpackTuple(args, (char *)"throw", 1, 3, &typ, &val, &tb)) + return NULL; + if (unlikely(__Pyx_Coroutine_CheckRunning(gen))) + return NULL; + if (yf) { + PyObject *ret; + Py_INCREF(yf); + if (PyErr_GivenExceptionMatches(typ, PyExc_GeneratorExit)) { + int err = __Pyx_Coroutine_CloseIter(gen, yf); + Py_DECREF(yf); + __Pyx_Coroutine_Undelegate(gen); + if (err < 0) + return __Pyx_Coroutine_MethodReturn(__Pyx_Coroutine_SendEx(gen, NULL)); + goto throw_here; + } + gen->is_running = 1; + #ifdef __Pyx_Generator_USED + if (__Pyx_Generator_CheckExact(yf)) { + ret = __Pyx_Coroutine_Throw(yf, args); + } else + #endif + #ifdef __Pyx_Coroutine_USED + if (__Pyx_Coroutine_CheckExact(yf)) { + ret = __Pyx_Coroutine_Throw(yf, args); + } else + #endif + { + PyObject *meth = __Pyx_PyObject_GetAttrStr(yf, __pyx_n_s_throw); + if (unlikely(!meth)) { + Py_DECREF(yf); + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) { + gen->is_running = 0; + return NULL; + } + PyErr_Clear(); + __Pyx_Coroutine_Undelegate(gen); + gen->is_running = 0; + goto throw_here; + } + ret = PyObject_CallObject(meth, args); + Py_DECREF(meth); + } + gen->is_running = 0; + Py_DECREF(yf); + if (!ret) { + ret = __Pyx_Coroutine_FinishDelegation(gen); + } + return __Pyx_Coroutine_MethodReturn(ret); + } +throw_here: + __Pyx_Raise(typ, val, tb, NULL); + return __Pyx_Coroutine_MethodReturn(__Pyx_Coroutine_SendEx(gen, NULL)); +} +static int __Pyx_Coroutine_traverse(PyObject *self, visitproc visit, void *arg) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + Py_VISIT(gen->closure); + Py_VISIT(gen->classobj); + Py_VISIT(gen->yieldfrom); + Py_VISIT(gen->exc_type); + Py_VISIT(gen->exc_value); + Py_VISIT(gen->exc_traceback); + return 0; +} +static int __Pyx_Coroutine_clear(PyObject *self) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + Py_CLEAR(gen->closure); + Py_CLEAR(gen->classobj); + Py_CLEAR(gen->yieldfrom); + Py_CLEAR(gen->exc_type); + Py_CLEAR(gen->exc_value); + Py_CLEAR(gen->exc_traceback); + Py_CLEAR(gen->gi_name); + Py_CLEAR(gen->gi_qualname); + return 0; +} +static void __Pyx_Coroutine_dealloc(PyObject *self) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + PyObject_GC_UnTrack(gen); + if (gen->gi_weakreflist != NULL) + PyObject_ClearWeakRefs(self); + if (gen->resume_label > 0) { + PyObject_GC_Track(self); +#if PY_VERSION_HEX >= 0x030400a1 + if (PyObject_CallFinalizerFromDealloc(self)) +#else + Py_TYPE(gen)->tp_del(self); + if (self->ob_refcnt > 0) +#endif + { + return; + } + PyObject_GC_UnTrack(self); + } + __Pyx_Coroutine_clear(self); + PyObject_GC_Del(gen); +} +static void __Pyx_Coroutine_del(PyObject *self) { + PyObject *res; + PyObject *error_type, *error_value, *error_traceback; + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + __Pyx_PyThreadState_declare + if (gen->resume_label <= 0) + return ; +#if PY_VERSION_HEX < 0x030400a1 + assert(self->ob_refcnt == 0); + self->ob_refcnt = 1; +#endif + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&error_type, &error_value, &error_traceback); + res = __Pyx_Coroutine_Close(self); + if (res == NULL) + PyErr_WriteUnraisable(self); + else + Py_DECREF(res); + __Pyx_ErrRestore(error_type, error_value, error_traceback); +#if PY_VERSION_HEX < 0x030400a1 + assert(self->ob_refcnt > 0); + if (--self->ob_refcnt == 0) { + return; + } + { + Py_ssize_t refcnt = self->ob_refcnt; + _Py_NewReference(self); + self->ob_refcnt = refcnt; + } +#if CYTHON_COMPILING_IN_CPYTHON + assert(PyType_IS_GC(self->ob_type) && + _Py_AS_GC(self)->gc.gc_refs != _PyGC_REFS_UNTRACKED); + _Py_DEC_REFTOTAL; +#endif +#ifdef COUNT_ALLOCS + --Py_TYPE(self)->tp_frees; + --Py_TYPE(self)->tp_allocs; +#endif +#endif +} +static PyObject * +__Pyx_Coroutine_get_name(__pyx_CoroutineObject *self) +{ + PyObject *name = self->gi_name; + if (unlikely(!name)) name = Py_None; + Py_INCREF(name); + return name; +} +static int +__Pyx_Coroutine_set_name(__pyx_CoroutineObject *self, PyObject *value) +{ + PyObject *tmp; +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) { +#else + if (unlikely(value == NULL || !PyString_Check(value))) { +#endif + PyErr_SetString(PyExc_TypeError, + "__name__ must be set to a string object"); + return -1; + } + tmp = self->gi_name; + Py_INCREF(value); + self->gi_name = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_Coroutine_get_qualname(__pyx_CoroutineObject *self) +{ + PyObject *name = self->gi_qualname; + if (unlikely(!name)) name = Py_None; + Py_INCREF(name); + return name; +} +static int +__Pyx_Coroutine_set_qualname(__pyx_CoroutineObject *self, PyObject *value) +{ + PyObject *tmp; +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) { +#else + if (unlikely(value == NULL || !PyString_Check(value))) { +#endif + PyErr_SetString(PyExc_TypeError, + "__qualname__ must be set to a string object"); + return -1; + } + tmp = self->gi_qualname; + Py_INCREF(value); + self->gi_qualname = value; + Py_XDECREF(tmp); + return 0; +} +static __pyx_CoroutineObject *__Pyx__Coroutine_New( + PyTypeObject* type, __pyx_coroutine_body_t body, PyObject *closure, + PyObject *name, PyObject *qualname, PyObject *module_name) { + __pyx_CoroutineObject *gen = PyObject_GC_New(__pyx_CoroutineObject, type); + if (gen == NULL) + return NULL; + gen->body = body; + gen->closure = closure; + Py_XINCREF(closure); + gen->is_running = 0; + gen->resume_label = 0; + gen->classobj = NULL; + gen->yieldfrom = NULL; + gen->exc_type = NULL; + gen->exc_value = NULL; + gen->exc_traceback = NULL; + gen->gi_weakreflist = NULL; + Py_XINCREF(qualname); + gen->gi_qualname = qualname; + Py_XINCREF(name); + gen->gi_name = name; + Py_XINCREF(module_name); + gen->gi_modulename = module_name; + PyObject_GC_Track(gen); + return gen; +} + +/* PatchModuleWithCoroutine */ + static PyObject* __Pyx_Coroutine_patch_module(PyObject* module, const char* py_code) { +#if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) + int result; + PyObject *globals, *result_obj; + globals = PyDict_New(); if (unlikely(!globals)) goto ignore; + result = PyDict_SetItemString(globals, "_cython_coroutine_type", + #ifdef __Pyx_Coroutine_USED + (PyObject*)__pyx_CoroutineType); + #else + Py_None); + #endif + if (unlikely(result < 0)) goto ignore; + result = PyDict_SetItemString(globals, "_cython_generator_type", + #ifdef __Pyx_Generator_USED + (PyObject*)__pyx_GeneratorType); + #else + Py_None); + #endif + if (unlikely(result < 0)) goto ignore; + if (unlikely(PyDict_SetItemString(globals, "_module", module) < 0)) goto ignore; + if (unlikely(PyDict_SetItemString(globals, "__builtins__", __pyx_b) < 0)) goto ignore; + result_obj = PyRun_String(py_code, Py_file_input, globals, globals); + if (unlikely(!result_obj)) goto ignore; + Py_DECREF(result_obj); + Py_DECREF(globals); + return module; +ignore: + Py_XDECREF(globals); + PyErr_WriteUnraisable(module); + if (unlikely(PyErr_WarnEx(PyExc_RuntimeWarning, "Cython module failed to patch module with custom type", 1) < 0)) { + Py_DECREF(module); + module = NULL; + } +#else + py_code++; +#endif + return module; +} + +/* PatchGeneratorABC */ + #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) +static PyObject* __Pyx_patch_abc_module(PyObject *module); +static PyObject* __Pyx_patch_abc_module(PyObject *module) { + module = __Pyx_Coroutine_patch_module( + module, "" +"if _cython_generator_type is not None:\n" +" try: Generator = _module.Generator\n" +" except AttributeError: pass\n" +" else: Generator.register(_cython_generator_type)\n" +"if _cython_coroutine_type is not None:\n" +" try: Coroutine = _module.Coroutine\n" +" except AttributeError: pass\n" +" else: Coroutine.register(_cython_coroutine_type)\n" + ); + return module; +} +#endif +static int __Pyx_patch_abc(void) { +#if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) + static int abc_patched = 0; + if (!abc_patched) { + PyObject *module; + module = PyImport_ImportModule((PY_VERSION_HEX >= 0x03030000) ? "collections.abc" : "collections"); + if (!module) { + PyErr_WriteUnraisable(NULL); + if (unlikely(PyErr_WarnEx(PyExc_RuntimeWarning, + ((PY_VERSION_HEX >= 0x03030000) ? + "Cython module failed to register with collections.abc module" : + "Cython module failed to register with collections module"), 1) < 0)) { + return -1; + } + } else { + module = __Pyx_patch_abc_module(module); + abc_patched = 1; + if (unlikely(!module)) + return -1; + Py_DECREF(module); + } + module = PyImport_ImportModule("backports_abc"); + if (module) { + module = __Pyx_patch_abc_module(module); + Py_XDECREF(module); + } + if (!module) { + PyErr_Clear(); + } + } +#else + if (0) __Pyx_Coroutine_patch_module(NULL, NULL); +#endif + return 0; +} + +/* Generator */ + static PyMethodDef __pyx_Generator_methods[] = { + {"send", (PyCFunction) __Pyx_Coroutine_Send, METH_O, + (char*) PyDoc_STR("send(arg) -> send 'arg' into generator,\nreturn next yielded value or raise StopIteration.")}, + {"throw", (PyCFunction) __Pyx_Coroutine_Throw, METH_VARARGS, + (char*) PyDoc_STR("throw(typ[,val[,tb]]) -> raise exception in generator,\nreturn next yielded value or raise StopIteration.")}, + {"close", (PyCFunction) __Pyx_Coroutine_Close, METH_NOARGS, + (char*) PyDoc_STR("close() -> raise GeneratorExit inside generator.")}, + {0, 0, 0, 0} +}; +static PyMemberDef __pyx_Generator_memberlist[] = { + {(char *) "gi_running", T_BOOL, offsetof(__pyx_CoroutineObject, is_running), READONLY, NULL}, + {(char*) "gi_yieldfrom", T_OBJECT, offsetof(__pyx_CoroutineObject, yieldfrom), READONLY, + (char*) PyDoc_STR("object being iterated by 'yield from', or None")}, + {0, 0, 0, 0, 0} +}; +static PyGetSetDef __pyx_Generator_getsets[] = { + {(char *) "__name__", (getter)__Pyx_Coroutine_get_name, (setter)__Pyx_Coroutine_set_name, + (char*) PyDoc_STR("name of the generator"), 0}, + {(char *) "__qualname__", (getter)__Pyx_Coroutine_get_qualname, (setter)__Pyx_Coroutine_set_qualname, + (char*) PyDoc_STR("qualified name of the generator"), 0}, + {0, 0, 0, 0, 0} +}; +static PyTypeObject __pyx_GeneratorType_type = { + PyVarObject_HEAD_INIT(0, 0) + "generator", + sizeof(__pyx_CoroutineObject), + 0, + (destructor) __Pyx_Coroutine_dealloc, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_HAVE_FINALIZE, + 0, + (traverseproc) __Pyx_Coroutine_traverse, + 0, + 0, + offsetof(__pyx_CoroutineObject, gi_weakreflist), + 0, + (iternextfunc) __Pyx_Generator_Next, + __pyx_Generator_methods, + __pyx_Generator_memberlist, + __pyx_Generator_getsets, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, +#if PY_VERSION_HEX >= 0x030400a1 + 0, +#else + __Pyx_Coroutine_del, +#endif + 0, +#if PY_VERSION_HEX >= 0x030400a1 + __Pyx_Coroutine_del, +#endif +}; +static int __pyx_Generator_init(void) { + __pyx_GeneratorType_type.tp_getattro = PyObject_GenericGetAttr; + __pyx_GeneratorType_type.tp_iter = PyObject_SelfIter; + __pyx_GeneratorType = __Pyx_FetchCommonType(&__pyx_GeneratorType_type); + if (unlikely(!__pyx_GeneratorType)) { + return -1; + } + return 0; +} + +/* CheckBinaryVersion */ + static int __Pyx_check_binary_version(void) { + char ctversion[4], rtversion[4]; + PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); + PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion()); + if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) { + char message[200]; + PyOS_snprintf(message, sizeof(message), + "compiletime version %s of module '%.100s' " + "does not match runtime version %s", + ctversion, __Pyx_MODULE_NAME, rtversion); + return PyErr_WarnEx(NULL, message, 1); + } + return 0; +} + +/* InitStrings */ + static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { + while (t->p) { + #if PY_MAJOR_VERSION < 3 + if (t->is_unicode) { + *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); + } else if (t->intern) { + *t->p = PyString_InternFromString(t->s); + } else { + *t->p = PyString_FromStringAndSize(t->s, t->n - 1); + } + #else + if (t->is_unicode | t->is_str) { + if (t->intern) { + *t->p = PyUnicode_InternFromString(t->s); + } else if (t->encoding) { + *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); + } else { + *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); + } + } else { + *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); + } + #endif + if (!*t->p) + return -1; + ++t; + } + return 0; +} + +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { + return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); +} +static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject* o) { + Py_ssize_t ignore; + return __Pyx_PyObject_AsStringAndSize(o, &ignore); +} +static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { +#if CYTHON_COMPILING_IN_CPYTHON && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) + if ( +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + __Pyx_sys_getdefaultencoding_not_ascii && +#endif + PyUnicode_Check(o)) { +#if PY_VERSION_HEX < 0x03030000 + char* defenc_c; + PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); + if (!defenc) return NULL; + defenc_c = PyBytes_AS_STRING(defenc); +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + { + char* end = defenc_c + PyBytes_GET_SIZE(defenc); + char* c; + for (c = defenc_c; c < end; c++) { + if ((unsigned char) (*c) >= 128) { + PyUnicode_AsASCIIString(o); + return NULL; + } + } + } +#endif + *length = PyBytes_GET_SIZE(defenc); + return defenc_c; +#else + if (__Pyx_PyUnicode_READY(o) == -1) return NULL; +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + if (PyUnicode_IS_ASCII(o)) { + *length = PyUnicode_GET_LENGTH(o); + return PyUnicode_AsUTF8(o); + } else { + PyUnicode_AsASCIIString(o); + return NULL; + } +#else + return PyUnicode_AsUTF8AndSize(o, length); +#endif +#endif + } else +#endif +#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) + if (PyByteArray_Check(o)) { + *length = PyByteArray_GET_SIZE(o); + return PyByteArray_AS_STRING(o); + } else +#endif + { + char* result; + int r = PyBytes_AsStringAndSize(o, &result, length); + if (unlikely(r < 0)) { + return NULL; + } else { + return result; + } + } +} +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { + int is_true = x == Py_True; + if (is_true | (x == Py_False) | (x == Py_None)) return is_true; + else return PyObject_IsTrue(x); +} +static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { +#if CYTHON_USE_TYPE_SLOTS + PyNumberMethods *m; +#endif + const char *name = NULL; + PyObject *res = NULL; +#if PY_MAJOR_VERSION < 3 + if (PyInt_Check(x) || PyLong_Check(x)) +#else + if (PyLong_Check(x)) +#endif + return __Pyx_NewRef(x); +#if CYTHON_USE_TYPE_SLOTS + m = Py_TYPE(x)->tp_as_number; + #if PY_MAJOR_VERSION < 3 + if (m && m->nb_int) { + name = "int"; + res = PyNumber_Int(x); + } + else if (m && m->nb_long) { + name = "long"; + res = PyNumber_Long(x); + } + #else + if (m && m->nb_int) { + name = "int"; + res = PyNumber_Long(x); + } + #endif +#else + res = PyNumber_Int(x); +#endif + if (res) { +#if PY_MAJOR_VERSION < 3 + if (!PyInt_Check(res) && !PyLong_Check(res)) { +#else + if (!PyLong_Check(res)) { +#endif + PyErr_Format(PyExc_TypeError, + "__%.4s__ returned non-%.4s (type %.200s)", + name, name, Py_TYPE(res)->tp_name); + Py_DECREF(res); + return NULL; + } + } + else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, + "an integer is required"); + } + return res; +} +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { + Py_ssize_t ival; + PyObject *x; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(b))) { + if (sizeof(Py_ssize_t) >= sizeof(long)) + return PyInt_AS_LONG(b); + else + return PyInt_AsSsize_t(x); + } +#endif + if (likely(PyLong_CheckExact(b))) { + #if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)b)->ob_digit; + const Py_ssize_t size = Py_SIZE(b); + if (likely(__Pyx_sst_abs(size) <= 1)) { + ival = likely(size) ? digits[0] : 0; + if (size == -1) ival = -ival; + return ival; + } else { + switch (size) { + case 2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + } + } + #endif + return PyLong_AsSsize_t(b); + } + x = PyNumber_Index(b); + if (!x) return -1; + ival = PyInt_AsSsize_t(x); + Py_DECREF(x); + return ival; +} +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { + return PyInt_FromSize_t(ival); +} + + +#endif /* Py_PYTHON_H */ +#endif /* (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) || (EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && !defined(_WIN32)) || (!EV_USE_SIGNALFD && !defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && defined(_WIN32)) || (!EV_USE_SIGNALFD && defined(LIBEV_EMBED) && !defined(_WIN32)) */ +/* Copyright (c) 2011-2012 Denis Bilenko. See LICENSE for details. */ +#ifdef Py_PYTHON_H + +/* the name changes depending on our file layout and --module-name option */ +#define _GEVENTLOOP struct __pyx_vtabstruct_6gevent_5libev_8corecext_loop + + +static void gevent_handle_error(struct PyGeventLoopObject* loop, PyObject* context) { + PyThreadState *tstate; + PyObject *type, *value, *traceback, *result; + tstate = PyThreadState_GET(); + type = tstate->curexc_type; + if (!type) + return; + value = tstate->curexc_value; + traceback = tstate->curexc_traceback; + if (!value) value = Py_None; + if (!traceback) traceback = Py_None; + + Py_INCREF(type); + Py_INCREF(value); + Py_INCREF(traceback); + + PyErr_Clear(); + + result = ((_GEVENTLOOP *)loop->__pyx_vtab)->handle_error(loop, context, type, value, traceback, 0); + + if (result) { + Py_DECREF(result); + } + else { + PyErr_Print(); + PyErr_Clear(); + } + + Py_DECREF(type); + Py_DECREF(value); + Py_DECREF(traceback); +} + + +static CYTHON_INLINE void gevent_check_signals(struct PyGeventLoopObject* loop) { + if (!ev_is_default_loop(loop->_ptr)) { + /* only reporting signals on the default loop */ + return; + } + PyErr_CheckSignals(); + if (PyErr_Occurred()) gevent_handle_error(loop, Py_None); +} + +#define GET_OBJECT(PY_TYPE, EV_PTR, MEMBER) \ + ((struct PY_TYPE *)(((char *)EV_PTR) - offsetof(struct PY_TYPE, MEMBER))) + + +#ifdef WITH_THREAD +#define GIL_DECLARE PyGILState_STATE ___save +#define GIL_ENSURE ___save = PyGILState_Ensure(); +#define GIL_RELEASE PyGILState_Release(___save); +#else +#define GIL_DECLARE +#define GIL_ENSURE +#define GIL_RELEASE +#endif + + +static void gevent_stop(PyObject* watcher, struct PyGeventLoopObject* loop) { + PyObject *result, *method; + int error; + error = 1; + method = PyObject_GetAttrString(watcher, "stop"); + if (method) { + result = PyObject_Call(method, __pyx_empty_tuple, NULL); + if (result) { + Py_DECREF(result); + error = 0; + } + Py_DECREF(method); + } + if (error) { + gevent_handle_error(loop, watcher); + } +} + + +static void gevent_callback(struct PyGeventLoopObject* loop, PyObject* callback, PyObject* args, PyObject* watcher, void *c_watcher, int revents) { + GIL_DECLARE; + PyObject *result, *py_events; + long length; + py_events = 0; + GIL_ENSURE; + Py_INCREF(loop); + Py_INCREF(callback); + Py_INCREF(args); + Py_INCREF(watcher); + gevent_check_signals(loop); + if (args == Py_None) { + args = __pyx_empty_tuple; + } + length = PyTuple_Size(args); + if (length < 0) { + gevent_handle_error(loop, watcher); + goto end; + } + if (length > 0 && PyTuple_GET_ITEM(args, 0) == GEVENT_CORE_EVENTS) { + py_events = PyInt_FromLong(revents); + if (!py_events) { + gevent_handle_error(loop, watcher); + goto end; + } + PyTuple_SET_ITEM(args, 0, py_events); + } + else { + py_events = NULL; + } + result = PyObject_Call(callback, args, NULL); + if (result) { + Py_DECREF(result); + } + else { + gevent_handle_error(loop, watcher); + if (revents & (EV_READ|EV_WRITE)) { + /* io watcher: not stopping it may cause the failing callback to be called repeatedly */ + gevent_stop(watcher, loop); + goto end; + } + } + if (!ev_is_active(c_watcher)) { + /* Watcher was stopped, maybe by libev. Let's call stop() to clean up + * 'callback' and 'args' properties, do Py_DECREF() and ev_ref() if necessary. + * BTW, we don't need to check for EV_ERROR, because libev stops the watcher in that case. */ + gevent_stop(watcher, loop); + } +end: + if (py_events) { + Py_DECREF(py_events); + PyTuple_SET_ITEM(args, 0, GEVENT_CORE_EVENTS); + } + Py_DECREF(watcher); + Py_DECREF(args); + Py_DECREF(callback); + Py_DECREF(loop); + GIL_RELEASE; +} + + +static void gevent_call(struct PyGeventLoopObject* loop, struct PyGeventCallbackObject* cb) { + /* no need for GIL here because it is only called from run_callbacks which already has GIL */ + PyObject *result, *callback, *args; + if (!loop || !cb) + return; + callback = cb->callback; + args = cb->args; + if (!callback || !args) + return; + if (callback == Py_None || args == Py_None) + return; + Py_INCREF(loop); + Py_INCREF(callback); + Py_INCREF(args); + + Py_INCREF(Py_None); + Py_DECREF(cb->callback); + cb->callback = Py_None; + + result = PyObject_Call(callback, args, NULL); + if (result) { + Py_DECREF(result); + } + else { + gevent_handle_error(loop, (PyObject*)cb); + } + + Py_INCREF(Py_None); + Py_DECREF(cb->args); + cb->args = Py_None; + + Py_DECREF(callback); + Py_DECREF(args); + Py_DECREF(loop); +} + + +#undef DEFINE_CALLBACK +#define DEFINE_CALLBACK(WATCHER_LC, WATCHER_TYPE) \ + static void gevent_callback_##WATCHER_LC(struct ev_loop *_loop, void *c_watcher, int revents) { \ + struct PyGevent##WATCHER_TYPE##Object* watcher = GET_OBJECT(PyGevent##WATCHER_TYPE##Object, c_watcher, _watcher); \ + gevent_callback(watcher->loop, watcher->_callback, watcher->args, (PyObject*)watcher, c_watcher, revents); \ + } + + +DEFINE_CALLBACKS + + +static void gevent_run_callbacks(struct ev_loop *_loop, void *watcher, int revents) { + struct PyGeventLoopObject* loop; + PyObject *result; + GIL_DECLARE; + GIL_ENSURE; + loop = GET_OBJECT(PyGeventLoopObject, watcher, _prepare); + Py_INCREF(loop); + gevent_check_signals(loop); + result = ((_GEVENTLOOP *)loop->__pyx_vtab)->_run_callbacks(loop); + if (result) { + Py_DECREF(result); + } + else { + PyErr_Print(); + PyErr_Clear(); + } + Py_DECREF(loop); + GIL_RELEASE; +} + +#if defined(_WIN32) + +static void gevent_periodic_signal_check(struct ev_loop *_loop, void *watcher, int revents) { + GIL_DECLARE; + GIL_ENSURE; + gevent_check_signals(GET_OBJECT(PyGeventLoopObject, watcher, _periodic_signal_checker)); + GIL_RELEASE; +} + +#endif /* _WIN32 */ + +#endif /* Py_PYTHON_H */ diff --git a/python/gevent/libev/libev.h b/python/gevent/libev/libev.h new file mode 100644 index 0000000..657aaad --- /dev/null +++ b/python/gevent/libev/libev.h @@ -0,0 +1,66 @@ +#if defined(LIBEV_EMBED) +#include "ev.c" +#else +#include "ev.h" + +#ifndef _WIN32 +#include +#endif + +#endif + +#ifndef _WIN32 + +static struct sigaction libev_sigchld; +/* + * Track the state of whether we have installed + * the libev sigchld handler specifically. + * If it's non-zero, libev_sigchld will be valid and set to the action + * that libev needs to do. + * If it's 1, we need to install libev_sigchld to make libev + * child handlers work (on request). + */ +static int sigchld_state = 0; + +static struct ev_loop* gevent_ev_default_loop(unsigned int flags) +{ + struct ev_loop* result; + struct sigaction tmp; + + if (sigchld_state) + return ev_default_loop(flags); + + // Request the old SIGCHLD handler + sigaction(SIGCHLD, NULL, &tmp); + // Get the loop, which will install a SIGCHLD handler + result = ev_default_loop(flags); + // XXX what if SIGCHLD received there? + // Now restore the previous SIGCHLD handler + sigaction(SIGCHLD, &tmp, &libev_sigchld); + sigchld_state = 1; + return result; +} + + +static void gevent_install_sigchld_handler(void) { + if (sigchld_state == 1) { + sigaction(SIGCHLD, &libev_sigchld, NULL); + sigchld_state = 2; + } +} + +static void gevent_reset_sigchld_handler(void) { + // We could have any state at this point, depending on + // whether the default loop has been used. If it has, + // then always be in state 1 ("need to install) + if (sigchld_state) { + sigchld_state = 1; + } +} + +#else + +#define gevent_ev_default_loop ev_default_loop +static void gevent_install_sigchld_handler(void) { } + +#endif diff --git a/python/gevent/libev/libev.pxd b/python/gevent/libev/libev.pxd new file mode 100644 index 0000000..d8914b6 --- /dev/null +++ b/python/gevent/libev/libev.pxd @@ -0,0 +1,208 @@ +cdef extern from "libev_vfd.h": +#ifdef _WIN32 +#ifdef _WIN64 + ctypedef long long vfd_socket_t +#else + ctypedef long vfd_socket_t +#endif +#else + ctypedef int vfd_socket_t +#endif + long vfd_get(int) + int vfd_open(long) except -1 + void vfd_free(int) + +cdef extern from "libev.h": + int EV_MINPRI + int EV_MAXPRI + + int EV_VERSION_MAJOR + int EV_VERSION_MINOR + + int EV_USE_FLOOR + int EV_USE_CLOCK_SYSCALL + int EV_USE_REALTIME + int EV_USE_MONOTONIC + int EV_USE_NANOSLEEP + int EV_USE_SELECT + int EV_USE_POLL + int EV_USE_EPOLL + int EV_USE_KQUEUE + int EV_USE_PORT + int EV_USE_INOTIFY + int EV_USE_SIGNALFD + int EV_USE_EVENTFD + int EV_USE_4HEAP + int EV_USE_IOCP + int EV_SELECT_IS_WINSOCKET + + int EV_UNDEF + int EV_NONE + int EV_READ + int EV_WRITE + int EV__IOFDSET + int EV_TIMER + int EV_PERIODIC + int EV_SIGNAL + int EV_CHILD + int EV_STAT + int EV_IDLE + int EV_PREPARE + int EV_CHECK + int EV_EMBED + int EV_FORK + int EV_CLEANUP + int EV_ASYNC + int EV_CUSTOM + int EV_ERROR + + int EVFLAG_AUTO + int EVFLAG_NOENV + int EVFLAG_FORKCHECK + int EVFLAG_NOINOTIFY + int EVFLAG_SIGNALFD + int EVFLAG_NOSIGMASK + + int EVBACKEND_SELECT + int EVBACKEND_POLL + int EVBACKEND_EPOLL + int EVBACKEND_KQUEUE + int EVBACKEND_DEVPOLL + int EVBACKEND_PORT + int EVBACKEND_IOCP + int EVBACKEND_ALL + int EVBACKEND_MASK + + int EVRUN_NOWAIT + int EVRUN_ONCE + + int EVBREAK_CANCEL + int EVBREAK_ONE + int EVBREAK_ALL + + struct ev_loop: + int activecnt + int sig_pending + int backend_fd + int sigfd + unsigned int origflags + + struct ev_io: + int fd + int events + + struct ev_timer: + double at + + struct ev_signal: + pass + + struct ev_idle: + pass + + struct ev_prepare: + pass + + struct ev_check: + pass + + struct ev_fork: + pass + + struct ev_async: + pass + + struct ev_child: + int pid + int rpid + int rstatus + + struct stat: + int st_nlink + + struct ev_stat: + stat attr + stat prev + double interval + + int ev_version_major() + int ev_version_minor() + + unsigned int ev_supported_backends() + unsigned int ev_recommended_backends() + unsigned int ev_embeddable_backends() + + double ev_time() + void ev_set_syserr_cb(void *) + + int ev_priority(void*) + void ev_set_priority(void*, int) + + int ev_is_pending(void*) + int ev_is_active(void*) + void ev_io_init(ev_io*, void* callback, int fd, int events) + void ev_io_start(ev_loop*, ev_io*) + void ev_io_stop(ev_loop*, ev_io*) + void ev_feed_event(ev_loop*, void*, int) + + void ev_timer_init(ev_timer*, void* callback, double, double) + void ev_timer_start(ev_loop*, ev_timer*) + void ev_timer_stop(ev_loop*, ev_timer*) + void ev_timer_again(ev_loop*, ev_timer*) + + void ev_signal_init(ev_signal*, void* callback, int) + void ev_signal_start(ev_loop*, ev_signal*) + void ev_signal_stop(ev_loop*, ev_signal*) + + void ev_idle_init(ev_idle*, void* callback) + void ev_idle_start(ev_loop*, ev_idle*) + void ev_idle_stop(ev_loop*, ev_idle*) + + void ev_prepare_init(ev_prepare*, void* callback) + void ev_prepare_start(ev_loop*, ev_prepare*) + void ev_prepare_stop(ev_loop*, ev_prepare*) + + void ev_check_init(ev_check*, void* callback) + void ev_check_start(ev_loop*, ev_check*) + void ev_check_stop(ev_loop*, ev_check*) + + void ev_fork_init(ev_fork*, void* callback) + void ev_fork_start(ev_loop*, ev_fork*) + void ev_fork_stop(ev_loop*, ev_fork*) + + void ev_async_init(ev_async*, void* callback) + void ev_async_start(ev_loop*, ev_async*) + void ev_async_stop(ev_loop*, ev_async*) + void ev_async_send(ev_loop*, ev_async*) + int ev_async_pending(ev_async*) + + void ev_child_init(ev_child*, void* callback, int, int) + void ev_child_start(ev_loop*, ev_child*) + void ev_child_stop(ev_loop*, ev_child*) + + void ev_stat_init(ev_stat*, void* callback, char*, double) + void ev_stat_start(ev_loop*, ev_stat*) + void ev_stat_stop(ev_loop*, ev_stat*) + + ev_loop* ev_default_loop(unsigned int flags) + ev_loop* ev_loop_new(unsigned int flags) + void ev_loop_destroy(ev_loop*) + void ev_loop_fork(ev_loop*) + int ev_is_default_loop(ev_loop*) + unsigned int ev_iteration(ev_loop*) + unsigned int ev_depth(ev_loop*) + unsigned int ev_backend(ev_loop*) + void ev_verify(ev_loop*) + void ev_run(ev_loop*, int flags) nogil + + double ev_now(ev_loop*) + void ev_now_update(ev_loop*) + + void ev_ref(ev_loop*) + void ev_unref(ev_loop*) + void ev_break(ev_loop*, int) + unsigned int ev_pending_count(ev_loop*) + + ev_loop* gevent_ev_default_loop(unsigned int flags) + void gevent_install_sigchld_handler() + void gevent_reset_sigchld_handler() diff --git a/python/gevent/libev/libev_vfd.h b/python/gevent/libev/libev_vfd.h new file mode 100644 index 0000000..ec16a28 --- /dev/null +++ b/python/gevent/libev/libev_vfd.h @@ -0,0 +1,223 @@ +#ifdef _WIN32 +#ifdef _WIN64 +typedef PY_LONG_LONG vfd_socket_t; +#define vfd_socket_object PyLong_FromLongLong +#else +typedef long vfd_socket_t; +#define vfd_socket_object PyInt_FromLong +#endif +#ifdef LIBEV_EMBED +/* + * If libev on win32 is embedded, then we can use an + * arbitrary mapping between integer fds and OS + * handles. Then by defining special macros libev + * will use our functions. + */ + +#define WIN32_LEAN_AND_MEAN +#include +#include + +typedef struct vfd_entry_t +{ + vfd_socket_t handle; /* OS handle, i.e. SOCKET */ + int count; /* Reference count, 0 if free */ + int next; /* Next free fd, -1 if last */ +} vfd_entry; + +#define VFD_INCREMENT 128 +static int vfd_num = 0; /* num allocated fds */ +static int vfd_max = 0; /* max allocated fds */ +static int vfd_next = -1; /* next free fd for reuse */ +static PyObject* vfd_map = NULL; /* map OS handle -> virtual fd */ +static vfd_entry* vfd_entries = NULL; /* list of virtual fd entries */ + +#ifdef WITH_THREAD +static CRITICAL_SECTION* volatile vfd_lock = NULL; +static CRITICAL_SECTION* vfd_make_lock() +{ + if (vfd_lock == NULL) { + /* must use malloc and not PyMem_Malloc here */ + CRITICAL_SECTION* lock = malloc(sizeof(CRITICAL_SECTION)); + InitializeCriticalSection(lock); + if (InterlockedCompareExchangePointer(&vfd_lock, lock, NULL) != NULL) { + /* another thread initialized lock first */ + DeleteCriticalSection(lock); + free(lock); + } + } + return vfd_lock; +} +#define VFD_LOCK_ENTER EnterCriticalSection(vfd_make_lock()) +#define VFD_LOCK_LEAVE LeaveCriticalSection(vfd_lock) +#define VFD_GIL_DECLARE PyGILState_STATE ___save +#define VFD_GIL_ENSURE ___save = PyGILState_Ensure() +#define VFD_GIL_RELEASE PyGILState_Release(___save) +#else +#define VFD_LOCK_ENTER +#define VFD_LOCK_LEAVE +#define VFD_GIL_DECLARE +#define VFD_GIL_ENSURE +#define VFD_GIL_RELEASE +#endif + +/* + * Given a virtual fd returns an OS handle or -1 + * This function is speed critical, so it cannot use GIL + */ +static vfd_socket_t vfd_get(int fd) +{ + int handle = -1; + VFD_LOCK_ENTER; + if (vfd_entries != NULL && fd >= 0 && fd < vfd_num) + handle = vfd_entries[fd].handle; + VFD_LOCK_LEAVE; + return handle; +} + +#define EV_FD_TO_WIN32_HANDLE(fd) vfd_get((fd)) + +/* + * Given an OS handle finds or allocates a virtual fd + * Returns -1 on failure and sets Python exception if pyexc is non-zero + */ +static int vfd_open_(vfd_socket_t handle, int pyexc) +{ + VFD_GIL_DECLARE; + int fd = -1; + unsigned long arg; + PyObject* key = NULL; + PyObject* value; + + if (!pyexc) { + VFD_GIL_ENSURE; + } + if (ioctlsocket(handle, FIONREAD, &arg) != 0) { + if (pyexc) + PyErr_Format(PyExc_IOError, +#ifdef _WIN64 + "%lld is not a socket (files are not supported)", +#else + "%ld is not a socket (files are not supported)", +#endif + handle); + goto done; + } + if (vfd_map == NULL) { + vfd_map = PyDict_New(); + if (vfd_map == NULL) + goto done; + } + key = vfd_socket_object(handle); + /* check if it's already in the dict */ + value = PyDict_GetItem(vfd_map, key); + if (value != NULL) { + /* is it safe to use PyInt_AS_LONG(value) here? */ + fd = PyInt_AsLong(value); + if (fd >= 0) { + ++vfd_entries[fd].count; + goto done; + } + } + /* use the free entry, if available */ + if (vfd_next >= 0) { + fd = vfd_next; + vfd_next = vfd_entries[fd].next; + VFD_LOCK_ENTER; + goto allocated; + } + /* check if it would be out of bounds */ + if (vfd_num >= FD_SETSIZE) { + /* libev's select doesn't support more that FD_SETSIZE fds */ + if (pyexc) + PyErr_Format(PyExc_IOError, "cannot watch more than %d sockets", (int)FD_SETSIZE); + goto done; + } + /* allocate more space if needed */ + VFD_LOCK_ENTER; + if (vfd_num >= vfd_max) { + int newsize = vfd_max + VFD_INCREMENT; + vfd_entry* entries = PyMem_Realloc(vfd_entries, sizeof(vfd_entry) * newsize); + if (entries == NULL) { + VFD_LOCK_LEAVE; + if (pyexc) + PyErr_NoMemory(); + goto done; + } + vfd_entries = entries; + vfd_max = newsize; + } + fd = vfd_num++; +allocated: + /* vfd_lock must be acquired when entering here */ + vfd_entries[fd].handle = handle; + vfd_entries[fd].count = 1; + VFD_LOCK_LEAVE; + value = PyInt_FromLong(fd); + PyDict_SetItem(vfd_map, key, value); + Py_DECREF(value); +done: + Py_XDECREF(key); + if (!pyexc) { + VFD_GIL_RELEASE; + } + return fd; +} + +#define vfd_open(fd) vfd_open_((fd), 1) +#define EV_WIN32_HANDLE_TO_FD(handle) vfd_open_((handle), 0) + +static void vfd_free_(int fd, int needclose) +{ + VFD_GIL_DECLARE; + PyObject* key; + + if (needclose) { + VFD_GIL_ENSURE; + } + if (fd < 0 || fd >= vfd_num) + goto done; /* out of bounds */ + if (vfd_entries[fd].count <= 0) + goto done; /* free entry, ignore */ + if (!--vfd_entries[fd].count) { + /* fd has just been freed */ + vfd_socket_t handle = vfd_entries[fd].handle; + vfd_entries[fd].handle = -1; + vfd_entries[fd].next = vfd_next; + vfd_next = fd; + if (needclose) + closesocket(handle); + /* vfd_map is assumed to be != NULL */ + key = vfd_socket_object(handle); + PyDict_DelItem(vfd_map, key); + Py_DECREF(key); + } +done: + if (needclose) { + VFD_GIL_RELEASE; + } +} + +#define vfd_free(fd) vfd_free_((fd), 0) +#define EV_WIN32_CLOSE_FD(fd) vfd_free_((fd), 1) + +#else +/* + * If libev on win32 is not embedded in gevent, then + * the only way to map vfds is to use the default of + * using runtime fds in libev. Note that it will leak + * fds, because there's no way of closing them safely + */ +#define vfd_get(fd) _get_osfhandle((fd)) +#define vfd_open(fd) _open_osfhandle((fd), 0) +#define vfd_free(fd) +#endif +#else +/* + * On non-win32 platforms vfd_* are noop macros + */ +typedef int vfd_socket_t; +#define vfd_get(fd) (fd) +#define vfd_open(fd) ((int)(fd)) +#define vfd_free(fd) +#endif diff --git a/python/gevent/libev/stathelper.c b/python/gevent/libev/stathelper.c new file mode 100644 index 0000000..1a70b55 --- /dev/null +++ b/python/gevent/libev/stathelper.c @@ -0,0 +1,187 @@ +/* copied from Python-2.7.2/Modules/posixmodule.c */ +#include "structseq.h" + +#define STRUCT_STAT struct stat + +#ifdef HAVE_STRUCT_STAT_ST_BLKSIZE +#define ST_BLKSIZE_IDX 13 +#else +#define ST_BLKSIZE_IDX 12 +#endif + +#ifdef HAVE_STRUCT_STAT_ST_BLOCKS +#define ST_BLOCKS_IDX (ST_BLKSIZE_IDX+1) +#else +#define ST_BLOCKS_IDX ST_BLKSIZE_IDX +#endif + +#ifdef HAVE_STRUCT_STAT_ST_RDEV +#define ST_RDEV_IDX (ST_BLOCKS_IDX+1) +#else +#define ST_RDEV_IDX ST_BLOCKS_IDX +#endif + +#ifdef HAVE_STRUCT_STAT_ST_FLAGS +#define ST_FLAGS_IDX (ST_RDEV_IDX+1) +#else +#define ST_FLAGS_IDX ST_RDEV_IDX +#endif + +#ifdef HAVE_STRUCT_STAT_ST_GEN +#define ST_GEN_IDX (ST_FLAGS_IDX+1) +#else +#define ST_GEN_IDX ST_FLAGS_IDX +#endif + +#ifdef HAVE_STRUCT_STAT_ST_BIRTHTIME +#define ST_BIRTHTIME_IDX (ST_GEN_IDX+1) +#else +#define ST_BIRTHTIME_IDX ST_GEN_IDX +#endif + + + +static PyObject* posixmodule = NULL; +static PyTypeObject* pStatResultType = NULL; + + +static PyObject* import_posixmodule(void) +{ + if (!posixmodule) { + posixmodule = PyImport_ImportModule("posix"); + } + return posixmodule; +} + + +static PyObject* import_StatResultType(void) +{ + PyObject* p = NULL; + if (!pStatResultType) { + PyObject* module; + module = import_posixmodule(); + if (module) { + p = PyObject_GetAttrString(module, "stat_result"); + } + } + return p; +} + +static void +fill_time(PyObject *v, int index, time_t sec, unsigned long nsec) +{ + PyObject *fval,*ival; +#if SIZEOF_TIME_T > SIZEOF_LONG + ival = PyLong_FromLongLong((PY_LONG_LONG)sec); +#else + ival = PyInt_FromLong((long)sec); +#endif + if (!ival) + return; + fval = PyFloat_FromDouble(sec + 1e-9*nsec); + PyStructSequence_SET_ITEM(v, index, ival); + PyStructSequence_SET_ITEM(v, index+3, fval); +} + +/* pack a system stat C structure into the Python stat tuple + (used by posix_stat() and posix_fstat()) */ +static PyObject* +_pystat_fromstructstat(STRUCT_STAT *st) +{ + unsigned long ansec, mnsec, cnsec; + PyObject *v; + + PyTypeObject* StatResultType = (PyTypeObject*)import_StatResultType(); + if (StatResultType == NULL) { + return NULL; + } + + v = PyStructSequence_New(StatResultType); + if (v == NULL) + return NULL; + + PyStructSequence_SET_ITEM(v, 0, PyInt_FromLong((long)st->st_mode)); +#ifdef HAVE_LARGEFILE_SUPPORT + PyStructSequence_SET_ITEM(v, 1, + PyLong_FromLongLong((PY_LONG_LONG)st->st_ino)); +#else + PyStructSequence_SET_ITEM(v, 1, PyInt_FromLong((long)st->st_ino)); +#endif +#if defined(HAVE_LONG_LONG) && !defined(MS_WINDOWS) + PyStructSequence_SET_ITEM(v, 2, + PyLong_FromLongLong((PY_LONG_LONG)st->st_dev)); +#else + PyStructSequence_SET_ITEM(v, 2, PyInt_FromLong((long)st->st_dev)); +#endif + PyStructSequence_SET_ITEM(v, 3, PyInt_FromLong((long)st->st_nlink)); + PyStructSequence_SET_ITEM(v, 4, PyInt_FromLong((long)st->st_uid)); + PyStructSequence_SET_ITEM(v, 5, PyInt_FromLong((long)st->st_gid)); +#ifdef HAVE_LARGEFILE_SUPPORT + PyStructSequence_SET_ITEM(v, 6, + PyLong_FromLongLong((PY_LONG_LONG)st->st_size)); +#else + PyStructSequence_SET_ITEM(v, 6, PyInt_FromLong(st->st_size)); +#endif + +#if defined(HAVE_STAT_TV_NSEC) + ansec = st->st_atim.tv_nsec; + mnsec = st->st_mtim.tv_nsec; + cnsec = st->st_ctim.tv_nsec; +#elif defined(HAVE_STAT_TV_NSEC2) + ansec = st->st_atimespec.tv_nsec; + mnsec = st->st_mtimespec.tv_nsec; + cnsec = st->st_ctimespec.tv_nsec; +#elif defined(HAVE_STAT_NSEC) + ansec = st->st_atime_nsec; + mnsec = st->st_mtime_nsec; + cnsec = st->st_ctime_nsec; +#else + ansec = mnsec = cnsec = 0; +#endif + fill_time(v, 7, st->st_atime, ansec); + fill_time(v, 8, st->st_mtime, mnsec); + fill_time(v, 9, st->st_ctime, cnsec); + +#ifdef HAVE_STRUCT_STAT_ST_BLKSIZE + PyStructSequence_SET_ITEM(v, ST_BLKSIZE_IDX, + PyInt_FromLong((long)st->st_blksize)); +#endif +#ifdef HAVE_STRUCT_STAT_ST_BLOCKS + PyStructSequence_SET_ITEM(v, ST_BLOCKS_IDX, + PyInt_FromLong((long)st->st_blocks)); +#endif +#ifdef HAVE_STRUCT_STAT_ST_RDEV + PyStructSequence_SET_ITEM(v, ST_RDEV_IDX, + PyInt_FromLong((long)st->st_rdev)); +#endif +#ifdef HAVE_STRUCT_STAT_ST_GEN + PyStructSequence_SET_ITEM(v, ST_GEN_IDX, + PyInt_FromLong((long)st->st_gen)); +#endif +#ifdef HAVE_STRUCT_STAT_ST_BIRTHTIME + { + PyObject *val; + unsigned long bsec,bnsec; + bsec = (long)st->st_birthtime; +#ifdef HAVE_STAT_TV_NSEC2 + bnsec = st->st_birthtimespec.tv_nsec; +#else + bnsec = 0; +#endif + val = PyFloat_FromDouble(bsec + 1e-9*bnsec); + PyStructSequence_SET_ITEM(v, ST_BIRTHTIME_IDX, + val); + } +#endif +#ifdef HAVE_STRUCT_STAT_ST_FLAGS + PyStructSequence_SET_ITEM(v, ST_FLAGS_IDX, + PyInt_FromLong((long)st->st_flags)); +#endif + + if (PyErr_Occurred()) { + Py_DECREF(v); + return NULL; + } + + return v; +} diff --git a/python/gevent/local.py b/python/gevent/local.py new file mode 100644 index 0000000..955c320 --- /dev/null +++ b/python/gevent/local.py @@ -0,0 +1,293 @@ +""" +Greenlet-local objects. + +This module is based on `_threading_local.py`__ from the standard +library of Python 3.4. + +__ https://github.com/python/cpython/blob/3.4/Lib/_threading_local.py + +Greenlet-local objects support the management of greenlet-local data. +If you have data that you want to be local to a greenlet, simply create +a greenlet-local object and use its attributes: + + >>> mydata = local() + >>> mydata.number = 42 + >>> mydata.number + 42 + +You can also access the local-object's dictionary: + + >>> mydata.__dict__ + {'number': 42} + >>> mydata.__dict__.setdefault('widgets', []) + [] + >>> mydata.widgets + [] + +What's important about greenlet-local objects is that their data are +local to a greenlet. If we access the data in a different greenlet: + + >>> log = [] + >>> def f(): + ... items = list(mydata.__dict__.items()) + ... items.sort() + ... log.append(items) + ... mydata.number = 11 + ... log.append(mydata.number) + >>> greenlet = gevent.spawn(f) + >>> greenlet.join() + >>> log + [[], 11] + +we get different data. Furthermore, changes made in the other greenlet +don't affect data seen in this greenlet: + + >>> mydata.number + 42 + +Of course, values you get from a local object, including a __dict__ +attribute, are for whatever greenlet was current at the time the +attribute was read. For that reason, you generally don't want to save +these values across greenlets, as they apply only to the greenlet they +came from. + +You can create custom local objects by subclassing the local class: + + >>> class MyLocal(local): + ... number = 2 + ... initialized = False + ... def __init__(self, **kw): + ... if self.initialized: + ... raise SystemError('__init__ called too many times') + ... self.initialized = True + ... self.__dict__.update(kw) + ... def squared(self): + ... return self.number ** 2 + +This can be useful to support default values, methods and +initialization. Note that if you define an __init__ method, it will be +called each time the local object is used in a separate greenlet. This +is necessary to initialize each greenlet's dictionary. + +Now if we create a local object: + + >>> mydata = MyLocal(color='red') + +Now we have a default number: + + >>> mydata.number + 2 + +an initial color: + + >>> mydata.color + 'red' + >>> del mydata.color + +And a method that operates on the data: + + >>> mydata.squared() + 4 + +As before, we can access the data in a separate greenlet: + + >>> log = [] + >>> greenlet = gevent.spawn(f) + >>> greenlet.join() + >>> log + [[('color', 'red'), ('initialized', True)], 11] + +without affecting this greenlet's data: + + >>> mydata.number + 2 + >>> mydata.color + Traceback (most recent call last): + ... + AttributeError: 'MyLocal' object has no attribute 'color' + +Note that subclasses can define slots, but they are not greenlet +local. They are shared across greenlets:: + + >>> class MyLocal(local): + ... __slots__ = 'number' + + >>> mydata = MyLocal() + >>> mydata.number = 42 + >>> mydata.color = 'red' + +So, the separate greenlet: + + >>> greenlet = gevent.spawn(f) + >>> greenlet.join() + +affects what we see: + + >>> mydata.number + 11 + +>>> del mydata + +.. versionchanged:: 1.1a2 + Update the implementation to match Python 3.4 instead of Python 2.5. + This results in locals being eligible for garbage collection as soon + as their greenlet exits. + +""" + +from copy import copy +from weakref import ref +from contextlib import contextmanager +from gevent.hub import getcurrent +from gevent._compat import PYPY +from gevent.lock import RLock + +__all__ = ["local"] + + +class _wrefdict(dict): + """A dict that can be weak referenced""" + + +class _localimpl(object): + """A class managing thread-local dicts""" + __slots__ = 'key', 'dicts', 'localargs', 'locallock', '__weakref__' + + def __init__(self): + # The key used in the Thread objects' attribute dicts. + # We keep it a string for speed but make it unlikely to clash with + # a "real" attribute. + self.key = '_threading_local._localimpl.' + str(id(self)) + # { id(Thread) -> (ref(Thread), thread-local dict) } + self.dicts = _wrefdict() + + def get_dict(self): + """Return the dict for the current thread. Raises KeyError if none + defined.""" + thread = getcurrent() + return self.dicts[id(thread)][1] + + def create_dict(self): + """Create a new dict for the current thread, and return it.""" + localdict = {} + key = self.key + thread = getcurrent() + idt = id(thread) + + # If we are working with a gevent.greenlet.Greenlet, we can + # pro-actively clear out with a link. Use rawlink to avoid + # spawning any more greenlets + try: + rawlink = thread.rawlink + except AttributeError: + # Otherwise we need to do it with weak refs + def local_deleted(_, key=key): + # When the localimpl is deleted, remove the thread attribute. + thread = wrthread() + if thread is not None: + del thread.__dict__[key] + + def thread_deleted(_, idt=idt): + # When the thread is deleted, remove the local dict. + # Note that this is suboptimal if the thread object gets + # caught in a reference loop. We would like to be called + # as soon as the OS-level thread ends instead. + _local = wrlocal() + if _local is not None: + _local.dicts.pop(idt, None) + wrlocal = ref(self, local_deleted) + wrthread = ref(thread, thread_deleted) + thread.__dict__[key] = wrlocal + else: + wrdicts = ref(self.dicts) + + def clear(_): + dicts = wrdicts() + if dicts: + dicts.pop(idt, None) + rawlink(clear) + wrthread = None + + self.dicts[idt] = wrthread, localdict + return localdict + + +@contextmanager +def _patch(self): + impl = object.__getattribute__(self, '_local__impl') + orig_dct = object.__getattribute__(self, '__dict__') + try: + dct = impl.get_dict() + except KeyError: + # it's OK to acquire the lock here and not earlier, because the above code won't switch out + # however, subclassed __init__ might switch, so we do need to acquire the lock here + dct = impl.create_dict() + args, kw = impl.localargs + with impl.locallock: + self.__init__(*args, **kw) + with impl.locallock: + object.__setattr__(self, '__dict__', dct) + yield + object.__setattr__(self, '__dict__', orig_dct) + + +class local(object): + """ + An object whose attributes are greenlet-local. + """ + __slots__ = '_local__impl', '__dict__' + + def __new__(cls, *args, **kw): + if args or kw: + if (PYPY and cls.__init__ == object.__init__) or (not PYPY and cls.__init__ is object.__init__): + raise TypeError("Initialization arguments are not supported") + self = object.__new__(cls) + impl = _localimpl() + impl.localargs = (args, kw) + impl.locallock = RLock() + object.__setattr__(self, '_local__impl', impl) + # We need to create the thread dict in anticipation of + # __init__ being called, to make sure we don't call it + # again ourselves. + impl.create_dict() + return self + + def __getattribute__(self, name): + with _patch(self): + return object.__getattribute__(self, name) + + def __setattr__(self, name, value): + if name == '__dict__': + raise AttributeError( + "%r object attribute '__dict__' is read-only" + % self.__class__.__name__) + with _patch(self): + return object.__setattr__(self, name, value) + + def __delattr__(self, name): + if name == '__dict__': + raise AttributeError( + "%r object attribute '__dict__' is read-only" + % self.__class__.__name__) + with _patch(self): + return object.__delattr__(self, name) + + def __copy__(self): + impl = object.__getattribute__(self, '_local__impl') + current = getcurrent() + currentId = id(current) + d = impl.get_dict() + duplicate = copy(d) + + cls = type(self) + if (PYPY and cls.__init__ != object.__init__) or (not PYPY and cls.__init__ is not object.__init__): + args, kw = impl.localargs + instance = cls(*args, **kw) + else: + instance = cls() + + new_impl = object.__getattribute__(instance, '_local__impl') + tpl = new_impl.dicts[currentId] + new_impl.dicts[currentId] = (tpl[0], duplicate) + + return instance diff --git a/python/gevent/lock.py b/python/gevent/lock.py new file mode 100644 index 0000000..506d8c5 --- /dev/null +++ b/python/gevent/lock.py @@ -0,0 +1,260 @@ +# Copyright (c) 2009-2012 Denis Bilenko. See LICENSE for details. +"""Locking primitives""" +from __future__ import absolute_import + +from gevent.hub import getcurrent +from gevent._compat import PYPY +from gevent._semaphore import Semaphore, BoundedSemaphore # pylint:disable=no-name-in-module,import-error + + +__all__ = [ + 'Semaphore', + 'DummySemaphore', + 'BoundedSemaphore', + 'RLock', +] + +# On PyPy, we don't compile the Semaphore class with Cython. Under +# Cython, each individual method holds the GIL for its entire +# duration, ensuring that no other thread can interrupt us in an +# unsafe state (only when we _do_wait do we call back into Python and +# allow switching threads). Simulate that here through the use of a manual +# lock. (We use a separate lock for each semaphore to allow sys.settrace functions +# to use locks *other* than the one being traced.) +if PYPY: + # TODO: Need to use monkey.get_original? + try: + from _thread import allocate_lock as _allocate_lock # pylint:disable=import-error,useless-suppression + from _thread import get_ident as _get_ident # pylint:disable=import-error,useless-suppression + except ImportError: + # Python 2 + from thread import allocate_lock as _allocate_lock # pylint:disable=import-error,useless-suppression + from thread import get_ident as _get_ident # pylint:disable=import-error,useless-suppression + _sem_lock = _allocate_lock() + + def untraceable(f): + # Don't allow re-entry to these functions in a single thread, as can + # happen if a sys.settrace is used + def wrapper(self): + me = _get_ident() + try: + count = self._locking[me] + except KeyError: + count = self._locking[me] = 1 + else: + count = self._locking[me] = count + 1 + if count: + return + + try: + return f(self) + finally: + count = count - 1 + if not count: + del self._locking[me] + else: + self._locking[me] = count + return wrapper + + class _OwnedLock(object): + + def __init__(self): + self._owner = None + self._block = _allocate_lock() + self._locking = {} + self._count = 0 + + @untraceable + def acquire(self): + me = _get_ident() + if self._owner == me: + self._count += 1 + return + + self._owner = me + self._block.acquire() + self._count = 1 + + @untraceable + def release(self): + self._count = count = self._count - 1 + if not count: + self._block.release() + self._owner = None + + # acquire, wait, and release all acquire the lock on entry and release it + # on exit. acquire and wait can call _do_wait, which must release it on entry + # and re-acquire it for them on exit. + class _around(object): + __slots__ = ('before', 'after') + + def __init__(self, before, after): + self.before = before + self.after = after + + def __enter__(self): + self.before() + + def __exit__(self, t, v, tb): + self.after() + + def _decorate(func, cmname): + # functools.wrap? + def wrapped(self, *args, **kwargs): + with getattr(self, cmname): + return func(self, *args, **kwargs) + return wrapped + + Semaphore._py3k_acquire = Semaphore.acquire = _decorate(Semaphore.acquire, '_lock_locked') + Semaphore.release = _decorate(Semaphore.release, '_lock_locked') + Semaphore.wait = _decorate(Semaphore.wait, '_lock_locked') + Semaphore._do_wait = _decorate(Semaphore._do_wait, '_lock_unlocked') + + _Sem_init = Semaphore.__init__ + + def __init__(self, *args, **kwargs): + l = self._lock_lock = _OwnedLock() + self._lock_locked = _around(l.acquire, l.release) + self._lock_unlocked = _around(l.release, l.acquire) + + _Sem_init(self, *args, **kwargs) + + Semaphore.__init__ = __init__ + + del _decorate + del untraceable + + +class DummySemaphore(object): + """ + DummySemaphore(value=None) -> DummySemaphore + + A Semaphore initialized with "infinite" initial value. None of its + methods ever block. + + This can be used to parameterize on whether or not to actually + guard access to a potentially limited resource. If the resource is + actually limited, such as a fixed-size thread pool, use a real + :class:`Semaphore`, but if the resource is unbounded, use an + instance of this class. In that way none of the supporting code + needs to change. + + Similarly, it can be used to parameterize on whether or not to + enforce mutual exclusion to some underlying object. If the + underlying object is known to be thread-safe itself mutual + exclusion is not needed and a ``DummySemaphore`` can be used, but + if that's not true, use a real ``Semaphore``. + """ + + # Internally this is used for exactly the purpose described in the + # documentation. gevent.pool.Pool uses it instead of a Semaphore + # when the pool size is unlimited, and + # gevent.fileobject.FileObjectThread takes a parameter that + # determines whether it should lock around IO to the underlying + # file object. + + def __init__(self, value=None): + """ + .. versionchanged:: 1.1rc3 + Accept and ignore a *value* argument for compatibility with Semaphore. + """ + pass + + def __str__(self): + return '<%s>' % self.__class__.__name__ + + def locked(self): + """A DummySemaphore is never locked so this always returns False.""" + return False + + def release(self): + """Releasing a dummy semaphore does nothing.""" + pass + + def rawlink(self, callback): + # XXX should still work and notify? + pass + + def unlink(self, callback): + pass + + def wait(self, timeout=None): + """Waiting for a DummySemaphore returns immediately.""" + pass + + def acquire(self, blocking=True, timeout=None): + """ + A DummySemaphore can always be acquired immediately so this always + returns True and ignores its arguments. + + .. versionchanged:: 1.1a1 + Always return *true*. + """ + # pylint:disable=unused-argument + return True + + def __enter__(self): + pass + + def __exit__(self, typ, val, tb): + pass + + +class RLock(object): + + def __init__(self): + self._block = Semaphore(1) + self._owner = None + self._count = 0 + + def __repr__(self): + return "<%s at 0x%x _block=%s _count=%r _owner=%r)>" % ( + self.__class__.__name__, + id(self), + self._block, + self._count, + self._owner) + + def acquire(self, blocking=1): + me = getcurrent() + if self._owner is me: + self._count = self._count + 1 + return 1 + rc = self._block.acquire(blocking) + if rc: + self._owner = me + self._count = 1 + return rc + + def __enter__(self): + return self.acquire() + + def release(self): + if self._owner is not getcurrent(): + raise RuntimeError("cannot release un-aquired lock") + self._count = count = self._count - 1 + if not count: + self._owner = None + self._block.release() + + def __exit__(self, typ, value, tb): + self.release() + + # Internal methods used by condition variables + + def _acquire_restore(self, count_owner): + count, owner = count_owner + self._block.acquire() + self._count = count + self._owner = owner + + def _release_save(self): + count = self._count + self._count = 0 + owner = self._owner + self._owner = None + self._block.release() + return (count, owner) + + def _is_owned(self): + return self._owner is getcurrent() diff --git a/python/gevent/monkey.py b/python/gevent/monkey.py new file mode 100644 index 0000000..1f04455 --- /dev/null +++ b/python/gevent/monkey.py @@ -0,0 +1,702 @@ +# Copyright (c) 2009-2012 Denis Bilenko. See LICENSE for details. +# pylint: disable=redefined-outer-name +""" +Make the standard library cooperative. + +Patching +======== + +The primary purpose of this module is to carefully patch, in place, +portions of the standard library with gevent-friendly functions that +behave in the same way as the original (at least as closely as possible). + +The primary interface to this is the :func:`patch_all` function, which +performs all the available patches. It accepts arguments to limit the +patching to certain modules, but most programs **should** use the +default values as they receive the most wide-spread testing, and some monkey +patches have dependencies on others. + +Patching **should be done as early as possible** in the lifecycle of the +program. For example, the main module (the one that tests against +``__main__`` or is otherwise the first imported) should begin with +this code, ideally before any other imports:: + + from gevent import monkey + monkey.patch_all() + +.. tip:: + + Some frameworks, such as gunicorn, handle monkey-patching for you. + Check their documentation to be sure. + +Querying +-------- + +Sometimes it is helpful to know if objects have been monkey-patched, and in +advanced cases even to have access to the original standard library functions. This +module provides functions for that purpose. + +- :func:`is_module_patched` +- :func:`is_object_patched` +- :func:`get_original` + +Use as a module +=============== + +Sometimes it is useful to run existing python scripts or modules that +were not built to be gevent aware under gevent. To do so, this module +can be run as the main module, passing the script and its arguments. +For details, see the :func:`main` function. + +Functions +========= +""" +from __future__ import absolute_import +from __future__ import print_function +import sys + +__all__ = [ + 'patch_all', + 'patch_builtins', + 'patch_dns', + 'patch_os', + 'patch_select', + 'patch_signal', + 'patch_socket', + 'patch_ssl', + 'patch_subprocess', + 'patch_sys', + 'patch_thread', + 'patch_time', + # query functions + 'get_original', + 'is_module_patched', + 'is_object_patched', + # module functions + 'main', +] + + +if sys.version_info[0] >= 3: + string_types = (str,) + PY3 = True +else: + import __builtin__ # pylint:disable=import-error + string_types = (__builtin__.basestring,) + PY3 = False + +WIN = sys.platform.startswith("win") + +# maps module name -> {attribute name: original item} +# e.g. "time" -> {"sleep": built-in function sleep} +saved = {} + + +def is_module_patched(modname): + """Check if a module has been replaced with a cooperative version.""" + return modname in saved + + +def is_object_patched(modname, objname): + """Check if an object in a module has been replaced with a cooperative version.""" + return is_module_patched(modname) and objname in saved[modname] + + +def _get_original(name, items): + d = saved.get(name, {}) + values = [] + module = None + for item in items: + if item in d: + values.append(d[item]) + else: + if module is None: + module = __import__(name) + values.append(getattr(module, item)) + return values + + +def get_original(mod_name, item_name): + """Retrieve the original object from a module. + + If the object has not been patched, then that object will still be retrieved. + + :param item_name: A string or sequence of strings naming the attribute(s) on the module + ``mod_name`` to return. + :return: The original value if a string was given for ``item_name`` or a sequence + of original values if a sequence was passed. + """ + if isinstance(item_name, string_types): + return _get_original(mod_name, [item_name])[0] + return _get_original(mod_name, item_name) + +_NONE = object() + + +def patch_item(module, attr, newitem): + olditem = getattr(module, attr, _NONE) + if olditem is not _NONE: + saved.setdefault(module.__name__, {}).setdefault(attr, olditem) + setattr(module, attr, newitem) + + +def remove_item(module, attr): + olditem = getattr(module, attr, _NONE) + if olditem is _NONE: + return + saved.setdefault(module.__name__, {}).setdefault(attr, olditem) + delattr(module, attr) + + +def patch_module(name, items=None): + gevent_module = getattr(__import__('gevent.' + name), name) + module_name = getattr(gevent_module, '__target__', name) + module = __import__(module_name) + if items is None: + items = getattr(gevent_module, '__implements__', None) + if items is None: + raise AttributeError('%r does not have __implements__' % gevent_module) + for attr in items: + patch_item(module, attr, getattr(gevent_module, attr)) + return module + + +def _queue_warning(message, _warnings): + # Queues a warning to show after the monkey-patching process is all done. + # Done this way to avoid extra imports during the process itself, just + # in case. If we're calling a function one-off (unusual) go ahead and do it + if _warnings is None: + _process_warnings([message]) + else: + _warnings.append(message) + + +def _process_warnings(_warnings): + import warnings + for warning in _warnings: + warnings.warn(warning, RuntimeWarning, stacklevel=3) + + +def _patch_sys_std(name): + from gevent.fileobject import FileObjectThread + orig = getattr(sys, name) + if not isinstance(orig, FileObjectThread): + patch_item(sys, name, FileObjectThread(orig)) + + +def patch_sys(stdin=True, stdout=True, stderr=True): + """Patch sys.std[in,out,err] to use a cooperative IO via a threadpool. + + This is relatively dangerous and can have unintended consequences such as hanging + the process or `misinterpreting control keys`_ when ``input`` and ``raw_input`` + are used. + + This method does nothing on Python 3. The Python 3 interpreter wants to flush + the TextIOWrapper objects that make up stderr/stdout at shutdown time, but + using a threadpool at that time leads to a hang. + + .. _`misinterpreting control keys`: https://github.com/gevent/gevent/issues/274 + """ + # test__issue6.py demonstrates the hang if these lines are removed; + # strangely enough that test passes even without monkey-patching sys + if PY3: + return + + if stdin: + _patch_sys_std('stdin') + if stdout: + _patch_sys_std('stdout') + if stderr: + _patch_sys_std('stderr') + + +def patch_os(): + """ + Replace :func:`os.fork` with :func:`gevent.fork`, and, on POSIX, + :func:`os.waitpid` with :func:`gevent.os.waitpid` (if the + environment variable ``GEVENT_NOWAITPID`` is not defined). Does + nothing if fork is not available. + + .. caution:: This method must be used with :func:`patch_signal` to have proper SIGCHLD + handling and thus correct results from ``waitpid``. + :func:`patch_all` calls both by default. + + .. caution:: For SIGCHLD handling to work correctly, the event loop must run. + The easiest way to help ensure this is to use :func:`patch_all`. + """ + patch_module('os') + + +def patch_time(): + """Replace :func:`time.sleep` with :func:`gevent.sleep`.""" + from gevent.hub import sleep + import time + patch_item(time, 'sleep', sleep) + + +def _patch_existing_locks(threading): + if len(list(threading.enumerate())) != 1: + return + try: + tid = threading.get_ident() + except AttributeError: + tid = threading._get_ident() + rlock_type = type(threading.RLock()) + try: + import importlib._bootstrap + except ImportError: + class _ModuleLock(object): + pass + else: + _ModuleLock = importlib._bootstrap._ModuleLock # python 2 pylint: disable=no-member + # It might be possible to walk up all the existing stack frames to find + # locked objects...at least if they use `with`. To be sure, we look at every object + # Since we're supposed to be done very early in the process, there shouldn't be + # too many. + + # By definition there's only one thread running, so the various + # owner attributes were the old (native) thread id. Make it our + # current greenlet id so that when it wants to unlock and compare + # self.__owner with _get_ident(), they match. + gc = __import__('gc') + for o in gc.get_objects(): + if isinstance(o, rlock_type): + if hasattr(o, '_owner'): # Py3 + if o._owner is not None: + o._owner = tid + else: + if o._RLock__owner is not None: + o._RLock__owner = tid + elif isinstance(o, _ModuleLock): + if o.owner is not None: + o.owner = tid + + +def patch_thread(threading=True, _threading_local=True, Event=False, logging=True, + existing_locks=True, + _warnings=None): + """ + Replace the standard :mod:`thread` module to make it greenlet-based. + + - If *threading* is true (the default), also patch ``threading``. + - If *_threading_local* is true (the default), also patch ``_threading_local.local``. + - If *logging* is True (the default), also patch locks taken if the logging module has + been configured. + - If *existing_locks* is True (the default), and the process is still single threaded, + make sure than any :class:`threading.RLock` (and, under Python 3, :class:`importlib._bootstrap._ModuleLock`) + instances that are currently locked can be properly unlocked. + + .. caution:: + Monkey-patching :mod:`thread` and using + :class:`multiprocessing.Queue` or + :class:`concurrent.futures.ProcessPoolExecutor` (which uses a + ``Queue``) will hang the process. + + .. versionchanged:: 1.1b1 + Add *logging* and *existing_locks* params. + """ + # XXX: Simplify + # pylint:disable=too-many-branches,too-many-locals + + # Description of the hang: + # There is an incompatibility with patching 'thread' and the 'multiprocessing' module: + # The problem is that multiprocessing.queues.Queue uses a half-duplex multiprocessing.Pipe, + # which is implemented with os.pipe() and _multiprocessing.Connection. os.pipe isn't patched + # by gevent, as it returns just a fileno. _multiprocessing.Connection is an internal implementation + # class implemented in C, which exposes a 'poll(timeout)' method; under the covers, this issues a + # (blocking) select() call: hence the need for a real thread. Except for that method, we could + # almost replace Connection with gevent.fileobject.SocketAdapter, plus a trivial + # patch to os.pipe (below). Sigh, so close. (With a little work, we could replicate that method) + + # import os + # import fcntl + # os_pipe = os.pipe + # def _pipe(): + # r, w = os_pipe() + # fcntl.fcntl(r, fcntl.F_SETFL, os.O_NONBLOCK) + # fcntl.fcntl(w, fcntl.F_SETFL, os.O_NONBLOCK) + # return r, w + # os.pipe = _pipe + + # The 'threading' module copies some attributes from the + # thread module the first time it is imported. If we patch 'thread' + # before that happens, then we store the wrong values in 'saved', + # So if we're going to patch threading, we either need to import it + # before we patch thread, or manually clean up the attributes that + # are in trouble. The latter is tricky because of the different names + # on different versions. + if threading: + threading_mod = __import__('threading') + # Capture the *real* current thread object before + # we start returning DummyThread objects, for comparison + # to the main thread. + orig_current_thread = threading_mod.current_thread() + else: + threading_mod = None + orig_current_thread = None + + patch_module('thread') + + if threading: + patch_module('threading') + + if Event: + from gevent.event import Event + patch_item(threading_mod, 'Event', Event) + + if existing_locks: + _patch_existing_locks(threading_mod) + + if logging and 'logging' in sys.modules: + logging = __import__('logging') + patch_item(logging, '_lock', threading_mod.RLock()) + for wr in logging._handlerList: + # In py26, these are actual handlers, not weakrefs + handler = wr() if callable(wr) else wr + if handler is None: + continue + if not hasattr(handler, 'lock'): + raise TypeError("Unknown/unsupported handler %r" % handler) + handler.lock = threading_mod.RLock() + + if _threading_local: + _threading_local = __import__('_threading_local') + from gevent.local import local + patch_item(_threading_local, 'local', local) + + def make_join_func(thread, thread_greenlet): + from gevent.hub import sleep + from time import time + + def join(timeout=None): + end = None + if threading_mod.current_thread() is thread: + raise RuntimeError("Cannot join current thread") + if thread_greenlet is not None and thread_greenlet.dead: + return + if not thread.is_alive(): + return + + if timeout: + end = time() + timeout + + while thread.is_alive(): + if end is not None and time() > end: + return + sleep(0.01) + return join + + if threading: + from gevent.threading import main_native_thread + + for thread in threading_mod._active.values(): + if thread == main_native_thread(): + continue + thread.join = make_join_func(thread, None) + + if sys.version_info[:2] >= (3, 4): + + # Issue 18808 changes the nature of Thread.join() to use + # locks. This means that a greenlet spawned in the main thread + # (which is already running) cannot wait for the main thread---it + # hangs forever. We patch around this if possible. See also + # gevent.threading. + greenlet = __import__('greenlet') + + if orig_current_thread == threading_mod.main_thread(): + main_thread = threading_mod.main_thread() + _greenlet = main_thread._greenlet = greenlet.getcurrent() + + main_thread.join = make_join_func(main_thread, _greenlet) + + # Patch up the ident of the main thread to match. This + # matters if threading was imported before monkey-patching + # thread + oldid = main_thread.ident + main_thread._ident = threading_mod.get_ident() + if oldid in threading_mod._active: + threading_mod._active[main_thread.ident] = threading_mod._active[oldid] + if oldid != main_thread.ident: + del threading_mod._active[oldid] + else: + _queue_warning("Monkey-patching not on the main thread; " + "threading.main_thread().join() will hang from a greenlet", + _warnings) + + +def patch_socket(dns=True, aggressive=True): + """Replace the standard socket object with gevent's cooperative sockets. + + If ``dns`` is true, also patch dns functions in :mod:`socket`. + """ + from gevent import socket + # Note: although it seems like it's not strictly necessary to monkey patch 'create_connection', + # it's better to do it. If 'create_connection' was not monkey patched, but the rest of socket module + # was, create_connection would still use "green" getaddrinfo and "green" socket. + # However, because gevent.socket.socket.connect is a Python function, the exception raised by it causes + # _socket object to be referenced by the frame, thus causing the next invocation of bind(source_address) to fail. + if dns: + items = socket.__implements__ # pylint:disable=no-member + else: + items = set(socket.__implements__) - set(socket.__dns__) # pylint:disable=no-member + patch_module('socket', items=items) + if aggressive: + if 'ssl' not in socket.__implements__: # pylint:disable=no-member + remove_item(socket, 'ssl') + + +def patch_dns(): + """Replace DNS functions in :mod:`socket` with cooperative versions. + + This is only useful if :func:`patch_socket` has been called and is done automatically + by that method if requested. + """ + from gevent import socket + patch_module('socket', items=socket.__dns__) # pylint:disable=no-member + + +def patch_ssl(): + """Replace SSLSocket object and socket wrapping functions in :mod:`ssl` with cooperative versions. + + This is only useful if :func:`patch_socket` has been called. + """ + patch_module('ssl') + + +def patch_select(aggressive=True): + """ + Replace :func:`select.select` with :func:`gevent.select.select` + and :func:`select.poll` with :class:`gevent.select.poll` (where available). + + If ``aggressive`` is true (the default), also remove other + blocking functions from :mod:`select` and (on Python 3.4 and + above) :mod:`selectors`: + + - :func:`select.epoll` + - :func:`select.kqueue` + - :func:`select.kevent` + - :func:`select.devpoll` (Python 3.5+) + - :class:`selectors.EpollSelector` + - :class:`selectors.KqueueSelector` + - :class:`selectors.DevpollSelector` (Python 3.5+) + """ + patch_module('select') + if aggressive: + select = __import__('select') + # since these are blocking we're removing them here. This makes some other + # modules (e.g. asyncore) non-blocking, as they use select that we provide + # when none of these are available. + remove_item(select, 'epoll') + remove_item(select, 'kqueue') + remove_item(select, 'kevent') + remove_item(select, 'devpoll') + + if sys.version_info[:2] >= (3, 4): + # Python 3 wants to use `select.select` as a member function, + # leading to this error in selectors.py (because gevent.select.select is + # not a builtin and doesn't get the magic auto-static that they do) + # r, w, _ = self._select(self._readers, self._writers, [], timeout) + # TypeError: select() takes from 3 to 4 positional arguments but 5 were given + # Note that this obviously only happens if selectors was imported after we had patched + # select; but there is a code path that leads to it being imported first (but now we've + # patched select---so we can't compare them identically) + select = __import__('select') # Should be gevent-patched now + orig_select_select = get_original('select', 'select') + assert select.select is not orig_select_select + selectors = __import__('selectors') + if selectors.SelectSelector._select in (select.select, orig_select_select): + def _select(self, *args, **kwargs): # pylint:disable=unused-argument + return select.select(*args, **kwargs) + selectors.SelectSelector._select = _select + _select._gevent_monkey = True + + if aggressive: + # If `selectors` had already been imported before we removed + # select.epoll|kqueue|devpoll, these may have been defined in terms + # of those functions. They'll fail at runtime. + remove_item(selectors, 'EpollSelector') + remove_item(selectors, 'KqueueSelector') + remove_item(selectors, 'DevpollSelector') + selectors.DefaultSelector = selectors.SelectSelector + + +def patch_subprocess(): + """ + Replace :func:`subprocess.call`, :func:`subprocess.check_call`, + :func:`subprocess.check_output` and :class:`subprocess.Popen` with + :mod:`cooperative versions `. + + .. note:: + On Windows under Python 3, the API support may not completely match + the standard library. + + """ + patch_module('subprocess') + + +def patch_builtins(): + """ + Make the builtin __import__ function `greenlet safe`_ under Python 2. + + .. note:: + This does nothing under Python 3 as it is not necessary. Python 3 features + improved import locks that are per-module, not global. + + .. _greenlet safe: https://github.com/gevent/gevent/issues/108 + + """ + if sys.version_info[:2] < (3, 3): + patch_module('builtins') + + +def patch_signal(): + """ + Make the signal.signal function work with a monkey-patched os. + + .. caution:: This method must be used with :func:`patch_os` to have proper SIGCHLD + handling. :func:`patch_all` calls both by default. + + .. caution:: For proper SIGCHLD handling, you must yield to the event loop. + Using :func:`patch_all` is the easiest way to ensure this. + + .. seealso:: :mod:`gevent.signal` + """ + patch_module("signal") + + +def _check_repatching(**module_settings): + _warnings = [] + key = '_gevent_saved_patch_all' + if saved.get(key, module_settings) != module_settings: + _queue_warning("Patching more than once will result in the union of all True" + " parameters being patched", + _warnings) + + first_time = key not in saved + saved[key] = module_settings + return _warnings, first_time + + +def patch_all(socket=True, dns=True, time=True, select=True, thread=True, os=True, ssl=True, httplib=False, + subprocess=True, sys=False, aggressive=True, Event=False, + builtins=True, signal=True): + """ + Do all of the default monkey patching (calls every other applicable + function in this module). + + .. versionchanged:: 1.1 + Issue a :mod:`warning ` if this function is called multiple times + with different arguments. The second and subsequent calls will only add more + patches, they can never remove existing patches by setting an argument to ``False``. + .. versionchanged:: 1.1 + Issue a :mod:`warning ` if this function is called with ``os=False`` + and ``signal=True``. This will cause SIGCHLD handlers to not be called. This may + be an error in the future. + """ + # pylint:disable=too-many-locals,too-many-branches + + # Check to see if they're changing the patched list + _warnings, first_time = _check_repatching(**locals()) + if not _warnings and not first_time: + # Nothing to do, identical args to what we just + # did + return + + # order is important + if os: + patch_os() + if time: + patch_time() + if thread: + patch_thread(Event=Event, _warnings=_warnings) + # sys must be patched after thread. in other cases threading._shutdown will be + # initiated to _MainThread with real thread ident + if sys: + patch_sys() + if socket: + patch_socket(dns=dns, aggressive=aggressive) + if select: + patch_select(aggressive=aggressive) + if ssl: + patch_ssl() + if httplib: + raise ValueError('gevent.httplib is no longer provided, httplib must be False') + if subprocess: + patch_subprocess() + if builtins: + patch_builtins() + if signal: + if not os: + _queue_warning('Patching signal but not os will result in SIGCHLD handlers' + ' installed after this not being called and os.waitpid may not' + ' function correctly if gevent.subprocess is used. This may raise an' + ' error in the future.', + _warnings) + patch_signal() + + _process_warnings(_warnings) + + +def main(): + args = {} + argv = sys.argv[1:] + verbose = False + script_help, patch_all_args, modules = _get_script_help() + while argv and argv[0].startswith('--'): + option = argv[0][2:] + if option == 'verbose': + verbose = True + elif option.startswith('no-') and option.replace('no-', '') in patch_all_args: + args[option[3:]] = False + elif option in patch_all_args: + args[option] = True + if option in modules: + for module in modules: + args.setdefault(module, False) + else: + sys.exit(script_help + '\n\n' + 'Cannot patch %r' % option) + del argv[0] + # TODO: break on -- + if verbose: + import pprint + import os + print('gevent.monkey.patch_all(%s)' % ', '.join('%s=%s' % item for item in args.items())) + print('sys.version=%s' % (sys.version.strip().replace('\n', ' '), )) + print('sys.path=%s' % pprint.pformat(sys.path)) + print('sys.modules=%s' % pprint.pformat(sorted(sys.modules.keys()))) + print('cwd=%s' % os.getcwd()) + + patch_all(**args) + if argv: + sys.argv = argv + __package__ = None + assert __package__ is None + globals()['__file__'] = sys.argv[0] # issue #302 + globals()['__package__'] = None # issue #975: make script be its own package + with open(sys.argv[0]) as f: + # Be sure to exec in globals to avoid import pollution. Also #975. + exec(f.read(), globals()) + else: + print(script_help) + + +def _get_script_help(): + from inspect import getargspec + patch_all_args = getargspec(patch_all)[0] # pylint:disable=deprecated-method + modules = [x for x in patch_all_args if 'patch_' + x in globals()] + script_help = """gevent.monkey - monkey patch the standard modules to use gevent. + +USAGE: python -m gevent.monkey [MONKEY OPTIONS] script [SCRIPT OPTIONS] + +If no OPTIONS present, monkey patches all the modules it can patch. +You can exclude a module with --no-module, e.g. --no-thread. You can +specify a module to patch with --module, e.g. --socket. In the latter +case only the modules specified on the command line will be patched. + +MONKEY OPTIONS: --verbose %s""" % ', '.join('--[no-]%s' % m for m in modules) + return script_help, patch_all_args, modules + +main.__doc__ = _get_script_help()[0] + +if __name__ == '__main__': + main() diff --git a/python/gevent/os.py b/python/gevent/os.py new file mode 100644 index 0000000..fffd0dc --- /dev/null +++ b/python/gevent/os.py @@ -0,0 +1,468 @@ +""" +Low-level operating system functions from :mod:`os`. + +Cooperative I/O +=============== + +This module provides cooperative versions of :func:`os.read` and +:func:`os.write`. These functions are *not* monkey-patched; you +must explicitly call them or monkey patch them yourself. + +POSIX functions +--------------- + +On POSIX, non-blocking IO is available. + +- :func:`nb_read` +- :func:`nb_write` +- :func:`make_nonblocking` + +All Platforms +------------- + +On non-POSIX platforms (e.g., Windows), non-blocking IO is not +available. On those platforms (and on POSIX), cooperative IO can +be done with the threadpool. + +- :func:`tp_read` +- :func:`tp_write` + +Child Processes +=============== + +The functions :func:`fork` and (on POSIX) :func:`forkpty` and :func:`waitpid` can be used +to manage child processes. + +.. warning:: + + Forking a process that uses greenlets does not eliminate all non-running + greenlets. Any that were scheduled in the hub of the forking thread in the parent + remain scheduled in the child; compare this to how normal threads operate. (This behaviour + may change is a subsequent major release.) +""" + +from __future__ import absolute_import + +import os +import sys +from gevent.hub import get_hub, reinit +from gevent._compat import PY3 +from gevent._util import copy_globals +import errno + +EAGAIN = getattr(errno, 'EAGAIN', 11) + +try: + import fcntl +except ImportError: + fcntl = None + +__implements__ = ['fork'] +__extensions__ = ['tp_read', 'tp_write'] + +_read = os.read +_write = os.write + + +ignored_errors = [EAGAIN, errno.EINTR] + + +if fcntl: + + __extensions__ += ['make_nonblocking', 'nb_read', 'nb_write'] + + def make_nonblocking(fd): + """Put the file descriptor *fd* into non-blocking mode if possible. + + :return: A boolean value that evaluates to True if successful.""" + flags = fcntl.fcntl(fd, fcntl.F_GETFL, 0) + if not bool(flags & os.O_NONBLOCK): + fcntl.fcntl(fd, fcntl.F_SETFL, flags | os.O_NONBLOCK) + return True + + def nb_read(fd, n): + """Read up to `n` bytes from file descriptor `fd`. Return a string + containing the bytes read. If end-of-file is reached, an empty string + is returned. + + The descriptor must be in non-blocking mode. + """ + hub, event = None, None + while True: + try: + return _read(fd, n) + except OSError as e: + if e.errno not in ignored_errors: + raise + if not PY3: + sys.exc_clear() + if hub is None: + hub = get_hub() + event = hub.loop.io(fd, 1) + hub.wait(event) + + def nb_write(fd, buf): + """Write bytes from buffer `buf` to file descriptor `fd`. Return the + number of bytes written. + + The file descriptor must be in non-blocking mode. + """ + hub, event = None, None + while True: + try: + return _write(fd, buf) + except OSError as e: + if e.errno not in ignored_errors: + raise + if not PY3: + sys.exc_clear() + if hub is None: + hub = get_hub() + event = hub.loop.io(fd, 2) + hub.wait(event) + + +def tp_read(fd, n): + """Read up to *n* bytes from file descriptor *fd*. Return a string + containing the bytes read. If end-of-file is reached, an empty string + is returned. + + Reading is done using the threadpool. + """ + return get_hub().threadpool.apply(_read, (fd, n)) + + +def tp_write(fd, buf): + """Write bytes from buffer *buf* to file descriptor *fd*. Return the + number of bytes written. + + Writing is done using the threadpool. + """ + return get_hub().threadpool.apply(_write, (fd, buf)) + + +if hasattr(os, 'fork'): + # pylint:disable=function-redefined,redefined-outer-name + + _raw_fork = os.fork + + def fork_gevent(): + """ + Forks the process using :func:`os.fork` and prepares the + child process to continue using gevent before returning. + + .. note:: + + The PID returned by this function may not be waitable with + either the original :func:`os.waitpid` or this module's + :func:`waitpid` and it may not generate SIGCHLD signals if + libev child watchers are or ever have been in use. For + example, the :mod:`gevent.subprocess` module uses libev + child watchers (which parts of gevent use libev child + watchers is subject to change at any time). Most + applications should use :func:`fork_and_watch`, which is + monkey-patched as the default replacement for + :func:`os.fork` and implements the ``fork`` function of + this module by default, unless the environment variable + ``GEVENT_NOWAITPID`` is defined before this module is + imported. + + .. versionadded:: 1.1b2 + """ + result = _raw_fork() + if not result: + reinit() + return result + + def fork(): + """ + A wrapper for :func:`fork_gevent` for non-POSIX platforms. + """ + return fork_gevent() + + if hasattr(os, 'forkpty'): + _raw_forkpty = os.forkpty + + def forkpty_gevent(): + """ + Forks the process using :func:`os.forkpty` and prepares the + child process to continue using gevent before returning. + + Returns a tuple (pid, master_fd). The `master_fd` is *not* put into + non-blocking mode. + + Availability: Some Unix systems. + + .. seealso:: This function has the same limitations as :func:`fork_gevent`. + + .. versionadded:: 1.1b5 + """ + pid, master_fd = _raw_forkpty() + if not pid: + reinit() + return pid, master_fd + + forkpty = forkpty_gevent + + __implements__.append('forkpty') + __extensions__.append("forkpty_gevent") + + if hasattr(os, 'WNOWAIT') or hasattr(os, 'WNOHANG'): + # We can only do this on POSIX + import time + + _waitpid = os.waitpid + _WNOHANG = os.WNOHANG + + # replaced by the signal module. + _on_child_hook = lambda: None + + # {pid -> watcher or tuple(pid, rstatus, timestamp)} + _watched_children = {} + + def _on_child(watcher, callback): + # XXX: Could handle tracing here by not stopping + # until the pid is terminated + watcher.stop() + _watched_children[watcher.pid] = (watcher.pid, watcher.rstatus, time.time()) + if callback: + callback(watcher) + # dispatch an "event"; used by gevent.signal.signal + _on_child_hook() + # now is as good a time as any to reap children + _reap_children() + + def _reap_children(timeout=60): + # Remove all the dead children that haven't been waited on + # for the *timeout* seconds. + # Some platforms queue delivery of SIGCHLD for all children that die; + # in that case, a well-behaved application should call waitpid() for each + # signal. + # Some platforms (linux) only guarantee one delivery if multiple children + # die. On that platform, the well-behave application calls waitpid() in a loop + # until it gets back -1, indicating no more dead children need to be waited for. + # In either case, waitpid should be called the same number of times as dead children, + # thus removing all the watchers when a SIGCHLD arrives. The (generous) timeout + # is to work with applications that neglect to call waitpid and prevent "unlimited" + # growth. + # Note that we don't watch for the case of pid wraparound. That is, we fork a new + # child with the same pid as an existing watcher, but the child is already dead, + # just not waited on yet. + now = time.time() + oldest_allowed = now - timeout + dead = [pid for pid, val + in _watched_children.items() + if isinstance(val, tuple) and val[2] < oldest_allowed] + for pid in dead: + del _watched_children[pid] + + def waitpid(pid, options): + """ + Wait for a child process to finish. + + If the child process was spawned using + :func:`fork_and_watch`, then this function behaves + cooperatively. If not, it *may* have race conditions; see + :func:`fork_gevent` for more information. + + The arguments are as for the underlying + :func:`os.waitpid`. Some combinations of *options* may not + be supported cooperatively (as of 1.1 that includes + WUNTRACED). Using a *pid* of 0 to request waiting on only processes + from the current process group is not cooperative. + + Availability: POSIX. + + .. versionadded:: 1.1b1 + .. versionchanged:: 1.2a1 + More cases are handled in a cooperative manner. + """ + # XXX Does not handle tracing children + + # So long as libev's loop doesn't run, it's OK to add + # child watchers. The SIGCHLD handler only feeds events + # for the next iteration of the loop to handle. (And the + # signal handler itself is only called from the next loop + # iteration.) + + if pid <= 0: + # magic functions for multiple children. + if pid == -1: + # Any child. If we have one that we're watching and that finished, + # we will use that one. Otherwise, let the OS take care of it. + for k, v in _watched_children.items(): + if isinstance(v, tuple): + pid = k + break + if pid <= 0: + # We didn't have one that was ready. If there are + # no funky options set, and the pid was -1 + # (meaning any process, not 0, which means process + # group--- libev doesn't know about process + # groups) then we can use a child watcher of pid 0; otherwise, + # pass through to the OS. + if pid == -1 and options == 0: + hub = get_hub() + watcher = hub.loop.child(0, False) + hub.wait(watcher) + return watcher.rpid, watcher.rstatus + # There were funky options/pid, so we must go to the OS. + return _waitpid(pid, options) + + if pid in _watched_children: + # yes, we're watching it + if options & _WNOHANG or isinstance(_watched_children[pid], tuple): + # We're either asked not to block, or it already finished, in which + # case blocking doesn't matter + result = _watched_children[pid] + if isinstance(result, tuple): + # it finished. libev child watchers + # are one-shot + del _watched_children[pid] + return result[:2] + # it's not finished + return (0, 0) + else: + # Ok, we need to "block". Do so via a watcher so that we're + # cooperative. We know it's our child, etc, so this should work. + watcher = _watched_children[pid] + # We can't start a watcher that's already started, + # so we can't reuse the existing watcher. + new_watcher = watcher.loop.child(pid, False) + get_hub().wait(new_watcher) + # Ok, so now the new watcher is done. That means + # the old watcher's callback (_on_child) should + # have fired, potentially taking this child out of + # _watched_children (but that could depend on how + # many callbacks there were to run, so use the + # watcher object directly; libev sets all the + # watchers at the same time). + return watcher.rpid, watcher.rstatus + + # we're not watching it and it may not even be our child, + # so we must go to the OS to be sure to get the right semantics (exception) + return _waitpid(pid, options) + + def fork_and_watch(callback=None, loop=None, ref=False, fork=fork_gevent): + """ + Fork a child process and start a child watcher for it in the parent process. + + This call cooperates with :func:`waitpid` to enable cooperatively waiting + for children to finish. When monkey-patching, these functions are patched in as + :func:`os.fork` and :func:`os.waitpid`, respectively. + + In the child process, this function calls :func:`gevent.hub.reinit` before returning. + + Availability: POSIX. + + :keyword callback: If given, a callable that will be called with the child watcher + when the child finishes. + :keyword loop: The loop to start the watcher in. Defaults to the + loop of the current hub. + :keyword fork: The fork function. Defaults to :func:`the one defined in this + module ` (which automatically calls :func:`gevent.hub.reinit`). + Pass the builtin :func:`os.fork` function if you do not need to + initialize gevent in the child process. + + .. versionadded:: 1.1b1 + .. seealso:: + :func:`gevent.monkey.get_original` To access the builtin :func:`os.fork`. + """ + pid = fork() + if pid: + # parent + loop = loop or get_hub().loop + watcher = loop.child(pid, ref=ref) + _watched_children[pid] = watcher + watcher.start(_on_child, watcher, callback) + return pid + + __extensions__.append('fork_and_watch') + __extensions__.append('fork_gevent') + + if 'forkpty' in __implements__: + def forkpty_and_watch(callback=None, loop=None, ref=False, forkpty=forkpty_gevent): + """ + Like :func:`fork_and_watch`, except using :func:`forkpty_gevent`. + + Availability: Some Unix systems. + + .. versionadded:: 1.1b5 + """ + result = [] + + def _fork(): + pid_and_fd = forkpty() + result.append(pid_and_fd) + return pid_and_fd[0] + fork_and_watch(callback, loop, ref, _fork) + return result[0] + + __extensions__.append('forkpty_and_watch') + + # Watch children by default + if not os.getenv('GEVENT_NOWAITPID'): + # Broken out into separate functions instead of simple name aliases + # for documentation purposes. + def fork(*args, **kwargs): + """ + Forks a child process and starts a child watcher for it in the + parent process so that ``waitpid`` and SIGCHLD work as expected. + + This implementation of ``fork`` is a wrapper for :func:`fork_and_watch` + when the environment variable ``GEVENT_NOWAITPID`` is *not* defined. + This is the default and should be used by most applications. + + .. versionchanged:: 1.1b2 + """ + # take any args to match fork_and_watch + return fork_and_watch(*args, **kwargs) + + if 'forkpty' in __implements__: + def forkpty(*args, **kwargs): + """ + Like :func:`fork`, but using :func:`forkpty_gevent`. + + This implementation of ``forkpty`` is a wrapper for :func:`forkpty_and_watch` + when the environment variable ``GEVENT_NOWAITPID`` is *not* defined. + This is the default and should be used by most applications. + + .. versionadded:: 1.1b5 + """ + # take any args to match fork_and_watch + return forkpty_and_watch(*args, **kwargs) + __implements__.append("waitpid") + else: + def fork(): + """ + Forks a child process, initializes gevent in the child, + but *does not* prepare the parent to wait for the child or receive SIGCHLD. + + This implementation of ``fork`` is a wrapper for :func:`fork_gevent` + when the environment variable ``GEVENT_NOWAITPID`` *is* defined. + This is not recommended for most applications. + """ + return fork_gevent() + + if 'forkpty' in __implements__: + def forkpty(): + """ + Like :func:`fork`, but using :func:`os.forkpty` + + This implementation of ``forkpty`` is a wrapper for :func:`forkpty_gevent` + when the environment variable ``GEVENT_NOWAITPID`` *is* defined. + This is not recommended for most applications. + + .. versionadded:: 1.1b5 + """ + return forkpty_gevent() + __extensions__.append("waitpid") + +else: + __implements__.remove('fork') + +__imports__ = copy_globals(os, globals(), + names_to_ignore=__implements__ + __extensions__, + dunder_names_to_keep=()) + +__all__ = list(set(__implements__ + __extensions__)) diff --git a/python/gevent/pool.py b/python/gevent/pool.py new file mode 100644 index 0000000..d0c5cbb --- /dev/null +++ b/python/gevent/pool.py @@ -0,0 +1,759 @@ +# Copyright (c) 2009-2011 Denis Bilenko. See LICENSE for details. +""" +Managing greenlets in a group. + +The :class:`Group` class in this module abstracts a group of running +greenlets. When a greenlet dies, it's automatically removed from the +group. All running greenlets in a group can be waited on with +:meth:`Group.join`, or all running greenlets can be killed with +:meth:`Group.kill`. + +The :class:`Pool` class, which is a subclass of :class:`Group`, +provides a way to limit concurrency: its :meth:`spawn ` +method blocks if the number of greenlets in the pool has already +reached the limit, until there is a free slot. +""" + +from bisect import insort_right +try: + from itertools import izip +except ImportError: + # Python 3 + izip = zip + +from gevent.hub import GreenletExit, getcurrent, kill as _kill +from gevent.greenlet import joinall, Greenlet +from gevent.timeout import Timeout +from gevent.event import Event +from gevent.lock import Semaphore, DummySemaphore + +__all__ = ['Group', 'Pool'] + + +class IMapUnordered(Greenlet): + """ + At iterator of map results. + """ + + _zipped = False + + def __init__(self, func, iterable, spawn=None, maxsize=None, _zipped=False): + """ + An iterator that. + + :keyword int maxsize: If given and not-None, specifies the maximum number of + finished results that will be allowed to accumulated awaiting the reader; + more than that number of results will cause map function greenlets to begin + to block. This is most useful is there is a great disparity in the speed of + the mapping code and the consumer and the results consume a great deal of resources. + Using a bound is more computationally expensive than not using a bound. + + .. versionchanged:: 1.1b3 + Added the *maxsize* parameter. + """ + from gevent.queue import Queue + Greenlet.__init__(self) + if spawn is not None: + self.spawn = spawn + if _zipped: + self._zipped = _zipped + self.func = func + self.iterable = iterable + self.queue = Queue() + if maxsize: + # Bounding the queue is not enough if we want to keep from + # accumulating objects; the result value will be around as + # the greenlet's result, blocked on self.queue.put(), and + # we'll go on to spawn another greenlet, which in turn can + # create the result. So we need a semaphore to prevent a + # greenlet from exiting while the queue is full so that we + # don't spawn the next greenlet (assuming that self.spawn + # is of course bounded). (Alternatively we could have the + # greenlet itself do the insert into the pool, but that + # takes some rework). + # + # Given the use of a semaphore at this level, sizing the queue becomes + # redundant, and that lets us avoid having to use self.link() instead + # of self.rawlink() to avoid having blocking methods called in the + # hub greenlet. + factory = Semaphore + else: + factory = DummySemaphore + self._result_semaphore = factory(maxsize) + + self.count = 0 + self.finished = False + # If the queue size is unbounded, then we want to call all + # the links (_on_finish and _on_result) directly in the hub greenlet + # for efficiency. However, if the queue is bounded, we can't do that if + # the queue might block (because if there's no waiter the hub can switch to, + # the queue simply raises Full). Therefore, in that case, we use + # the safer, somewhat-slower (because it spawns a greenlet) link() methods. + # This means that _on_finish and _on_result can be called and interleaved in any order + # if the call to self.queue.put() blocks.. + # Note that right now we're not bounding the queue, instead using a semaphore. + self.rawlink(self._on_finish) + + def __iter__(self): + return self + + def next(self): + self._result_semaphore.release() + value = self._inext() + if isinstance(value, Failure): + raise value.exc + return value + __next__ = next + + def _inext(self): + return self.queue.get() + + def _ispawn(self, func, item): + self._result_semaphore.acquire() + self.count += 1 + g = self.spawn(func, item) if not self._zipped else self.spawn(func, *item) + g.rawlink(self._on_result) + return g + + def _run(self): # pylint:disable=method-hidden + try: + func = self.func + for item in self.iterable: + self._ispawn(func, item) + finally: + self.__dict__.pop('spawn', None) + self.__dict__.pop('func', None) + self.__dict__.pop('iterable', None) + + def _on_result(self, greenlet): + # This method can either be called in the hub greenlet (if the + # queue is unbounded) or its own greenlet. If it's called in + # its own greenlet, the calls to put() may block and switch + # greenlets, which in turn could mutate our state. So any + # state on this object that we need to look at, notably + # self.count, we need to capture or mutate *before* we put. + # (Note that right now we're not bounding the queue, but we may + # choose to do so in the future so this implementation will be left in case.) + self.count -= 1 + count = self.count + finished = self.finished + ready = self.ready() + put_finished = False + + if ready and count <= 0 and not finished: + finished = self.finished = True + put_finished = True + + if greenlet.successful(): + self.queue.put(self._iqueue_value_for_success(greenlet)) + else: + self.queue.put(self._iqueue_value_for_failure(greenlet)) + + if put_finished: + self.queue.put(self._iqueue_value_for_finished()) + + def _on_finish(self, _self): + if self.finished: + return + + if not self.successful(): + self.finished = True + self.queue.put(self._iqueue_value_for_self_failure()) + return + + if self.count <= 0: + self.finished = True + self.queue.put(self._iqueue_value_for_finished()) + + def _iqueue_value_for_success(self, greenlet): + return greenlet.value + + def _iqueue_value_for_failure(self, greenlet): + return Failure(greenlet.exception, getattr(greenlet, '_raise_exception')) + + def _iqueue_value_for_finished(self): + return Failure(StopIteration) + + def _iqueue_value_for_self_failure(self): + return Failure(self.exception, self._raise_exception) + + +class IMap(IMapUnordered): + # A specialization of IMapUnordered that returns items + # in the order in which they were generated, not + # the order in which they finish. + # We do this by storing tuples (order, value) in the queue + # not just value. + + def __init__(self, *args, **kwargs): + self.waiting = [] # QQQ maybe deque will work faster there? + self.index = 0 + self.maxindex = -1 + IMapUnordered.__init__(self, *args, **kwargs) + + def _inext(self): + while True: + if self.waiting and self.waiting[0][0] <= self.index: + _, value = self.waiting.pop(0) + else: + index, value = self.queue.get() + if index > self.index: + insort_right(self.waiting, (index, value)) + continue + self.index += 1 + return value + + def _ispawn(self, func, item): + g = IMapUnordered._ispawn(self, func, item) + self.maxindex += 1 + g.index = self.maxindex + return g + + def _iqueue_value_for_success(self, greenlet): + return (greenlet.index, IMapUnordered._iqueue_value_for_success(self, greenlet)) + + def _iqueue_value_for_failure(self, greenlet): + return (greenlet.index, IMapUnordered._iqueue_value_for_failure(self, greenlet)) + + def _iqueue_value_for_finished(self): + self.maxindex += 1 + return (self.maxindex, IMapUnordered._iqueue_value_for_finished(self)) + + def _iqueue_value_for_self_failure(self): + self.maxindex += 1 + return (self.maxindex, IMapUnordered._iqueue_value_for_self_failure(self)) + + +class GroupMappingMixin(object): + # Internal, non-public API class. + # Provides mixin methods for implementing mapping pools. Subclasses must define: + + # - self.spawn(func, *args, **kwargs): a function that runs `func` with `args` + # and `awargs`, potentially asynchronously. Return a value with a `get` method that + # blocks until the results of func are available, and a `link` method. + + # - self._apply_immediately(): should the function passed to apply be called immediately, + # synchronously? + + # - self._apply_async_use_greenlet(): Should apply_async directly call + # Greenlet.spawn(), bypassing self.spawn? Return true when self.spawn would block + + # - self._apply_async_cb_spawn(callback, result): Run the given callback function, possiblly + # asynchronously, possibly synchronously. + + def apply_cb(self, func, args=None, kwds=None, callback=None): + """ + :meth:`apply` the given *func(\\*args, \\*\\*kwds)*, and, if a *callback* is given, run it with the + results of *func* (unless an exception was raised.) + + The *callback* may be called synchronously or asynchronously. If called + asynchronously, it will not be tracked by this group. (:class:`Group` and :class:`Pool` + call it asynchronously in a new greenlet; :class:`~gevent.threadpool.ThreadPool` calls + it synchronously in the current greenlet.) + """ + result = self.apply(func, args, kwds) + if callback is not None: + self._apply_async_cb_spawn(callback, result) + return result + + def apply_async(self, func, args=None, kwds=None, callback=None): + """ + A variant of the :meth:`apply` method which returns a :class:`~.Greenlet` object. + + When the returned greenlet gets to run, it *will* call :meth:`apply`, + passing in *func*, *args* and *kwds*. + + If *callback* is specified, then it should be a callable which + accepts a single argument. When the result becomes ready + callback is applied to it (unless the call failed). + + This method will never block, even if this group is full (that is, + even if :meth:`spawn` would block, this method will not). + + .. caution:: The returned greenlet may or may not be tracked + as part of this group, so :meth:`joining ` this group is + not a reliable way to wait for the results to be available or + for the returned greenlet to run; instead, join the returned + greenlet. + + .. tip:: Because :class:`~.ThreadPool` objects do not track greenlets, the returned + greenlet will never be a part of it. To reduce overhead and improve performance, + :class:`Group` and :class:`Pool` may choose to track the returned + greenlet. These are implementation details that may change. + """ + if args is None: + args = () + if kwds is None: + kwds = {} + if self._apply_async_use_greenlet(): + # cannot call self.spawn() directly because it will block + # XXX: This is always the case for ThreadPool, but for Group/Pool + # of greenlets, this is only the case when they are full...hence + # the weasely language about "may or may not be tracked". Should we make + # Group/Pool always return true as well so it's never tracked by any + # implementation? That would simplify that logic, but could increase + # the total number of greenlets in the system and add a layer of + # overhead for the simple cases when the pool isn't full. + return Greenlet.spawn(self.apply_cb, func, args, kwds, callback) + + greenlet = self.spawn(func, *args, **kwds) + if callback is not None: + greenlet.link(pass_value(callback)) + return greenlet + + def apply(self, func, args=None, kwds=None): + """ + Rough quivalent of the :func:`apply()` builtin function blocking until + the result is ready and returning it. + + The ``func`` will *usually*, but not *always*, be run in a way + that allows the current greenlet to switch out (for example, + in a new greenlet or thread, depending on implementation). But + if the current greenlet or thread is already one that was + spawned by this pool, the pool may choose to immediately run + the `func` synchronously. + + Any exception ``func`` raises will be propagated to the caller of ``apply`` (that is, + this method will raise the exception that ``func`` raised). + """ + if args is None: + args = () + if kwds is None: + kwds = {} + if self._apply_immediately(): + return func(*args, **kwds) + return self.spawn(func, *args, **kwds).get() + + def map(self, func, iterable): + """Return a list made by applying the *func* to each element of + the iterable. + + .. seealso:: :meth:`imap` + """ + return list(self.imap(func, iterable)) + + def map_cb(self, func, iterable, callback=None): + result = self.map(func, iterable) + if callback is not None: + callback(result) + return result + + def map_async(self, func, iterable, callback=None): + """ + A variant of the map() method which returns a Greenlet object that is executing + the map function. + + If callback is specified then it should be a callable which accepts a + single argument. + """ + return Greenlet.spawn(self.map_cb, func, iterable, callback) + + def __imap(self, cls, func, *iterables, **kwargs): + # Python 2 doesn't support the syntax that lets us mix varargs and + # a named kwarg, so we have to unpack manually + maxsize = kwargs.pop('maxsize', None) + if kwargs: + raise TypeError("Unsupported keyword arguments") + return cls.spawn(func, izip(*iterables), spawn=self.spawn, + _zipped=True, maxsize=maxsize) + + def imap(self, func, *iterables, **kwargs): + """ + imap(func, *iterables, maxsize=None) -> iterable + + An equivalent of :func:`itertools.imap`, operating in parallel. + The *func* is applied to each element yielded from each + iterable in *iterables* in turn, collecting the result. + + If this object has a bound on the number of active greenlets it can + contain (such as :class:`Pool`), then at most that number of tasks will operate + in parallel. + + :keyword int maxsize: If given and not-None, specifies the maximum number of + finished results that will be allowed to accumulate awaiting the reader; + more than that number of results will cause map function greenlets to begin + to block. This is most useful if there is a great disparity in the speed of + the mapping code and the consumer and the results consume a great deal of resources. + + .. note:: This is separate from any bound on the number of active parallel + tasks, though they may have some interaction (for example, limiting the + number of parallel tasks to the smallest bound). + + .. note:: Using a bound is slightly more computationally expensive than not using a bound. + + .. tip:: The :meth:`imap_unordered` method makes much better + use of this parameter. Some additional, unspecified, + number of objects may be required to be kept in memory + to maintain order by this function. + + :return: An iterable object. + + .. versionchanged:: 1.1b3 + Added the *maxsize* keyword parameter. + .. versionchanged:: 1.1a1 + Accept multiple *iterables* to iterate in parallel. + """ + return self.__imap(IMap, func, *iterables, **kwargs) + + def imap_unordered(self, func, *iterables, **kwargs): + """ + imap_unordered(func, *iterables, maxsize=None) -> iterable + + The same as :meth:`imap` except that the ordering of the results + from the returned iterator should be considered in arbitrary + order. + + This is lighter weight than :meth:`imap` and should be preferred if order + doesn't matter. + + .. seealso:: :meth:`imap` for more details. + """ + return self.__imap(IMapUnordered, func, *iterables, **kwargs) + + +class Group(GroupMappingMixin): + """ + Maintain a group of greenlets that are still running, without + limiting their number. + + Links to each item and removes it upon notification. + + Groups can be iterated to discover what greenlets they are tracking, + they can be tested to see if they contain a greenlet, and they know the + number (len) of greenlets they are tracking. If they are not tracking any + greenlets, they are False in a boolean context. + """ + + #: The type of Greenlet object we will :meth:`spawn`. This can be changed + #: on an instance or in a subclass. + greenlet_class = Greenlet + + def __init__(self, *args): + assert len(args) <= 1, args + self.greenlets = set(*args) + if args: + for greenlet in args[0]: + greenlet.rawlink(self._discard) + # each item we kill we place in dying, to avoid killing the same greenlet twice + self.dying = set() + self._empty_event = Event() + self._empty_event.set() + + def __repr__(self): + return '<%s at 0x%x %s>' % (self.__class__.__name__, id(self), self.greenlets) + + def __len__(self): + """ + Answer how many greenlets we are tracking. Note that if we are empty, + we are False in a boolean context. + """ + return len(self.greenlets) + + def __contains__(self, item): + """ + Answer if we are tracking the given greenlet. + """ + return item in self.greenlets + + def __iter__(self): + """ + Iterate across all the greenlets we are tracking, in no particular order. + """ + return iter(self.greenlets) + + def add(self, greenlet): + """ + Begin tracking the greenlet. + + If this group is :meth:`full`, then this method may block + until it is possible to track the greenlet. + """ + try: + rawlink = greenlet.rawlink + except AttributeError: + pass # non-Greenlet greenlet, like MAIN + else: + rawlink(self._discard) + self.greenlets.add(greenlet) + self._empty_event.clear() + + def _discard(self, greenlet): + self.greenlets.discard(greenlet) + self.dying.discard(greenlet) + if not self.greenlets: + self._empty_event.set() + + def discard(self, greenlet): + """ + Stop tracking the greenlet. + """ + self._discard(greenlet) + try: + unlink = greenlet.unlink + except AttributeError: + pass # non-Greenlet greenlet, like MAIN + else: + unlink(self._discard) + + def start(self, greenlet): + """ + Start the un-started *greenlet* and add it to the collection of greenlets + this group is monitoring. + """ + self.add(greenlet) + greenlet.start() + + def spawn(self, *args, **kwargs): + """ + Begin a new greenlet with the given arguments (which are passed + to the greenlet constructor) and add it to the collection of greenlets + this group is monitoring. + + :return: The newly started greenlet. + """ + greenlet = self.greenlet_class(*args, **kwargs) + self.start(greenlet) + return greenlet + +# def close(self): +# """Prevents any more tasks from being submitted to the pool""" +# self.add = RaiseException("This %s has been closed" % self.__class__.__name__) + + def join(self, timeout=None, raise_error=False): + """ + Wait for this group to become empty *at least once*. + + If there are no greenlets in the group, returns immediately. + + .. note:: By the time the waiting code (the caller of this + method) regains control, a greenlet may have been added to + this group, and so this object may no longer be empty. (That + is, ``group.join(); assert len(group) == 0`` is not + guaranteed to hold.) This method only guarantees that the group + reached a ``len`` of 0 at some point. + + :keyword bool raise_error: If True (*not* the default), if any + greenlet that finished while the join was in progress raised + an exception, that exception will be raised to the caller of + this method. If multiple greenlets raised exceptions, which + one gets re-raised is not determined. Only greenlets currently + in the group when this method is called are guaranteed to + be checked for exceptions. + + :return bool: A value indicating whether this group became empty. + If the timeout is specified and the group did not become empty + during that timeout, then this will be a false value. Otherwise + it will be a true value. + + .. versionchanged:: 1.2a1 + Add the return value. + """ + greenlets = list(self.greenlets) if raise_error else () + result = self._empty_event.wait(timeout=timeout) + + for greenlet in greenlets: + if greenlet.exception is not None: + if hasattr(greenlet, '_raise_exception'): + greenlet._raise_exception() + raise greenlet.exception + + return result + + def kill(self, exception=GreenletExit, block=True, timeout=None): + """ + Kill all greenlets being tracked by this group. + """ + timer = Timeout._start_new_or_dummy(timeout) + try: + while self.greenlets: + for greenlet in list(self.greenlets): + if greenlet in self.dying: + continue + try: + kill = greenlet.kill + except AttributeError: + _kill(greenlet, exception) + else: + kill(exception, block=False) + self.dying.add(greenlet) + if not block: + break + joinall(self.greenlets) + except Timeout as ex: + if ex is not timer: + raise + finally: + timer.cancel() + + def killone(self, greenlet, exception=GreenletExit, block=True, timeout=None): + """ + If the given *greenlet* is running and being tracked by this group, + kill it. + """ + if greenlet not in self.dying and greenlet in self.greenlets: + greenlet.kill(exception, block=False) + self.dying.add(greenlet) + if block: + greenlet.join(timeout) + + def full(self): + """ + Return a value indicating whether this group can track more greenlets. + + In this implementation, because there are no limits on the number of + tracked greenlets, this will always return a ``False`` value. + """ + return False + + def wait_available(self, timeout=None): + """ + Block until it is possible to :meth:`spawn` a new greenlet. + + In this implementation, because there are no limits on the number + of tracked greenlets, this will always return immediately. + """ + pass + + # MappingMixin methods + + def _apply_immediately(self): + # If apply() is called from one of our own + # worker greenlets, don't spawn a new one---if we're full, that + # could deadlock. + return getcurrent() in self + + def _apply_async_cb_spawn(self, callback, result): + Greenlet.spawn(callback, result) + + def _apply_async_use_greenlet(self): + # cannot call self.spawn() because it will block, so + # use a fresh, untracked greenlet that when run will + # (indirectly) call self.spawn() for us. + return self.full() + + +class Failure(object): + __slots__ = ['exc', '_raise_exception'] + + def __init__(self, exc, raise_exception=None): + self.exc = exc + self._raise_exception = raise_exception + + def raise_exc(self): + if self._raise_exception: + self._raise_exception() + else: + raise self.exc + + +class Pool(Group): + + def __init__(self, size=None, greenlet_class=None): + """ + Create a new pool. + + A pool is like a group, but the maximum number of members + is governed by the *size* parameter. + + :keyword int size: If given, this non-negative integer is the + maximum count of active greenlets that will be allowed in + this pool. A few values have special significance: + + * ``None`` (the default) places no limit on the number of + greenlets. This is useful when you need to track, but not limit, + greenlets, as with :class:`gevent.pywsgi.WSGIServer`. A :class:`Group` + may be a more efficient way to achieve the same effect. + * ``0`` creates a pool that can never have any active greenlets. Attempting + to spawn in this pool will block forever. This is only useful + if an application uses :meth:`wait_available` with a timeout and checks + :meth:`free_count` before attempting to spawn. + """ + if size is not None and size < 0: + raise ValueError('size must not be negative: %r' % (size, )) + Group.__init__(self) + self.size = size + if greenlet_class is not None: + self.greenlet_class = greenlet_class + if size is None: + factory = DummySemaphore + else: + factory = Semaphore + self._semaphore = factory(size) + + def wait_available(self, timeout=None): + """ + Wait until it's possible to spawn a greenlet in this pool. + + :param float timeout: If given, only wait the specified number + of seconds. + + .. warning:: If the pool was initialized with a size of 0, this + method will block forever unless a timeout is given. + + :return: A number indicating how many new greenlets can be put into + the pool without blocking. + + .. versionchanged:: 1.1a3 + Added the ``timeout`` parameter. + """ + return self._semaphore.wait(timeout=timeout) + + def full(self): + """ + Return a boolean indicating whether this pool has any room for + members. (True if it does, False if it doesn't.) + """ + return self.free_count() <= 0 + + def free_count(self): + """ + Return a number indicating *approximately* how many more members + can be added to this pool. + """ + if self.size is None: + return 1 + return max(0, self.size - len(self)) + + def add(self, greenlet): + """ + Begin tracking the given greenlet, blocking until space is available. + + .. seealso:: :meth:`Group.add` + """ + self._semaphore.acquire() + try: + Group.add(self, greenlet) + except: + self._semaphore.release() + raise + + def _discard(self, greenlet): + Group._discard(self, greenlet) + self._semaphore.release() + + +class pass_value(object): + __slots__ = ['callback'] + + def __init__(self, callback): + self.callback = callback + + def __call__(self, source): + if source.successful(): + self.callback(source.value) + + def __hash__(self): + return hash(self.callback) + + def __eq__(self, other): + return self.callback == getattr(other, 'callback', other) + + def __str__(self): + return str(self.callback) + + def __repr__(self): + return repr(self.callback) + + def __getattr__(self, item): + assert item != 'callback' + return getattr(self.callback, item) diff --git a/python/gevent/python.pxd b/python/gevent/python.pxd new file mode 100644 index 0000000..b4635b1 --- /dev/null +++ b/python/gevent/python.pxd @@ -0,0 +1,17 @@ +cdef extern from "Python.h": + struct PyObject: + pass + ctypedef PyObject* PyObjectPtr "PyObject*" + void Py_INCREF(PyObjectPtr) + void Py_DECREF(PyObjectPtr) + void Py_XDECREF(PyObjectPtr) + int Py_ReprEnter(PyObjectPtr) + void Py_ReprLeave(PyObjectPtr) + int PyCallable_Check(PyObjectPtr) + +cdef extern from "frameobject.h": + ctypedef struct PyThreadState: + PyObjectPtr exc_type + PyObjectPtr exc_value + PyObjectPtr exc_traceback + PyThreadState* PyThreadState_GET() diff --git a/python/gevent/pywsgi.py b/python/gevent/pywsgi.py new file mode 100644 index 0000000..2726f6d --- /dev/null +++ b/python/gevent/pywsgi.py @@ -0,0 +1,1509 @@ +# Copyright (c) 2005-2009, eventlet contributors +# Copyright (c) 2009-2015, gevent contributors +""" +A pure-Python, gevent-friendly WSGI server. + +The server is provided in :class:`WSGIServer`, but most of the actual +WSGI work is handled by :class:`WSGIHandler` --- a new instance is +created for each request. The server can be customized to use +different subclasses of :class:`WSGIHandler`. + +""" +# FIXME: Can we refactor to make smallor? +# pylint:disable=too-many-lines + +import errno +from io import BytesIO +import string +import sys +import time +import traceback +from datetime import datetime + +try: + from urllib import unquote +except ImportError: + from urllib.parse import unquote # python 2 pylint:disable=import-error,no-name-in-module + +from gevent import socket +import gevent +from gevent.server import StreamServer +from gevent.hub import GreenletExit +from gevent._compat import PY3, reraise + +from functools import partial +if PY3: + unquote_latin1 = partial(unquote, encoding='latin-1') +else: + unquote_latin1 = unquote + +_no_undoc_members = True # Don't put undocumented things into sphinx + +__all__ = [ + 'WSGIServer', + 'WSGIHandler', + 'LoggingLogAdapter', + 'Environ', + 'SecureEnviron', + 'WSGISecureEnviron', +] + + +MAX_REQUEST_LINE = 8192 +# Weekday and month names for HTTP date/time formatting; always English! +_WEEKDAYNAME = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"] +_MONTHNAME = [None, # Dummy so we can use 1-based month numbers + "Jan", "Feb", "Mar", "Apr", "May", "Jun", + "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"] + +# The contents of the "HEX" grammar rule for HTTP, upper and lowercase A-F plus digits, +# in byte form for comparing to the network. +_HEX = string.hexdigits.encode('ascii') + +# Errors +_ERRORS = dict() +_INTERNAL_ERROR_STATUS = '500 Internal Server Error' +_INTERNAL_ERROR_BODY = b'Internal Server Error' +_INTERNAL_ERROR_HEADERS = [('Content-Type', 'text/plain'), + ('Connection', 'close'), + ('Content-Length', str(len(_INTERNAL_ERROR_BODY)))] +_ERRORS[500] = (_INTERNAL_ERROR_STATUS, _INTERNAL_ERROR_HEADERS, _INTERNAL_ERROR_BODY) + +_BAD_REQUEST_STATUS = '400 Bad Request' +_BAD_REQUEST_BODY = '' +_BAD_REQUEST_HEADERS = [('Content-Type', 'text/plain'), + ('Connection', 'close'), + ('Content-Length', str(len(_BAD_REQUEST_BODY)))] +_ERRORS[400] = (_BAD_REQUEST_STATUS, _BAD_REQUEST_HEADERS, _BAD_REQUEST_BODY) + +_REQUEST_TOO_LONG_RESPONSE = b"HTTP/1.1 414 Request URI Too Long\r\nConnection: close\r\nContent-length: 0\r\n\r\n" +_BAD_REQUEST_RESPONSE = b"HTTP/1.1 400 Bad Request\r\nConnection: close\r\nContent-length: 0\r\n\r\n" +_CONTINUE_RESPONSE = b"HTTP/1.1 100 Continue\r\n\r\n" + + +def format_date_time(timestamp): + # Return a byte-string of the date and time in HTTP format + # .. versionchanged:: 1.1b5 + # Return a byte string, not a native string + year, month, day, hh, mm, ss, wd, _y, _z = time.gmtime(timestamp) + value = "%s, %02d %3s %4d %02d:%02d:%02d GMT" % (_WEEKDAYNAME[wd], day, _MONTHNAME[month], year, hh, mm, ss) + if PY3: + value = value.encode("latin-1") + return value + + +class _InvalidClientInput(IOError): + # Internal exception raised by Input indicating that the client + # sent invalid data at the lowest level of the stream. The result + # *should* be a HTTP 400 error. + pass + + +class _InvalidClientRequest(ValueError): + # Internal exception raised by WSGIHandler.read_request + # indicating that the client sent an HTTP request that cannot + # be parsed (e.g., invalid grammar). The result *should* be an + # HTTP 400 error + pass + + +class Input(object): + + __slots__ = ('rfile', 'content_length', 'socket', 'position', + 'chunked_input', 'chunk_length', '_chunked_input_error') + + def __init__(self, rfile, content_length, socket=None, chunked_input=False): + # pylint:disable=redefined-outer-name + self.rfile = rfile + self.content_length = content_length + self.socket = socket + self.position = 0 + self.chunked_input = chunked_input + self.chunk_length = -1 + self._chunked_input_error = False + + def _discard(self): + if self._chunked_input_error: + # We are in an unknown state, so we can't necessarily discard + # the body (e.g., if the client keeps the socket open, we could hang + # here forever). + # In this case, we've raised an exception and the user of this object + # is going to close the socket, so we don't have to discard + return + + if self.socket is None and (self.position < (self.content_length or 0) or self.chunked_input): + # ## Read and discard body + while 1: + d = self.read(16384) + if not d: + break + + def _send_100_continue(self): + if self.socket is not None: + self.socket.sendall(_CONTINUE_RESPONSE) + self.socket = None + + def _do_read(self, length=None, use_readline=False): + if use_readline: + reader = self.rfile.readline + else: + reader = self.rfile.read + content_length = self.content_length + if content_length is None: + # Either Content-Length or "Transfer-Encoding: chunked" must be present in a request with a body + # if it was chunked, then this function would have not been called + return b'' + + self._send_100_continue() + left = content_length - self.position + if length is None: + length = left + elif length > left: + length = left + if not length: + return b'' + + # On Python 2, self.rfile is usually socket.makefile(), which + # uses cStringIO.StringIO. If *length* is greater than the C + # sizeof(int) (typically 32 bits signed), parsing the argument to + # readline raises OverflowError. StringIO.read(), OTOH, uses + # PySize_t, typically a long (64 bits). In a bare readline() + # case, because the header lines we're trying to read with + # readline are typically expected to be small, we can correct + # that failure by simply doing a smaller call to readline and + # appending; failures in read we let propagate. + try: + read = reader(length) + except OverflowError: + if not use_readline: + # Expecting to read more than 64 bits of data. Ouch! + raise + # We could loop on calls to smaller readline(), appending them + # until we actually get a newline. For uses in this module, + # we expect the actual length to be small, but WSGI applications + # are allowed to pass in an arbitrary length. (This loop isn't optimal, + # but even client applications *probably* have short lines.) + read = b'' + while len(read) < length and not read.endswith(b'\n'): + read += reader(MAX_REQUEST_LINE) + + self.position += len(read) + if len(read) < length: + if (use_readline and not read.endswith(b"\n")) or not use_readline: + raise IOError("unexpected end of file while reading request at position %s" % (self.position,)) + + return read + + def __read_chunk_length(self, rfile): + # Read and return the next integer chunk length. If no + # chunk length can be read, raises _InvalidClientInput. + + # Here's the production for a chunk: + # (http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html) + # chunk = chunk-size [ chunk-extension ] CRLF + # chunk-data CRLF + # chunk-size = 1*HEX + # chunk-extension= *( ";" chunk-ext-name [ "=" chunk-ext-val ] ) + # chunk-ext-name = token + # chunk-ext-val = token | quoted-string + + # To cope with malicious or broken clients that fail to send valid + # chunk lines, the strategy is to read character by character until we either reach + # a ; or newline. If at any time we read a non-HEX digit, we bail. If we hit a + # ;, indicating an chunk-extension, we'll read up to the next + # MAX_REQUEST_LINE characters + # looking for the CRLF, and if we don't find it, we bail. If we read more than 16 hex characters, + # (the number needed to represent a 64-bit chunk size), we bail (this protects us from + # a client that sends an infinite stream of `F`, for example). + + buf = BytesIO() + while 1: + char = rfile.read(1) + if not char: + self._chunked_input_error = True + raise _InvalidClientInput("EOF before chunk end reached") + if char == b'\r': + break + if char == b';': + break + + if char not in _HEX: + self._chunked_input_error = True + raise _InvalidClientInput("Non-hex data", char) + buf.write(char) + if buf.tell() > 16: + self._chunked_input_error = True + raise _InvalidClientInput("Chunk-size too large.") + + if char == b';': + i = 0 + while i < MAX_REQUEST_LINE: + char = rfile.read(1) + if char == b'\r': + break + i += 1 + else: + # we read more than MAX_REQUEST_LINE without + # hitting CR + self._chunked_input_error = True + raise _InvalidClientInput("Too large chunk extension") + + if char == b'\r': + # We either got here from the main loop or from the + # end of an extension + char = rfile.read(1) + if char != b'\n': + self._chunked_input_error = True + raise _InvalidClientInput("Line didn't end in CRLF") + return int(buf.getvalue(), 16) + + def _chunked_read(self, length=None, use_readline=False): + # pylint:disable=too-many-branches + rfile = self.rfile + self._send_100_continue() + + if length == 0: + return b"" + + if length is not None and length < 0: + length = None + + if use_readline: + reader = self.rfile.readline + else: + reader = self.rfile.read + + response = [] + while self.chunk_length != 0: + maxreadlen = self.chunk_length - self.position + if length is not None and length < maxreadlen: + maxreadlen = length + + if maxreadlen > 0: + data = reader(maxreadlen) + if not data: + self.chunk_length = 0 + self._chunked_input_error = True + raise IOError("unexpected end of file while parsing chunked data") + + datalen = len(data) + response.append(data) + + self.position += datalen + if self.chunk_length == self.position: + rfile.readline() + + if length is not None: + length -= datalen + if length == 0: + break + if use_readline and data[-1] == b"\n"[0]: + break + else: + # We're at the beginning of a chunk, so we need to + # determine the next size to read + self.chunk_length = self.__read_chunk_length(rfile) + self.position = 0 + if self.chunk_length == 0: + # Last chunk. Terminates with a CRLF. + rfile.readline() + return b''.join(response) + + def read(self, length=None): + if self.chunked_input: + return self._chunked_read(length) + return self._do_read(length) + + def readline(self, size=None): + if self.chunked_input: + return self._chunked_read(size, True) + return self._do_read(size, use_readline=True) + + def readlines(self, hint=None): + # pylint:disable=unused-argument + return list(self) + + def __iter__(self): + return self + + def next(self): + line = self.readline() + if not line: + raise StopIteration + return line + __next__ = next + + +try: + import mimetools + headers_factory = mimetools.Message +except ImportError: + # adapt Python 3 HTTP headers to old API + from http import client # pylint:disable=import-error + + class OldMessage(client.HTTPMessage): + def __init__(self, **kwargs): + super(client.HTTPMessage, self).__init__(**kwargs) # pylint:disable=bad-super-call + self.status = '' + + def getheader(self, name, default=None): + return self.get(name, default) + + @property + def headers(self): + for key, value in self._headers: + yield '%s: %s\r\n' % (key, value) + + @property + def typeheader(self): + return self.get('content-type') + + def headers_factory(fp, *args): # pylint:disable=unused-argument + try: + ret = client.parse_headers(fp, _class=OldMessage) + except client.LineTooLong: + ret = OldMessage() + ret.status = 'Line too long' + return ret + + +class WSGIHandler(object): + """ + Handles HTTP requests from a socket, creates the WSGI environment, and + interacts with the WSGI application. + + This is the default value of :attr:`WSGIServer.handler_class`. + This class may be subclassed carefully, and that class set on a + :class:`WSGIServer` instance through a keyword argument at + construction time. + + Instances are constructed with the same arguments as passed to the + server's :meth:`WSGIServer.handle` method followed by the server + itself. The application and environment are obtained from the server. + + """ + # pylint:disable=too-many-instance-attributes + + protocol_version = 'HTTP/1.1' + if PY3: + # if we do like Py2, then headers_factory unconditionally + # becomes a bound method, meaning the fp argument becomes WSGIHandler + def MessageClass(self, *args): + return headers_factory(*args) + else: + MessageClass = headers_factory + + # Attributes reset at various times for each request; not public + # documented. Class attributes to keep the constructor fast + # (but not make lint tools complain) + + status = None # byte string: b'200 OK' + _orig_status = None # native string: '200 OK' + response_headers = None # list of tuples (b'name', b'value') + code = None # Integer parsed from status + provided_date = None + provided_content_length = None + close_connection = False + time_start = 0 # time.time() when begin handling request + time_finish = 0 # time.time() when done handling request + headers_sent = False # Have we already sent headers? + response_use_chunked = False # Write with transfer-encoding chunked + environ = None # Dict from self.get_environ + application = None # application callable from self.server.application + requestline = None # native str 'GET / HTTP/1.1' + response_length = 0 # How much data we sent + result = None # The return value of the WSGI application + wsgi_input = None # Instance of Input() + content_length = 0 # From application-provided headers Incoming + # request headers, instance of MessageClass (gunicorn uses hasattr + # on this so the default value needs to be compatible with the + # API) + headers = headers_factory(BytesIO()) + request_version = None # str: 'HTTP 1.1' + command = None # str: 'GET' + path = None # str: '/' + + def __init__(self, sock, address, server, rfile=None): + # Deprecation: The rfile kwarg was introduced in 1.0a1 as part + # of a refactoring. It was never documented or used. It is + # considered DEPRECATED and may be removed in the future. Its + # use is not supported. + + self.socket = sock + self.client_address = address + self.server = server + if rfile is None: + self.rfile = sock.makefile('rb', -1) + else: + self.rfile = rfile + + def handle(self): + """ + The main request handling method, called by the server. + + This method runs a request handling loop, calling + :meth:`handle_one_request` until all requests on the + connection have been handled (that is, it implements + keep-alive). + """ + try: + while self.socket is not None: + self.time_start = time.time() + self.time_finish = 0 + + result = self.handle_one_request() + if result is None: + break + if result is True: + continue + + self.status, response_body = result + self.socket.sendall(response_body) + if self.time_finish == 0: + self.time_finish = time.time() + self.log_request() + break + finally: + if self.socket is not None: + _sock = getattr(self.socket, '_sock', None) # Python 3 + try: + # read out request data to prevent error: [Errno 104] Connection reset by peer + if _sock: + try: + # socket.recv would hang + _sock.recv(16384) + finally: + _sock.close() + self.socket.close() + except socket.error: + pass + self.__dict__.pop('socket', None) + self.__dict__.pop('rfile', None) + + def _check_http_version(self): + version_str = self.request_version + if not version_str.startswith("HTTP/"): + return False + version = tuple(int(x) for x in version_str[5:].split(".")) # "HTTP/" + if version[1] < 0 or version < (0, 9) or version >= (2, 0): + return False + return True + + def read_request(self, raw_requestline): + """ + Parse the incoming request. + + Parses various headers into ``self.headers`` using + :attr:`MessageClass`. Other attributes that are set upon a successful + return of this method include ``self.content_length`` and ``self.close_connection``. + + :param str raw_requestline: A native :class:`str` representing + the request line. A processed version of this will be stored + into ``self.requestline``. + + :raises ValueError: If the request is invalid. This error will + not be logged as a traceback (because it's a client issue, not a server problem). + :return: A boolean value indicating whether the request was successfully parsed. + This method should either return a true value or have raised a ValueError + with details about the parsing error. + + .. versionchanged:: 1.1b6 + Raise the previously documented :exc:`ValueError` in more cases instead of returning a + false value; this allows subclasses more opportunity to customize behaviour. + """ + # pylint:disable=too-many-branches + self.requestline = raw_requestline.rstrip() + words = self.requestline.split() + if len(words) == 3: + self.command, self.path, self.request_version = words + if not self._check_http_version(): + raise _InvalidClientRequest('Invalid http version: %r', raw_requestline) + elif len(words) == 2: + self.command, self.path = words + if self.command != "GET": + raise _InvalidClientRequest('Expected GET method: %r', raw_requestline) + self.request_version = "HTTP/0.9" + # QQQ I'm pretty sure we can drop support for HTTP/0.9 + else: + raise _InvalidClientRequest('Invalid HTTP method: %r', raw_requestline) + + self.headers = self.MessageClass(self.rfile, 0) + + if self.headers.status: + raise _InvalidClientRequest('Invalid headers status: %r', self.headers.status) + + if self.headers.get("transfer-encoding", "").lower() == "chunked": + try: + del self.headers["content-length"] + except KeyError: + pass + + content_length = self.headers.get("content-length") + if content_length is not None: + content_length = int(content_length) + if content_length < 0: + raise _InvalidClientRequest('Invalid Content-Length: %r', content_length) + + if content_length and self.command in ('HEAD', ): + raise _InvalidClientRequest('Unexpected Content-Length') + + self.content_length = content_length + + if self.request_version == "HTTP/1.1": + conntype = self.headers.get("Connection", "").lower() + self.close_connection = (conntype == 'close') + else: + self.close_connection = True + + return True + + def log_error(self, msg, *args): + try: + message = msg % args + except Exception: # pylint:disable=broad-except + traceback.print_exc() + message = '%r %r' % (msg, args) + try: + message = '%s: %s' % (self.socket, message) + except Exception: # pylint:disable=broad-except + pass + + try: + self.server.error_log.write(message + '\n') + except Exception: # pylint:disable=broad-except + traceback.print_exc() + + def read_requestline(self): + """ + Read and return the HTTP request line. + + Under both Python 2 and 3, this should return the native + ``str`` type; under Python 3, this probably means the bytes read + from the network need to be decoded (using the ISO-8859-1 charset, aka + latin-1). + """ + line = self.rfile.readline(MAX_REQUEST_LINE) + if PY3: + line = line.decode('latin-1') + return line + + def handle_one_request(self): + """ + Handles one HTTP request using ``self.socket`` and ``self.rfile``. + + Each invocation of this method will do several things, including (but not limited to): + + - Read the request line using :meth:`read_requestline`; + - Read the rest of the request, including headers, with :meth:`read_request`; + - Construct a new WSGI environment in ``self.environ`` using :meth:`get_environ`; + - Store the application in ``self.application``, retrieving it from the server; + - Handle the remainder of the request, including invoking the application, + with :meth:`handle_one_response` + + There are several possible return values to indicate the state + of the client connection: + + - ``None`` + The client connection is already closed or should + be closed because the WSGI application or client set the + ``Connection: close`` header. The request handling + loop should terminate and perform cleanup steps. + - (status, body) + An HTTP status and body tuple. The request was in error, + as detailed by the status and body. The request handling + loop should terminate, close the connection, and perform + cleanup steps. Note that the ``body`` is the complete contents + to send to the client, including all headers and the initial + status line. + - ``True`` + The literal ``True`` value. The request was successfully handled + and the response sent to the client by :meth:`handle_one_response`. + The connection remains open to process more requests and the connection + handling loop should call this method again. This is the typical return + value. + + .. seealso:: :meth:`handle` + + .. versionchanged:: 1.1b6 + Funnel exceptions having to do with invalid HTTP requests through + :meth:`_handle_client_error` to allow subclasses to customize. Note that + this is experimental and may change in the future. + """ + # pylint:disable=too-many-return-statements + if self.rfile.closed: + return + + try: + self.requestline = self.read_requestline() + # Account for old subclasses that haven't done this + if PY3 and isinstance(self.requestline, bytes): + self.requestline = self.requestline.decode('latin-1') + except socket.error: + # "Connection reset by peer" or other socket errors aren't interesting here + return + + if not self.requestline: + return + + self.response_length = 0 + + if len(self.requestline) >= MAX_REQUEST_LINE: + return ('414', _REQUEST_TOO_LONG_RESPONSE) + + try: + # for compatibility with older versions of pywsgi, we pass self.requestline as an argument there + # NOTE: read_request is supposed to raise ValueError on invalid input; allow old + # subclasses that return a False value instead. + # NOTE: This can mutate the value of self.headers, so self.get_environ() must not be + # called until AFTER this call is done. + if not self.read_request(self.requestline): + return ('400', _BAD_REQUEST_RESPONSE) + except Exception as ex: # pylint:disable=broad-except + # Notice we don't use self.handle_error because it reports + # a 500 error to the client, and this is almost certainly + # a client error. + # Provide a hook for subclasses. + return self._handle_client_error(ex) + + self.environ = self.get_environ() + self.application = self.server.application + + self.handle_one_response() + + if self.close_connection: + return + + if self.rfile.closed: + return + + return True # read more requests + + def finalize_headers(self): + if self.provided_date is None: + self.response_headers.append((b'Date', format_date_time(time.time()))) + + if self.code not in (304, 204): + # the reply will include message-body; make sure we have either Content-Length or chunked + if self.provided_content_length is None: + if hasattr(self.result, '__len__'): + total_len = sum(len(chunk) for chunk in self.result) + total_len_str = str(total_len) + if PY3: + total_len_str = total_len_str.encode("latin-1") + self.response_headers.append((b'Content-Length', total_len_str)) + else: + if self.request_version != 'HTTP/1.0': + self.response_use_chunked = True + self.response_headers.append((b'Transfer-Encoding', b'chunked')) + + def _sendall(self, data): + try: + self.socket.sendall(data) + except socket.error as ex: + self.status = 'socket error: %s' % ex + if self.code > 0: + self.code = -self.code + raise + self.response_length += len(data) + + def _write(self, data): + if not data: + # The application/middleware are allowed to yield + # empty bytestrings. + return + + if self.response_use_chunked: + ## Write the chunked encoding + header = ("%x\r\n" % len(data)).encode('ascii') + # socket.sendall will slice these small strings, as [0:], + # but that's special cased to return the original string. + # They're small enough we probably expect them to go down to the network + # buffers in one go anyway. + self._sendall(header) + self._sendall(data) + self._sendall(b'\r\n') # trailer + else: + self._sendall(data) + + def write(self, data): + # The write() callable we return from start_response. + # https://www.python.org/dev/peps/pep-3333/#the-write-callable + # Supposed to do pretty much the same thing as yielding values + # from the application's return. + if self.code in (304, 204) and data: + raise AssertionError('The %s response must have no body' % self.code) + + if self.headers_sent: + self._write(data) + else: + if not self.status: + raise AssertionError("The application did not call start_response()") + self._write_with_headers(data) + + def _write_with_headers(self, data): + towrite = bytearray() + self.headers_sent = True + self.finalize_headers() + + # self.response_headers and self.status are already in latin-1, as encoded by self.start_response + towrite.extend(b'HTTP/1.1 ') + towrite.extend(self.status) + towrite.extend(b'\r\n') + for header, value in self.response_headers: + towrite.extend(header) + towrite.extend(b': ') + towrite.extend(value) + towrite.extend(b"\r\n") + + towrite.extend(b'\r\n') + self._sendall(towrite) + # No need to copy the data into towrite; we may make an extra syscall + # but the copy time could be substantial too, and it reduces the chances + # of sendall being able to send everything in one go + self._write(data) + + def start_response(self, status, headers, exc_info=None): + """ + .. versionchanged:: 1.2a1 + Avoid HTTP header injection by raising a :exc:`ValueError` + if *status* or any *header* name or value contains a carriage + return or newline. + .. versionchanged:: 1.1b5 + Pro-actively handle checking the encoding of the status line + and headers during this method. On Python 2, avoid some + extra encodings. + """ + # pylint:disable=too-many-branches,too-many-statements + if exc_info: + try: + if self.headers_sent: + # Re-raise original exception if headers sent + reraise(*exc_info) + finally: + # Avoid dangling circular ref + exc_info = None + + # Pep 3333, "The start_response callable": + # https://www.python.org/dev/peps/pep-3333/#the-start-response-callable + # "Servers should check for errors in the headers at the time + # start_response is called, so that an error can be raised + # while the application is still running." Here, we check the encoding. + # This aids debugging: headers especially are generated programatically + # and an encoding error in a loop or list comprehension yields an opaque + # UnicodeError without any clue which header was wrong. + # Note that this results in copying the header list at this point, not modifying it, + # although we are allowed to do so if needed. This slightly increases memory usage. + # We also check for HTTP Response Splitting vulnerabilities + response_headers = [] + header = None + value = None + try: + for header, value in headers: + if not isinstance(header, str): + raise UnicodeError("The header must be a native string", header, value) + if not isinstance(value, str): + raise UnicodeError("The value must be a native string", header, value) + if '\r' in header or '\n' in header: + raise ValueError('carriage return or newline in header name', header) + if '\r' in value or '\n' in value: + raise ValueError('carriage return or newline in header value', value) + # Either we're on Python 2, in which case bytes is correct, or + # we're on Python 3 and the user screwed up (because it should be a native + # string). In either case, make sure that this is latin-1 compatible. Under + # Python 2, bytes.encode() will take a round-trip through the system encoding, + # which may be ascii, which is not really what we want. However, the latin-1 encoding + # can encode everything except control characters and the block from 0x7F to 0x9F, so + # explicitly round-tripping bytes through the encoding is unlikely to be of much + # benefit, so we go for speed (the WSGI spec specifically calls out allowing the range + # from 0x00 to 0xFF, although the HTTP spec forbids the control characters). + # Note: Some Python 2 implementations, like Jython, may allow non-octet (above 255) values + # in their str implementation; this is mentioned in the WSGI spec, but we don't + # run on any platform like that so we can assume that a str value is pure bytes. + response_headers.append((header if not PY3 else header.encode("latin-1"), + value if not PY3 else value.encode("latin-1"))) + except UnicodeEncodeError: + # If we get here, we're guaranteed to have a header and value + raise UnicodeError("Non-latin1 header", repr(header), repr(value)) + + # Same as above + if not isinstance(status, str): + raise UnicodeError("The status string must be a native string") + if '\r' in status or '\n' in status: + raise ValueError("carriage return or newline in status", status) + # don't assign to anything until the validation is complete, including parsing the + # code + code = int(status.split(' ', 1)[0]) + + self.status = status if not PY3 else status.encode("latin-1") + self._orig_status = status # Preserve the native string for logging + self.response_headers = response_headers + self.code = code + + provided_connection = None + self.provided_date = None + self.provided_content_length = None + + for header, value in headers: + header = header.lower() + if header == 'connection': + provided_connection = value + elif header == 'date': + self.provided_date = value + elif header == 'content-length': + self.provided_content_length = value + + if self.request_version == 'HTTP/1.0' and provided_connection is None: + response_headers.append((b'Connection', b'close')) + self.close_connection = True + elif provided_connection == 'close': + self.close_connection = True + + if self.code in (304, 204): + if self.provided_content_length is not None and self.provided_content_length != '0': + msg = 'Invalid Content-Length for %s response: %r (must be absent or zero)' % (self.code, self.provided_content_length) + if PY3: + msg = msg.encode('latin-1') + raise AssertionError(msg) + + return self.write + + def log_request(self): + self.server.log.write(self.format_request() + '\n') + + def format_request(self): + now = datetime.now().replace(microsecond=0) + length = self.response_length or '-' + if self.time_finish: + delta = '%.6f' % (self.time_finish - self.time_start) + else: + delta = '-' + client_address = self.client_address[0] if isinstance(self.client_address, tuple) else self.client_address + return '%s - - [%s] "%s" %s %s %s' % ( + client_address or '-', + now, + self.requestline or '', + # Use the native string version of the status, saved so we don't have to + # decode. But fallback to the encoded 'status' in case of subclasses + # (Is that really necessary? At least there's no overhead.) + (self._orig_status or self.status or '000').split()[0], + length, + delta) + + def process_result(self): + for data in self.result: + if data: + self.write(data) + if self.status and not self.headers_sent: + # In other words, the application returned an empty + # result iterable (and did not use the write callable) + # Trigger the flush of the headers. + self.write(b'') + if self.response_use_chunked: + self.socket.sendall(b'0\r\n\r\n') + self.response_length += 5 + + def run_application(self): + assert self.result is None + try: + self.result = self.application(self.environ, self.start_response) + self.process_result() + finally: + close = getattr(self.result, 'close', None) + try: + if close is not None: + close() + finally: + # Discard the result. If it's a generator this can + # free a lot of hidden resources (if we failed to iterate + # all the way through it---the frames are automatically + # cleaned up when StopIteration is raised); but other cases + # could still free up resources sooner than otherwise. + close = None + self.result = None + + def handle_one_response(self): + self.time_start = time.time() + self.status = None + self.headers_sent = False + + self.result = None + self.response_use_chunked = False + self.response_length = 0 + + try: + try: + self.run_application() + finally: + try: + self.wsgi_input._discard() + except (socket.error, IOError): + # Don't let exceptions during discarding + # input override any exception that may have been + # raised by the application, such as our own _InvalidClientInput. + # In the general case, these aren't even worth logging (see the comment + # just below) + pass + except _InvalidClientInput: + self._send_error_response_if_possible(400) + except socket.error as ex: + if ex.args[0] in (errno.EPIPE, errno.ECONNRESET): + # Broken pipe, connection reset by peer. + # Swallow these silently to avoid spewing + # useless info on normal operating conditions, + # bloating logfiles. See https://github.com/gevent/gevent/pull/377 + # and https://github.com/gevent/gevent/issues/136. + if not PY3: + sys.exc_clear() + self.close_connection = True + else: + self.handle_error(*sys.exc_info()) + except: # pylint:disable=bare-except + self.handle_error(*sys.exc_info()) + finally: + self.time_finish = time.time() + self.log_request() + + def _send_error_response_if_possible(self, error_code): + if self.response_length: + self.close_connection = True + else: + status, headers, body = _ERRORS[error_code] + try: + self.start_response(status, headers[:]) + self.write(body) + except socket.error: + if not PY3: + sys.exc_clear() + self.close_connection = True + + def _log_error(self, t, v, tb): + # TODO: Shouldn't we dump this to wsgi.errors? If we did that now, it would + # wind up getting logged twice + if not issubclass(t, GreenletExit): + context = self.environ + if not isinstance(context, self.server.secure_environ_class): + context = self.server.secure_environ_class(context) + self.server.loop.handle_error(context, t, v, tb) + + def handle_error(self, t, v, tb): + # Called for internal, unexpected errors, NOT invalid client input + self._log_error(t, v, tb) + del tb + self._send_error_response_if_possible(500) + + def _handle_client_error(self, ex): + # Called for invalid client input + # Returns the appropriate error response. + if not isinstance(ex, ValueError): + # XXX: Why not self._log_error to send it through the loop's + # handle_error method? + traceback.print_exc() + if isinstance(ex, _InvalidClientRequest): + # These come with good error messages, and we want to let + # log_error deal with the formatting, especially to handle encoding + self.log_error(*ex.args) + else: + self.log_error('Invalid request: %s', str(ex) or ex.__class__.__name__) + return ('400', _BAD_REQUEST_RESPONSE) + + def _headers(self): + key = None + value = None + IGNORED_KEYS = (None, 'CONTENT_TYPE', 'CONTENT_LENGTH') + for header in self.headers.headers: + if key is not None and header[:1] in " \t": + value += header + continue + + if key not in IGNORED_KEYS: + yield 'HTTP_' + key, value.strip() + + key, value = header.split(':', 1) + if '_' in key: + # strip incoming bad veaders + key = None + else: + key = key.replace('-', '_').upper() + + if key not in IGNORED_KEYS: + yield 'HTTP_' + key, value.strip() + + def get_environ(self): + """ + Construct and return a new WSGI environment dictionary for a specific request. + + This should begin with asking the server for the base environment + using :meth:`WSGIServer.get_environ`, and then proceed to add the + request specific values. + + By the time this method is invoked the request line and request shall have + been parsed and ``self.headers`` shall be populated. + """ + env = self.server.get_environ() + env['REQUEST_METHOD'] = self.command + env['SCRIPT_NAME'] = '' + + if '?' in self.path: + path, query = self.path.split('?', 1) + else: + path, query = self.path, '' + # Note that self.path contains the original str object; if it contains + # encoded escapes, it will NOT match PATH_INFO. + env['PATH_INFO'] = unquote_latin1(path) + env['QUERY_STRING'] = query + + if self.headers.typeheader is not None: + env['CONTENT_TYPE'] = self.headers.typeheader + + length = self.headers.getheader('content-length') + if length: + env['CONTENT_LENGTH'] = length + env['SERVER_PROTOCOL'] = self.request_version + + client_address = self.client_address + if isinstance(client_address, tuple): + env['REMOTE_ADDR'] = str(client_address[0]) + env['REMOTE_PORT'] = str(client_address[1]) + + for key, value in self._headers(): + if key in env: + if 'COOKIE' in key: + env[key] += '; ' + value + else: + env[key] += ',' + value + else: + env[key] = value + + if env.get('HTTP_EXPECT') == '100-continue': + sock = self.socket + else: + sock = None + + chunked = env.get('HTTP_TRANSFER_ENCODING', '').lower() == 'chunked' + self.wsgi_input = Input(self.rfile, self.content_length, socket=sock, chunked_input=chunked) + env['wsgi.input'] = self.wsgi_input + return env + + +class _NoopLog(object): + # Does nothing; implements just enough file-like methods + # to pass the WSGI validator + + def write(self, *args, **kwargs): + # pylint:disable=unused-argument + return + + def flush(self): + pass + + def writelines(self, *args, **kwargs): + pass + + +class LoggingLogAdapter(object): + """ + An adapter for :class:`logging.Logger` instances + to let them be used with :class:`WSGIServer`. + + .. warning:: Unless the entire process is monkey-patched at a very + early part of the lifecycle (before logging is configured), + loggers are likely to not be gevent-cooperative. For example, + the socket and syslog handlers use the socket module in a way + that can block, and most handlers acquire threading locks. + + .. warning:: It *may* be possible for the logging functions to be + called in the :class:`gevent.Hub` greenlet. Code running in the + hub greenlet cannot use any gevent blocking functions without triggering + a ``LoopExit``. + + .. versionadded:: 1.1a3 + + .. versionchanged:: 1.1b6 + Attributes not present on this object are proxied to the underlying + logger instance. This permits using custom :class:`~logging.Logger` + subclasses (or indeed, even duck-typed objects). + + .. versionchanged:: 1.1 + Strip trailing newline characters on the message passed to :meth:`write` + because log handlers will usually add one themselves. + """ + + # gevent avoids importing and using logging because importing it and + # creating loggers creates native locks unless monkey-patched. + + __slots__ = ('_logger', '_level') + + def __init__(self, logger, level=20): + """ + Write information to the *logger* at the given *level* (default to INFO). + """ + self._logger = logger + self._level = level + + def write(self, msg): + if msg and msg.endswith('\n'): + msg = msg[:-1] + self._logger.log(self._level, msg) + + def flush(self): + "No-op; required to be a file-like object" + pass + + def writelines(self, lines): + for line in lines: + self.write(line) + + def __getattr__(self, name): + return getattr(self._logger, name) + + def __setattr__(self, name, value): + if name not in LoggingLogAdapter.__slots__: + setattr(self._logger, name, value) + else: + object.__setattr__(self, name, value) + + def __delattr__(self, name): + delattr(self._logger, name) + +#### +## Environ classes. +# These subclass dict. They could subclass collections.UserDict on +# 3.3+ and proxy to the underlying real dict to avoid a copy if we +# have to print them (on 2.7 it's slightly more complicated to be an +# instance of collections.MutableMapping; UserDict.UserDict isn't.) +# Then we could have either the WSGIHandler.get_environ or the +# WSGIServer.get_environ return one of these proxies, and +# WSGIHandler.run_application would know to access the `environ.data` +# attribute to be able to pass the *real* dict to the application +# (because PEP3333 requires no subclasses, only actual dict objects; +# wsgiref.validator and webob.Request both enforce this). This has the +# advantage of not being fragile if anybody else tries to print/log +# self.environ (and not requiring a copy). However, if there are any +# subclasses of Handler or Server, this could break if they don't know +# to return this type. +#### + +class Environ(dict): + """ + A base class that can be used for WSGI environment objects. + + Provisional API. + + .. versionadded:: 1.2a1 + """ + + __slots__ = () # add no ivars or weakref ability + + def copy(self): + return self.__class__(self) + + if not hasattr(dict, 'iteritems'): + # Python 3 + def iteritems(self): + return self.items() + + def __reduce_ex__(self, proto): + return (dict, (), None, None, iter(self.iteritems())) + +class SecureEnviron(Environ): + """ + An environment that does not print its keys and values + by default. + + Provisional API. + + This is intended to keep potentially sensitive information like + HTTP authorization and cookies from being inadvertently printed + or logged. + + For debugging, each instance can have its *secure_repr* attribute + set to ``False``, which will cause it to print like a normal dict. + + When *secure_repr* is ``True`` (the default), then the value of + the *whitelist_keys* attribute is consulted; if this value is + true-ish, it should be a container (something that responds to + ``in``) of key names (typically a list or set). Keys and values in + this dictionary that are in *whitelist_keys* will then be printed, + while all other values will be masked. These values may be + customized on the class by setting the *default_secure_repr* and + *default_whitelist_keys*, respectively:: + + >>> environ = SecureEnviron(key='value') + >>> environ # doctest: +ELLIPSIS + >> environ.whitelist_keys = {'key'} + >>> environ + {'key': 'value'} + + A non-whitelisted key (*only*, to avoid doctest issues) is masked:: + + >>> environ['secure'] = 'secret'; del environ['key'] + >>> environ + {'secure': ''} + + We can turn it off entirely for the instance:: + + >>> environ.secure_repr = False + >>> environ + {'secure': 'secret'} + + We can also customize it at the class level (here we use a new + class to be explicit and to avoid polluting the true default + values; we would set this class to be the ``environ_class`` of the + server):: + + >>> class MyEnviron(SecureEnviron): + ... default_whitelist_keys = ('key',) + ... + >>> environ = MyEnviron({'key': 'value'}) + >>> environ + {'key': 'value'} + + .. versionadded:: 1.2a1 + """ + + default_secure_repr = True + default_whitelist_keys = () + default_print_masked_keys = True + + # Allow instances to override the class values, + # but inherit from the class if not present. Keeps instances + # small since we can't combine __slots__ with class attributes + # of the same name. + __slots__ = ('secure_repr', 'whitelist_keys', 'print_masked_keys') + + def __getattr__(self, name): + if name in SecureEnviron.__slots__: + return getattr(type(self), 'default_' + name) + raise AttributeError(name) + + def __repr__(self): + if self.secure_repr: + whitelist = self.whitelist_keys + print_masked = self.print_masked_keys + if whitelist: + safe = {k: self[k] if k in whitelist else "" + for k in self + if k in whitelist or print_masked} + safe_repr = repr(safe) + if not print_masked and len(safe) != len(self): + safe_repr = safe_repr[:-1] + ", (hidden keys: %d)}" % (len(self) - len(safe)) + return safe_repr + return "" % (len(self), id(self)) + return Environ.__repr__(self) + __str__ = __repr__ + + +class WSGISecureEnviron(SecureEnviron): + """ + Specializes the default list of whitelisted keys to a few + common WSGI variables. + + Example:: + + >>> environ = WSGISecureEnviron(REMOTE_ADDR='::1', HTTP_AUTHORIZATION='secret') + >>> environ + {'REMOTE_ADDR': '::1', (hidden keys: 1)} + >>> import pprint + >>> pprint.pprint(environ) + {'REMOTE_ADDR': '::1', (hidden keys: 1)} + >>> print(pprint.pformat(environ)) + {'REMOTE_ADDR': '::1', (hidden keys: 1)} + """ + default_whitelist_keys = ('REMOTE_ADDR', 'REMOTE_PORT', 'HTTP_HOST') + default_print_masked_keys = False + + +class WSGIServer(StreamServer): + """ + A WSGI server based on :class:`StreamServer` that supports HTTPS. + + + :keyword log: If given, an object with a ``write`` method to which + request (access) logs will be written. If not given, defaults + to :obj:`sys.stderr`. You may pass ``None`` to disable request + logging. You may use a wrapper, around e.g., :mod:`logging`, + to support objects that don't implement a ``write`` method. + (If you pass a :class:`~logging.Logger` instance, or in + general something that provides a ``log`` method but not a + ``write`` method, such a wrapper will automatically be created + and it will be logged to at the :data:`~logging.INFO` level.) + + :keyword error_log: If given, a file-like object with ``write``, + ``writelines`` and ``flush`` methods to which error logs will + be written. If not given, defaults to :obj:`sys.stderr`. You + may pass ``None`` to disable error logging (not recommended). + You may use a wrapper, around e.g., :mod:`logging`, to support + objects that don't implement the proper methods. This + parameter will become the value for ``wsgi.errors`` in the + WSGI environment (if not already set). (As with *log*, + wrappers for :class:`~logging.Logger` instances and the like + will be created automatically and logged to at the :data:`~logging.ERROR` + level.) + + .. seealso:: + + :class:`LoggingLogAdapter` + See important warnings before attempting to use :mod:`logging`. + + .. versionchanged:: 1.1a3 + Added the ``error_log`` parameter, and set ``wsgi.errors`` in the WSGI + environment to this value. + .. versionchanged:: 1.1a3 + Add support for passing :class:`logging.Logger` objects to the ``log`` and + ``error_log`` arguments. + """ + + #: A callable taking three arguments: (socket, address, server) and returning + #: an object with a ``handle()`` method. The callable is called once for + #: each incoming socket request, as is its handle method. The handle method should not + #: return until all use of the socket is complete. + #: + #: This class uses the :class:`WSGIHandler` object as the default value. You may + #: subclass this class and set a different default value, or you may pass + #: a value to use in the ``handler_class`` keyword constructor argument. + handler_class = WSGIHandler + + #: The object to which request logs will be written. + #: It must never be None. Initialized from the ``log`` constructor + #: parameter. + log = None + + #: The object to which error logs will be written. + #: It must never be None. Initialized from the ``error_log`` constructor + #: parameter. + error_log = None + + #: The class of environ objects passed to the handlers. + #: Must be a dict subclass. For compliance with :pep:`3333` + #: and libraries like WebOb, this is simply :class:`dict` + #: but this can be customized in a subclass or per-instance + #: (probably to :class:`WSGISecureEnviron`). + #: + #: .. versionadded:: 1.2a1 + environ_class = dict + + # Undocumented internal detail: the class that WSGIHandler._log_error + # will cast to before passing to the loop. + secure_environ_class = WSGISecureEnviron + + base_env = {'GATEWAY_INTERFACE': 'CGI/1.1', + 'SERVER_SOFTWARE': 'gevent/%d.%d Python/%d.%d' % (gevent.version_info[:2] + sys.version_info[:2]), + 'SCRIPT_NAME': '', + 'wsgi.version': (1, 0), + 'wsgi.multithread': False, # XXX: Aren't we really, though? + 'wsgi.multiprocess': False, + 'wsgi.run_once': False} + + def __init__(self, listener, application=None, backlog=None, spawn='default', + log='default', error_log='default', + handler_class=None, + environ=None, **ssl_args): + StreamServer.__init__(self, listener, backlog=backlog, spawn=spawn, **ssl_args) + if application is not None: + self.application = application + if handler_class is not None: + self.handler_class = handler_class + + # Note that we can't initialize these as class variables: + # sys.stderr might get monkey patched at runtime. + def _make_log(l, level=20): + if l == 'default': + return sys.stderr + if l is None: + return _NoopLog() + if not hasattr(l, 'write') and hasattr(l, 'log'): + return LoggingLogAdapter(l, level) + return l + self.log = _make_log(log) + self.error_log = _make_log(error_log, 40) # logging.ERROR + + self.set_environ(environ) + self.set_max_accept() + + def set_environ(self, environ=None): + if environ is not None: + self.environ = environ + environ_update = getattr(self, 'environ', None) + + self.environ = self.environ_class(self.base_env) + if self.ssl_enabled: + self.environ['wsgi.url_scheme'] = 'https' + else: + self.environ['wsgi.url_scheme'] = 'http' + if environ_update is not None: + self.environ.update(environ_update) + if self.environ.get('wsgi.errors') is None: + self.environ['wsgi.errors'] = self.error_log + + def set_max_accept(self): + if self.environ.get('wsgi.multiprocess'): + self.max_accept = 1 + + def get_environ(self): + return self.environ_class(self.environ) + + def init_socket(self): + StreamServer.init_socket(self) + self.update_environ() + + def update_environ(self): + """ + Called before the first request is handled to fill in WSGI environment values. + + This includes getting the correct server name and port. + """ + address = self.address + if isinstance(address, tuple): + if 'SERVER_NAME' not in self.environ: + try: + name = socket.getfqdn(address[0]) + except socket.error: + name = str(address[0]) + if PY3 and not isinstance(name, str): + name = name.decode('ascii') + self.environ['SERVER_NAME'] = name + self.environ.setdefault('SERVER_PORT', str(address[1])) + else: + self.environ.setdefault('SERVER_NAME', '') + self.environ.setdefault('SERVER_PORT', '') + + def handle(self, sock, address): + """ + Create an instance of :attr:`handler_class` to handle the request. + + This method blocks until the handler returns. + """ + # pylint:disable=method-hidden + handler = self.handler_class(sock, address, self) + handler.handle() + +def _main(): + # Provisional main handler, for quick tests, not production + # usage. + from gevent import monkey; monkey.patch_all() + + import argparse + import importlib + + parser = argparse.ArgumentParser() + parser.add_argument("app", help="dotted name of WSGI app callable [module:callable]") + parser.add_argument("-b", "--bind", + help="The socket to bind", + default=":8080") + + args = parser.parse_args() + + module_name, app_name = args.app.split(':') + module = importlib.import_module(module_name) + app = getattr(module, app_name) + bind = args.bind + + server = WSGIServer(bind, app) + server.serve_forever() + +if __name__ == '__main__': + _main() diff --git a/python/gevent/queue.py b/python/gevent/queue.py new file mode 100644 index 0000000..5f1bb47 --- /dev/null +++ b/python/gevent/queue.py @@ -0,0 +1,605 @@ +# Copyright (c) 2009-2012 Denis Bilenko. See LICENSE for details. +"""Synchronized queues. + +The :mod:`gevent.queue` module implements multi-producer, multi-consumer queues +that work across greenlets, with the API similar to the classes found in the +standard :mod:`Queue` and :class:`multiprocessing ` modules. + +The classes in this module implement iterator protocol. Iterating over queue +means repeatedly calling :meth:`get ` until :meth:`get ` returns ``StopIteration``. + + >>> queue = gevent.queue.Queue() + >>> queue.put(1) + >>> queue.put(2) + >>> queue.put(StopIteration) + >>> for item in queue: + ... print(item) + 1 + 2 + +.. versionchanged:: 1.0 + ``Queue(0)`` now means queue of infinite size, not a channel. A :exc:`DeprecationWarning` + will be issued with this argument. +""" + +from __future__ import absolute_import +import sys +import heapq +import collections + +if sys.version_info[0] == 2: + import Queue as __queue__ +else: + import queue as __queue__ # python 2: pylint:disable=import-error +Full = __queue__.Full +Empty = __queue__.Empty + +from gevent.timeout import Timeout +from gevent.hub import get_hub, Waiter, getcurrent +from gevent.hub import InvalidSwitchError + + +__all__ = ['Queue', 'PriorityQueue', 'LifoQueue', 'JoinableQueue', 'Channel'] + + +def _safe_remove(deq, item): + # For when the item may have been removed by + # Queue._unlock + try: + deq.remove(item) + except ValueError: + pass + + +class Queue(object): + """ + Create a queue object with a given maximum size. + + If *maxsize* is less than or equal to zero or ``None``, the queue + size is infinite. + + .. versionchanged:: 1.1b3 + Queues now support :func:`len`; it behaves the same as :meth:`qsize`. + .. versionchanged:: 1.1b3 + Multiple greenlets that block on a call to :meth:`put` for a full queue + will now be woken up to put their items into the queue in the order in which + they arrived. Likewise, multiple greenlets that block on a call to :meth:`get` for + an empty queue will now receive items in the order in which they blocked. An + implementation quirk under CPython *usually* ensured this was roughly the case + previously anyway, but that wasn't the case for PyPy. + """ + + def __init__(self, maxsize=None, items=None): + if maxsize is not None and maxsize <= 0: + self.maxsize = None + if maxsize == 0: + import warnings + warnings.warn('Queue(0) now equivalent to Queue(None); if you want a channel, use Channel', + DeprecationWarning, stacklevel=2) + else: + self.maxsize = maxsize + # Explicitly maintain order for getters and putters that block + # so that callers can consistently rely on getting things out + # in the apparent order they went in. This was once required by + # imap_unordered. Previously these were set() objects, and the + # items put in the set have default hash() and eq() methods; + # under CPython, since new objects tend to have increasing + # hash values, this tended to roughly maintain order anyway, + # but that's not true under PyPy. An alternative to a deque + # (to avoid the linear scan of remove()) might be an + # OrderedDict, but it's 2.7 only; we don't expect to have so + # many waiters that removing an arbitrary element is a + # bottleneck, though. + self.getters = collections.deque() + self.putters = collections.deque() + self.hub = get_hub() + self._event_unlock = None + if items: + self._init(maxsize, items) + else: + self._init(maxsize) + + # QQQ make maxsize into a property with setter that schedules unlock if necessary + + def copy(self): + return type(self)(self.maxsize, self.queue) + + def _init(self, maxsize, items=None): + # FIXME: Why is maxsize unused or even passed? + # pylint:disable=unused-argument + if items: + self.queue = collections.deque(items) + else: + self.queue = collections.deque() + + def _get(self): + return self.queue.popleft() + + def _peek(self): + return self.queue[0] + + def _put(self, item): + self.queue.append(item) + + def __repr__(self): + return '<%s at %s%s>' % (type(self).__name__, hex(id(self)), self._format()) + + def __str__(self): + return '<%s%s>' % (type(self).__name__, self._format()) + + def _format(self): + result = [] + if self.maxsize is not None: + result.append('maxsize=%r' % (self.maxsize, )) + if getattr(self, 'queue', None): + result.append('queue=%r' % (self.queue, )) + if self.getters: + result.append('getters[%s]' % len(self.getters)) + if self.putters: + result.append('putters[%s]' % len(self.putters)) + if result: + return ' ' + ' '.join(result) + return '' + + def qsize(self): + """Return the size of the queue.""" + return len(self.queue) + + def __len__(self): + """ + Return the size of the queue. This is the same as :meth:`qsize`. + + .. versionadded: 1.1b3 + + Previously, getting len() of a queue would raise a TypeError. + """ + + return self.qsize() + + def __bool__(self): + """ + A queue object is always True. + + .. versionadded: 1.1b3 + + Now that queues support len(), they need to implement ``__bool__`` + to return True for backwards compatibility. + """ + return True + __nonzero__ = __bool__ + + def empty(self): + """Return ``True`` if the queue is empty, ``False`` otherwise.""" + return not self.qsize() + + def full(self): + """Return ``True`` if the queue is full, ``False`` otherwise. + + ``Queue(None)`` is never full. + """ + return self.maxsize is not None and self.qsize() >= self.maxsize + + def put(self, item, block=True, timeout=None): + """Put an item into the queue. + + If optional arg *block* is true and *timeout* is ``None`` (the default), + block if necessary until a free slot is available. If *timeout* is + a positive number, it blocks at most *timeout* seconds and raises + the :class:`Full` exception if no free slot was available within that time. + Otherwise (*block* is false), put an item on the queue if a free slot + is immediately available, else raise the :class:`Full` exception (*timeout* + is ignored in that case). + """ + if self.maxsize is None or self.qsize() < self.maxsize: + # there's a free slot, put an item right away + self._put(item) + if self.getters: + self._schedule_unlock() + elif self.hub is getcurrent(): + # We're in the mainloop, so we cannot wait; we can switch to other greenlets though. + # Check if possible to get a free slot in the queue. + while self.getters and self.qsize() and self.qsize() >= self.maxsize: + getter = self.getters.popleft() + getter.switch(getter) + if self.qsize() < self.maxsize: + self._put(item) + return + raise Full + elif block: + waiter = ItemWaiter(item, self) + self.putters.append(waiter) + timeout = Timeout._start_new_or_dummy(timeout, Full) + try: + if self.getters: + self._schedule_unlock() + result = waiter.get() + if result is not waiter: + raise InvalidSwitchError("Invalid switch into Queue.put: %r" % (result, )) + finally: + timeout.cancel() + _safe_remove(self.putters, waiter) + else: + raise Full + + def put_nowait(self, item): + """Put an item into the queue without blocking. + + Only enqueue the item if a free slot is immediately available. + Otherwise raise the :class:`Full` exception. + """ + self.put(item, False) + + def __get_or_peek(self, method, block, timeout): + # Internal helper method. The `method` should be either + # self._get when called from self.get() or self._peek when + # called from self.peek(). Call this after the initial check + # to see if there are items in the queue. + + if self.hub is getcurrent(): + # special case to make get_nowait() or peek_nowait() runnable in the mainloop greenlet + # there are no items in the queue; try to fix the situation by unlocking putters + while self.putters: + # Note: get() used popleft(), peek used pop(); popleft + # is almost certainly correct. + self.putters.popleft().put_and_switch() + if self.qsize(): + return method() + raise Empty() + + if not block: + # We can't block, we're not the hub, and we have nothing + # to return. No choice... + raise Empty() + + waiter = Waiter() + timeout = Timeout._start_new_or_dummy(timeout, Empty) + try: + self.getters.append(waiter) + if self.putters: + self._schedule_unlock() + result = waiter.get() + if result is not waiter: + raise InvalidSwitchError('Invalid switch into Queue.get: %r' % (result, )) + return method() + finally: + timeout.cancel() + _safe_remove(self.getters, waiter) + + def get(self, block=True, timeout=None): + """Remove and return an item from the queue. + + If optional args *block* is true and *timeout* is ``None`` (the default), + block if necessary until an item is available. If *timeout* is a positive number, + it blocks at most *timeout* seconds and raises the :class:`Empty` exception + if no item was available within that time. Otherwise (*block* is false), return + an item if one is immediately available, else raise the :class:`Empty` exception + (*timeout* is ignored in that case). + """ + if self.qsize(): + if self.putters: + self._schedule_unlock() + return self._get() + + return self.__get_or_peek(self._get, block, timeout) + + def get_nowait(self): + """Remove and return an item from the queue without blocking. + + Only get an item if one is immediately available. Otherwise + raise the :class:`Empty` exception. + """ + return self.get(False) + + def peek(self, block=True, timeout=None): + """Return an item from the queue without removing it. + + If optional args *block* is true and *timeout* is ``None`` (the default), + block if necessary until an item is available. If *timeout* is a positive number, + it blocks at most *timeout* seconds and raises the :class:`Empty` exception + if no item was available within that time. Otherwise (*block* is false), return + an item if one is immediately available, else raise the :class:`Empty` exception + (*timeout* is ignored in that case). + """ + if self.qsize(): + # XXX: Why doesn't this schedule an unlock like get() does? + return self._peek() + + return self.__get_or_peek(self._peek, block, timeout) + + def peek_nowait(self): + """Return an item from the queue without blocking. + + Only return an item if one is immediately available. Otherwise + raise the :class:`Empty` exception. + """ + return self.peek(False) + + def _unlock(self): + while True: + repeat = False + if self.putters and (self.maxsize is None or self.qsize() < self.maxsize): + repeat = True + try: + putter = self.putters.popleft() + self._put(putter.item) + except: # pylint:disable=bare-except + putter.throw(*sys.exc_info()) + else: + putter.switch(putter) + if self.getters and self.qsize(): + repeat = True + getter = self.getters.popleft() + getter.switch(getter) + if not repeat: + return + + def _schedule_unlock(self): + if not self._event_unlock: + self._event_unlock = self.hub.loop.run_callback(self._unlock) + + def __iter__(self): + return self + + def next(self): + result = self.get() + if result is StopIteration: + raise result + return result + + __next__ = next + + + +class ItemWaiter(Waiter): + __slots__ = ['item', 'queue'] + + def __init__(self, item, queue): + Waiter.__init__(self) + self.item = item + self.queue = queue + + def put_and_switch(self): + self.queue._put(self.item) + self.queue = None + self.item = None + return self.switch(self) + + +class PriorityQueue(Queue): + '''A subclass of :class:`Queue` that retrieves entries in priority order (lowest first). + + Entries are typically tuples of the form: ``(priority number, data)``. + + .. versionchanged:: 1.2a1 + Any *items* given to the constructor will now be passed through + :func:`heapq.heapify` to ensure the invariants of this class hold. + Previously it was just assumed that they were already a heap. + ''' + + def _init(self, maxsize, items=None): + if items: + self.queue = list(items) + heapq.heapify(self.queue) + else: + self.queue = [] + + def _put(self, item, heappush=heapq.heappush): + # pylint:disable=arguments-differ + heappush(self.queue, item) + + def _get(self, heappop=heapq.heappop): + # pylint:disable=arguments-differ + return heappop(self.queue) + + +class LifoQueue(Queue): + '''A subclass of :class:`Queue` that retrieves most recently added entries first.''' + + def _init(self, maxsize, items=None): + if items: + self.queue = list(items) + else: + self.queue = [] + + def _put(self, item): + self.queue.append(item) + + def _get(self): + return self.queue.pop() + + def _peek(self): + return self.queue[-1] + + +class JoinableQueue(Queue): + """ + A subclass of :class:`Queue` that additionally has + :meth:`task_done` and :meth:`join` methods. + """ + + def __init__(self, maxsize=None, items=None, unfinished_tasks=None): + """ + + .. versionchanged:: 1.1a1 + If *unfinished_tasks* is not given, then all the given *items* + (if any) will be considered unfinished. + + """ + from gevent.event import Event + Queue.__init__(self, maxsize, items) + self._cond = Event() + self._cond.set() + + if unfinished_tasks: + self.unfinished_tasks = unfinished_tasks + elif items: + self.unfinished_tasks = len(items) + else: + self.unfinished_tasks = 0 + + if self.unfinished_tasks: + self._cond.clear() + + def copy(self): + return type(self)(self.maxsize, self.queue, self.unfinished_tasks) + + def _format(self): + result = Queue._format(self) + if self.unfinished_tasks: + result += ' tasks=%s _cond=%s' % (self.unfinished_tasks, self._cond) + return result + + def _put(self, item): + Queue._put(self, item) + self.unfinished_tasks += 1 + self._cond.clear() + + def task_done(self): + '''Indicate that a formerly enqueued task is complete. Used by queue consumer threads. + For each :meth:`get ` used to fetch a task, a subsequent call to :meth:`task_done` tells the queue + that the processing on the task is complete. + + If a :meth:`join` is currently blocking, it will resume when all items have been processed + (meaning that a :meth:`task_done` call was received for every item that had been + :meth:`put ` into the queue). + + Raises a :exc:`ValueError` if called more times than there were items placed in the queue. + ''' + if self.unfinished_tasks <= 0: + raise ValueError('task_done() called too many times') + self.unfinished_tasks -= 1 + if self.unfinished_tasks == 0: + self._cond.set() + + def join(self, timeout=None): + ''' + Block until all items in the queue have been gotten and processed. + + The count of unfinished tasks goes up whenever an item is added to the queue. + The count goes down whenever a consumer thread calls :meth:`task_done` to indicate + that the item was retrieved and all work on it is complete. When the count of + unfinished tasks drops to zero, :meth:`join` unblocks. + + :param float timeout: If not ``None``, then wait no more than this time in seconds + for all tasks to finish. + :return: ``True`` if all tasks have finished; if ``timeout`` was given and expired before + all tasks finished, ``False``. + + .. versionchanged:: 1.1a1 + Add the *timeout* parameter. + ''' + return self._cond.wait(timeout=timeout) + + +class Channel(object): + + def __init__(self): + self.getters = collections.deque() + self.putters = collections.deque() + self.hub = get_hub() + self._event_unlock = None + + def __repr__(self): + return '<%s at %s %s>' % (type(self).__name__, hex(id(self)), self._format()) + + def __str__(self): + return '<%s %s>' % (type(self).__name__, self._format()) + + def _format(self): + result = '' + if self.getters: + result += ' getters[%s]' % len(self.getters) + if self.putters: + result += ' putters[%s]' % len(self.putters) + return result + + @property + def balance(self): + return len(self.putters) - len(self.getters) + + def qsize(self): + return 0 + + def empty(self): + return True + + def full(self): + return True + + def put(self, item, block=True, timeout=None): + if self.hub is getcurrent(): + if self.getters: + getter = self.getters.popleft() + getter.switch(item) + return + raise Full + + if not block: + timeout = 0 + + waiter = Waiter() + item = (item, waiter) + self.putters.append(item) + timeout = Timeout._start_new_or_dummy(timeout, Full) + try: + if self.getters: + self._schedule_unlock() + result = waiter.get() + if result is not waiter: + raise InvalidSwitchError("Invalid switch into Channel.put: %r" % (result, )) + except: + _safe_remove(self.putters, item) + raise + finally: + timeout.cancel() + + def put_nowait(self, item): + self.put(item, False) + + def get(self, block=True, timeout=None): + if self.hub is getcurrent(): + if self.putters: + item, putter = self.putters.popleft() + self.hub.loop.run_callback(putter.switch, putter) + return item + + if not block: + timeout = 0 + + waiter = Waiter() + timeout = Timeout._start_new_or_dummy(timeout, Empty) + try: + self.getters.append(waiter) + if self.putters: + self._schedule_unlock() + return waiter.get() + except: + self.getters.remove(waiter) + raise + finally: + timeout.cancel() + + def get_nowait(self): + return self.get(False) + + def _unlock(self): + while self.putters and self.getters: + getter = self.getters.popleft() + item, putter = self.putters.popleft() + getter.switch(item) + putter.switch(putter) + + def _schedule_unlock(self): + if not self._event_unlock: + self._event_unlock = self.hub.loop.run_callback(self._unlock) + + def __iter__(self): + return self + + def next(self): + result = self.get() + if result is StopIteration: + raise result + return result + + __next__ = next # py3 diff --git a/python/gevent/resolver_ares.py b/python/gevent/resolver_ares.py new file mode 100644 index 0000000..196e4c4 --- /dev/null +++ b/python/gevent/resolver_ares.py @@ -0,0 +1,388 @@ +# Copyright (c) 2011-2015 Denis Bilenko. See LICENSE for details. +""" +c-ares based hostname resolver. +""" +from __future__ import absolute_import +import os +import sys +from _socket import getservbyname, getaddrinfo, gaierror, error +from gevent.hub import Waiter, get_hub +from gevent._compat import string_types, text_type, integer_types, reraise, PY3 +from gevent.socket import AF_UNSPEC, AF_INET, AF_INET6, SOCK_STREAM, SOCK_DGRAM, SOCK_RAW, AI_NUMERICHOST, EAI_SERVICE, AI_PASSIVE +from gevent.ares import channel, InvalidIP # pylint:disable=import-error,no-name-in-module + + +__all__ = ['Resolver'] + + +class Resolver(object): + """ + Implementation of the resolver API using the `c-ares`_ library. + + This implementation uses the c-ares library to handle name + resolution. c-ares is natively asynchronous at the socket level + and so integrates well into gevent's event loop. + + In comparison to :class:`gevent.resolver_thread.Resolver` (which + delegates to the native system resolver), the implementation is + much more complex. In addition, there have been reports of it not + properly honoring certain system configurations (for example, the + order in which IPv4 and IPv6 results are returned may not match + the threaded resolver). However, because it does not use threads, + it may scale better for applications that make many lookups. + + There are some known differences from the system resolver: + + - ``gethostbyname_ex`` and ``gethostbyaddr`` may return different + for the ``aliaslist`` tuple member. (Sometimes the same, + sometimes in a different order, sometimes a different alias + altogether.) + - ``gethostbyname_ex`` may return the ``ipaddrlist`` in a different order. + - ``getaddrinfo`` does not return ``SOCK_RAW`` results. + - ``getaddrinfo`` may return results in a different order. + - Handling of ``.local`` (mDNS) names may be different, even if they are listed in + the hosts file. + - c-ares will not resolve ``broadcasthost``, even if listed in the hosts file. + - This implementation may raise ``gaierror(4)`` where the system implementation would raise + ``herror(1)``. + - The results for ``localhost`` may be different. In particular, some system + resolvers will return more results from ``getaddrinfo`` than c-ares does, + such as SOCK_DGRAM results, and c-ares may report more ips on a multi-homed + host. + + .. caution:: This module is considered extremely experimental on PyPy, and + due to its implementation in cython, it may be slower. It may also lead to + interpreter crashes. + + .. _c-ares: http://c-ares.haxx.se + """ + + ares_class = channel + + def __init__(self, hub=None, use_environ=True, **kwargs): + if hub is None: + hub = get_hub() + self.hub = hub + if use_environ: + for key in os.environ: + if key.startswith('GEVENTARES_'): + name = key[11:].lower() + if name: + value = os.environ[key] + kwargs.setdefault(name, value) + self.ares = self.ares_class(hub.loop, **kwargs) + self.pid = os.getpid() + self.params = kwargs + self.fork_watcher = hub.loop.fork(ref=False) + self.fork_watcher.start(self._on_fork) + + def __repr__(self): + return '' % (id(self), self.ares) + + def _on_fork(self): + # NOTE: See comment in gevent.hub.reinit. + pid = os.getpid() + if pid != self.pid: + self.hub.loop.run_callback(self.ares.destroy) + self.ares = self.ares_class(self.hub.loop, **self.params) + self.pid = pid + + def close(self): + if self.ares is not None: + self.hub.loop.run_callback(self.ares.destroy) + self.ares = None + self.fork_watcher.stop() + + def gethostbyname(self, hostname, family=AF_INET): + hostname = _resolve_special(hostname, family) + return self.gethostbyname_ex(hostname, family)[-1][0] + + def gethostbyname_ex(self, hostname, family=AF_INET): + if PY3: + if isinstance(hostname, str): + hostname = hostname.encode('idna') + elif not isinstance(hostname, (bytes, bytearray)): + raise TypeError('Expected es(idna), not %s' % type(hostname).__name__) + else: + if isinstance(hostname, text_type): + hostname = hostname.encode('ascii') + elif not isinstance(hostname, str): + raise TypeError('Expected string, not %s' % type(hostname).__name__) + + while True: + ares = self.ares + try: + waiter = Waiter(self.hub) + ares.gethostbyname(waiter, hostname, family) + result = waiter.get() + if not result[-1]: + raise gaierror(-5, 'No address associated with hostname') + return result + except gaierror: + if ares is self.ares: + if hostname == b'255.255.255.255': + # The stdlib handles this case in 2.7 and 3.x, but ares does not. + # It is tested by test_socket.py in 3.4. + # HACK: So hardcode the expected return. + return ('255.255.255.255', [], ['255.255.255.255']) + raise + # "self.ares is not ares" means channel was destroyed (because we were forked) + + def _lookup_port(self, port, socktype): + # pylint:disable=too-many-branches + socktypes = [] + if isinstance(port, string_types): + try: + port = int(port) + except ValueError: + try: + if socktype == 0: + origport = port + try: + port = getservbyname(port, 'tcp') + socktypes.append(SOCK_STREAM) + except error: + port = getservbyname(port, 'udp') + socktypes.append(SOCK_DGRAM) + else: + try: + if port == getservbyname(origport, 'udp'): + socktypes.append(SOCK_DGRAM) + except error: + pass + elif socktype == SOCK_STREAM: + port = getservbyname(port, 'tcp') + elif socktype == SOCK_DGRAM: + port = getservbyname(port, 'udp') + else: + raise gaierror(EAI_SERVICE, 'Servname not supported for ai_socktype') + except error as ex: + if 'not found' in str(ex): + raise gaierror(EAI_SERVICE, 'Servname not supported for ai_socktype') + else: + raise gaierror(str(ex)) + except UnicodeEncodeError: + raise error('Int or String expected') + elif port is None: + port = 0 + elif isinstance(port, integer_types): + pass + else: + raise error('Int or String expected', port, type(port)) + port = int(port % 65536) + if not socktypes and socktype: + socktypes.append(socktype) + return port, socktypes + + def _getaddrinfo(self, host, port, family=0, socktype=0, proto=0, flags=0): + # pylint:disable=too-many-locals,too-many-branches + if isinstance(host, text_type): + host = host.encode('idna') + elif not isinstance(host, str) or (flags & AI_NUMERICHOST): + # this handles cases which do not require network access + # 1) host is None + # 2) host is of an invalid type + # 3) AI_NUMERICHOST flag is set + return getaddrinfo(host, port, family, socktype, proto, flags) + # we also call _socket.getaddrinfo below if family is not one of AF_* + + port, socktypes = self._lookup_port(port, socktype) + + socktype_proto = [(SOCK_STREAM, 6), (SOCK_DGRAM, 17), (SOCK_RAW, 0)] + if socktypes: + socktype_proto = [(x, y) for (x, y) in socktype_proto if x in socktypes] + if proto: + socktype_proto = [(x, y) for (x, y) in socktype_proto if proto == y] + + ares = self.ares + + if family == AF_UNSPEC: + ares_values = Values(self.hub, 2) + ares.gethostbyname(ares_values, host, AF_INET) + ares.gethostbyname(ares_values, host, AF_INET6) + elif family == AF_INET: + ares_values = Values(self.hub, 1) + ares.gethostbyname(ares_values, host, AF_INET) + elif family == AF_INET6: + ares_values = Values(self.hub, 1) + ares.gethostbyname(ares_values, host, AF_INET6) + else: + raise gaierror(5, 'ai_family not supported: %r' % (family, )) + + values = ares_values.get() + if len(values) == 2 and values[0] == values[1]: + values.pop() + + result = [] + result4 = [] + result6 = [] + + for addrs in values: + if addrs.family == AF_INET: + for addr in addrs[-1]: + sockaddr = (addr, port) + for socktype4, proto4 in socktype_proto: + result4.append((AF_INET, socktype4, proto4, '', sockaddr)) + elif addrs.family == AF_INET6: + for addr in addrs[-1]: + if addr == '::1': + dest = result + else: + dest = result6 + sockaddr = (addr, port, 0, 0) + for socktype6, proto6 in socktype_proto: + dest.append((AF_INET6, socktype6, proto6, '', sockaddr)) + + # As of 2016, some platforms return IPV6 first and some do IPV4 first, + # and some might even allow configuration of which is which. For backwards + # compatibility with earlier releases (but not necessarily resolver_thread!) + # we return 4 first. See https://github.com/gevent/gevent/issues/815 for more. + result += result4 + result6 + + if not result: + raise gaierror(-5, 'No address associated with hostname') + + return result + + def getaddrinfo(self, host, port, family=0, socktype=0, proto=0, flags=0): + while True: + ares = self.ares + try: + return self._getaddrinfo(host, port, family, socktype, proto, flags) + except gaierror: + if ares is self.ares: + raise + + def _gethostbyaddr(self, ip_address): + if PY3: + if isinstance(ip_address, str): + ip_address = ip_address.encode('idna') + elif not isinstance(ip_address, (bytes, bytearray)): + raise TypeError('Expected es(idna), not %s' % type(ip_address).__name__) + else: + if isinstance(ip_address, text_type): + ip_address = ip_address.encode('ascii') + elif not isinstance(ip_address, str): + raise TypeError('Expected string, not %s' % type(ip_address).__name__) + + waiter = Waiter(self.hub) + try: + self.ares.gethostbyaddr(waiter, ip_address) + return waiter.get() + except InvalidIP: + result = self._getaddrinfo(ip_address, None, family=AF_UNSPEC, socktype=SOCK_DGRAM) + if not result: + raise + _ip_address = result[0][-1][0] + if isinstance(_ip_address, text_type): + _ip_address = _ip_address.encode('ascii') + if _ip_address == ip_address: + raise + waiter.clear() + self.ares.gethostbyaddr(waiter, _ip_address) + return waiter.get() + + def gethostbyaddr(self, ip_address): + ip_address = _resolve_special(ip_address, AF_UNSPEC) + while True: + ares = self.ares + try: + return self._gethostbyaddr(ip_address) + except gaierror: + if ares is self.ares: + raise + + def _getnameinfo(self, sockaddr, flags): + if not isinstance(flags, int): + raise TypeError('an integer is required') + if not isinstance(sockaddr, tuple): + raise TypeError('getnameinfo() argument 1 must be a tuple') + + address = sockaddr[0] + if not PY3 and isinstance(address, text_type): + address = address.encode('ascii') + + if not isinstance(address, string_types): + raise TypeError('sockaddr[0] must be a string, not %s' % type(address).__name__) + + port = sockaddr[1] + if not isinstance(port, int): + raise TypeError('port must be an integer, not %s' % type(port)) + + waiter = Waiter(self.hub) + result = self._getaddrinfo(address, str(sockaddr[1]), family=AF_UNSPEC, socktype=SOCK_DGRAM) + if not result: + reraise(*sys.exc_info()) + elif len(result) != 1: + raise error('sockaddr resolved to multiple addresses') + family, _socktype, _proto, _name, address = result[0] + + if family == AF_INET: + if len(sockaddr) != 2: + raise error("IPv4 sockaddr must be 2 tuple") + elif family == AF_INET6: + address = address[:2] + sockaddr[2:] + + self.ares.getnameinfo(waiter, address, flags) + node, service = waiter.get() + + if service is None: + if PY3: + # ares docs: "If the query did not complete + # successfully, or one of the values was not + # requested, node or service will be NULL ". Python 2 + # allows that for the service, but Python 3 raises + # an error. This is tested by test_socket in py 3.4 + err = gaierror('nodename nor servname provided, or not known') + err.errno = 8 + raise err + service = '0' + return node, service + + def getnameinfo(self, sockaddr, flags): + while True: + ares = self.ares + try: + return self._getnameinfo(sockaddr, flags) + except gaierror: + if ares is self.ares: + raise + + +class Values(object): + # helper to collect multiple values; ignore errors unless nothing has succeeded + # QQQ could probably be moved somewhere - hub.py? + + __slots__ = ['count', 'values', 'error', 'waiter'] + + def __init__(self, hub, count): + self.count = count + self.values = [] + self.error = None + self.waiter = Waiter(hub) + + def __call__(self, source): + self.count -= 1 + if source.exception is None: + self.values.append(source.value) + else: + self.error = source.exception + if self.count <= 0: + self.waiter.switch() + + def get(self): + self.waiter.get() + if self.values: + return self.values + else: + assert error is not None + raise self.error # pylint:disable=raising-bad-type + + +def _resolve_special(hostname, family): + if hostname == '': + result = getaddrinfo(None, 0, family, SOCK_DGRAM, 0, AI_PASSIVE) + if len(result) != 1: + raise error('wildcard resolved to multiple address') + return result[0][4][0] + return hostname diff --git a/python/gevent/resolver_thread.py b/python/gevent/resolver_thread.py new file mode 100644 index 0000000..ce69eaf --- /dev/null +++ b/python/gevent/resolver_thread.py @@ -0,0 +1,71 @@ +# Copyright (c) 2012-2015 Denis Bilenko. See LICENSE for details. +""" +Native thread-based hostname resolver. +""" +import _socket +from gevent._compat import text_type +from gevent.hub import get_hub + + +__all__ = ['Resolver'] + + +# trigger import of encodings.idna to avoid https://github.com/gevent/gevent/issues/349 +text_type('foo').encode('idna') + + +class Resolver(object): + """ + Implementation of the resolver API using native threads and native resolution + functions. + + Using the native resolution mechanisms ensures the highest + compatibility with what a non-gevent program would return + including good support for platform specific configuration + mechanisms. The use of native (non-greenlet) threads ensures that + a caller doesn't block other greenlets. + + This implementation also has the benefit of being very simple in comparison to + :class:`gevent.resolver_ares.Resolver`. + + .. tip:: + + Most users find this resolver to be quite reliable in a + properly monkey-patched environment. However, there have been + some reports of long delays, slow performance or even hangs, + particularly in long-lived programs that make many, many DNS + requests. If you suspect that may be happening to you, try the + ares resolver (and submit a bug report). + """ + def __init__(self, hub=None): + if hub is None: + hub = get_hub() + self.pool = hub.threadpool + if _socket.gaierror not in hub.NOT_ERROR: + # Do not cause lookup failures to get printed by the default + # error handler. This can be very noisy. + hub.NOT_ERROR += (_socket.gaierror, _socket.herror) + + def __repr__(self): + return '' % (id(self), self.pool) + + def close(self): + pass + + # from briefly reading socketmodule.c, it seems that all of the functions + # below are thread-safe in Python, even if they are not thread-safe in C. + + def gethostbyname(self, *args): + return self.pool.apply(_socket.gethostbyname, args) + + def gethostbyname_ex(self, *args): + return self.pool.apply(_socket.gethostbyname_ex, args) + + def getaddrinfo(self, *args, **kwargs): + return self.pool.apply(_socket.getaddrinfo, args, kwargs) + + def gethostbyaddr(self, *args, **kwargs): + return self.pool.apply(_socket.gethostbyaddr, args, kwargs) + + def getnameinfo(self, *args, **kwargs): + return self.pool.apply(_socket.getnameinfo, args, kwargs) diff --git a/python/gevent/select.py b/python/gevent/select.py new file mode 100644 index 0000000..e5680b5 --- /dev/null +++ b/python/gevent/select.py @@ -0,0 +1,244 @@ +# Copyright (c) 2009-2011 Denis Bilenko. See LICENSE for details. +""" +Waiting for I/O completion. +""" +from __future__ import absolute_import + +import sys + +from gevent.event import Event +from gevent.hub import get_hub +from gevent.hub import sleep as _g_sleep +from gevent._compat import integer_types +from gevent._compat import iteritems +from gevent._compat import itervalues +from gevent._util import copy_globals +from gevent._util import _NONE + +from errno import EINTR +if sys.platform.startswith('win32'): + def _original_select(_r, _w, _x, _t): + # windows cant handle three empty lists, but we've always + # accepted that, so don't try the compliance check on windows + return ((), (), ()) +else: + from select import select as _original_select + +try: + from select import poll as original_poll + from select import POLLIN, POLLOUT, POLLNVAL + __implements__ = ['select', 'poll'] +except ImportError: + original_poll = None + __implements__ = ['select'] + +__all__ = ['error'] + __implements__ + +import select as __select__ + +error = __select__.error + +__imports__ = copy_globals(__select__, globals(), + names_to_ignore=__all__, + dunder_names_to_keep=()) + +_EV_READ = 1 +_EV_WRITE = 2 + +def get_fileno(obj): + try: + fileno_f = obj.fileno + except AttributeError: + if not isinstance(obj, integer_types): + raise TypeError('argument must be an int, or have a fileno() method: %r' % (obj,)) + return obj + else: + return fileno_f() + + +class SelectResult(object): + __slots__ = ('read', 'write', 'event') + + def __init__(self): + self.read = [] + self.write = [] + self.event = Event() + + def add_read(self, socket): + self.read.append(socket) + self.event.set() + + add_read.event = _EV_READ + + def add_write(self, socket): + self.write.append(socket) + self.event.set() + + add_write.event = _EV_WRITE + + def __add_watchers(self, watchers, fdlist, callback, io, pri): + for fd in fdlist: + watcher = io(get_fileno(fd), callback.event) + watcher.priority = pri + watchers.append(watcher) + watcher.start(callback, fd) + + def _make_watchers(self, watchers, rlist, wlist): + loop = get_hub().loop + io = loop.io + MAXPRI = loop.MAXPRI + + try: + self.__add_watchers(watchers, rlist, self.add_read, io, MAXPRI) + self.__add_watchers(watchers, wlist, self.add_write, io, MAXPRI) + except IOError as ex: + raise error(*ex.args) + + def _closeall(self, watchers): + for watcher in watchers: + watcher.stop() + del watchers[:] + + def select(self, rlist, wlist, timeout): + watchers = [] + try: + self._make_watchers(watchers, rlist, wlist) + self.event.wait(timeout=timeout) + return self.read, self.write, [] + finally: + self._closeall(watchers) + + +def select(rlist, wlist, xlist, timeout=None): # pylint:disable=unused-argument + """An implementation of :meth:`select.select` that blocks only the current greenlet. + + .. caution:: *xlist* is ignored. + + .. versionchanged:: 1.2a1 + Raise a :exc:`ValueError` if timeout is negative. This matches Python 3's + behaviour (Python 2 would raise a ``select.error``). Previously gevent had + undefined behaviour. + .. versionchanged:: 1.2a1 + Raise an exception if any of the file descriptors are invalid. + """ + if timeout is not None and timeout < 0: + # Raise an error like the real implementation; which error + # depends on the version. Python 3, where select.error is OSError, + # raises a ValueError (which makes sense). Older pythons raise + # the error from the select syscall...but we don't actually get there. + # We choose to just raise the ValueError as it makes more sense and is + # forward compatible + raise ValueError("timeout must be non-negative") + + # First, do a poll with the original select system call. This + # is the most efficient way to check to see if any of the file descriptors + # have previously been closed and raise the correct corresponding exception. + # (Because libev tends to just return them as ready...) + # We accept the *xlist* here even though we can't below because this is all about + # error handling. + sel_results = ((), (), ()) + try: + sel_results = _original_select(rlist, wlist, xlist, 0) + except error as e: + enumber = getattr(e, 'errno', None) or e.args[0] + if enumber != EINTR: + # Ignore interrupted syscalls + raise + + if sel_results[0] or sel_results[1] or sel_results[2]: + # If we actually had stuff ready, go ahead and return it. No need + # to go through the trouble of doing our own stuff. + # However, because this is typically a place where scheduling switches + # can occur, we need to make sure that's still the case; otherwise a single + # consumer could monopolize the thread. (shows up in test_ftplib.) + _g_sleep() + return sel_results + + result = SelectResult() + return result.select(rlist, wlist, timeout) + + +if original_poll is not None: + class PollResult(object): + __slots__ = ('events', 'event') + + def __init__(self): + self.events = set() + self.event = Event() + + def add_event(self, events, fd): + if events < 0: + result_flags = POLLNVAL + else: + result_flags = 0 + if events & _EV_READ: + result_flags = POLLIN + if events & _EV_WRITE: + result_flags |= POLLOUT + + self.events.add((fd, result_flags)) + self.event.set() + + class poll(object): + """ + An implementation of :class:`select.poll` that blocks only the current greenlet. + + .. caution:: ``POLLPRI`` data is not supported. + + .. versionadded:: 1.1b1 + """ + def __init__(self): + self.fds = {} # {int -> watcher} + self.loop = get_hub().loop + + def register(self, fd, eventmask=_NONE): + if eventmask is _NONE: + flags = _EV_READ | _EV_WRITE + else: + flags = 0 + if eventmask & POLLIN: + flags = _EV_READ + if eventmask & POLLOUT: + flags |= _EV_WRITE + # If they ask for POLLPRI, we can't support + # that. Should we raise an error? + + fileno = get_fileno(fd) + watcher = self.loop.io(fileno, flags) + watcher.priority = self.loop.MAXPRI + self.fds[fileno] = watcher + + def modify(self, fd, eventmask): + self.register(fd, eventmask) + + def poll(self, timeout=None): + """ + poll the registered fds. + + .. versionchanged:: 1.2a1 + File descriptors that are closed are reported with POLLNVAL. + """ + result = PollResult() + try: + for fd, watcher in iteritems(self.fds): + watcher.start(result.add_event, fd, pass_events=True) + if timeout is not None and timeout > -1: + timeout /= 1000.0 + result.event.wait(timeout=timeout) + return list(result.events) + finally: + for awatcher in itervalues(self.fds): + awatcher.stop() + + def unregister(self, fd): + """ + Unregister the *fd*. + + .. versionchanged:: 1.2a1 + Raise a `KeyError` if *fd* was not registered, like the standard + library. Previously gevent did nothing. + """ + fileno = get_fileno(fd) + del self.fds[fileno] + +del original_poll diff --git a/python/gevent/server.py b/python/gevent/server.py new file mode 100644 index 0000000..f2afab7 --- /dev/null +++ b/python/gevent/server.py @@ -0,0 +1,255 @@ +# Copyright (c) 2009-2012 Denis Bilenko. See LICENSE for details. +"""TCP/SSL server""" +import sys +import _socket +from gevent.baseserver import BaseServer +from gevent.socket import EWOULDBLOCK, socket +from gevent._compat import PYPY, PY3 + +__all__ = ['StreamServer', 'DatagramServer'] + + +if sys.platform == 'win32': + # SO_REUSEADDR on Windows does not mean the same thing as on *nix (issue #217) + DEFAULT_REUSE_ADDR = None +else: + DEFAULT_REUSE_ADDR = 1 + + +class StreamServer(BaseServer): + """ + A generic TCP server. + + Accepts connections on a listening socket and spawns user-provided + *handle* function for each connection with 2 arguments: the client + socket and the client address. + + Note that although the errors in a successfully spawned handler + will not affect the server or other connections, the errors raised + by :func:`accept` and *spawn* cause the server to stop accepting + for a short amount of time. The exact period depends on the values + of :attr:`min_delay` and :attr:`max_delay` attributes. + + The delay starts with :attr:`min_delay` and doubles with each + successive error until it reaches :attr:`max_delay`. A successful + :func:`accept` resets the delay to :attr:`min_delay` again. + + See :class:`~gevent.baseserver.BaseServer` for information on defining the *handle* + function and important restrictions on it. + + **SSL Support** + + The server can optionally work in SSL mode when given the correct + keyword arguments. (That is, the presence of any keyword arguments + will trigger SSL mode.) On Python 2.7.9 and later (any Python + version that supports the :class:`ssl.SSLContext`), this can be + done with a configured ``SSLContext``. On any Python version, it + can be done by passing the appropriate arguments for + :func:`ssl.wrap_socket`. + + The incoming socket will be wrapped into an SSL socket before + being passed to the *handle* function. + + If the *ssl_context* keyword argument is present, it should + contain an :class:`ssl.SSLContext`. The remaining keyword + arguments are passed to the :meth:`ssl.SSLContext.wrap_socket` + method of that object. Depending on the Python version, supported arguments + may include: + + - server_hostname + - suppress_ragged_eofs + - do_handshake_on_connect + + .. caution:: When using an SSLContext, it should either be + imported from :mod:`gevent.ssl`, or the process needs to be monkey-patched. + If the process is not monkey-patched and you pass the standard library + SSLContext, the resulting client sockets will not cooperate with gevent. + + Otherwise, keyword arguments are assumed to apply to :func:`ssl.wrap_socket`. + These keyword arguments bay include: + + - keyfile + - certfile + - cert_reqs + - ssl_version + - ca_certs + - suppress_ragged_eofs + - do_handshake_on_connect + - ciphers + + .. versionchanged:: 1.2a2 + Add support for the *ssl_context* keyword argument. + + """ + # the default backlog to use if none was provided in __init__ + backlog = 256 + + reuse_addr = DEFAULT_REUSE_ADDR + + def __init__(self, listener, handle=None, backlog=None, spawn='default', **ssl_args): + BaseServer.__init__(self, listener, handle=handle, spawn=spawn) + try: + if ssl_args: + ssl_args.setdefault('server_side', True) + if 'ssl_context' in ssl_args: + ssl_context = ssl_args.pop('ssl_context') + self.wrap_socket = ssl_context.wrap_socket + self.ssl_args = ssl_args + else: + from gevent.ssl import wrap_socket + self.wrap_socket = wrap_socket + self.ssl_args = ssl_args + else: + self.ssl_args = None + if backlog is not None: + if hasattr(self, 'socket'): + raise TypeError('backlog must be None when a socket instance is passed') + self.backlog = backlog + except: + self.close() + raise + + @property + def ssl_enabled(self): + return self.ssl_args is not None + + def set_listener(self, listener): + BaseServer.set_listener(self, listener) + try: + self.socket = self.socket._sock + except AttributeError: + pass + + def init_socket(self): + if not hasattr(self, 'socket'): + # FIXME: clean up the socket lifetime + # pylint:disable=attribute-defined-outside-init + self.socket = self.get_listener(self.address, self.backlog, self.family) + self.address = self.socket.getsockname() + if self.ssl_args: + self._handle = self.wrap_socket_and_handle + else: + self._handle = self.handle + + @classmethod + def get_listener(cls, address, backlog=None, family=None): + if backlog is None: + backlog = cls.backlog + return _tcp_listener(address, backlog=backlog, reuse_addr=cls.reuse_addr, family=family) + + if PY3: + + def do_read(self): + sock = self.socket + try: + fd, address = sock._accept() + except BlockingIOError: # python 2: pylint: disable=undefined-variable + if not sock.timeout: + return + raise + sock = socket(sock.family, sock.type, sock.proto, fileno=fd) + # XXX Python issue #7995? + return sock, address + + else: + + def do_read(self): + try: + client_socket, address = self.socket.accept() + except _socket.error as err: + if err.args[0] == EWOULDBLOCK: + return + raise + sockobj = socket(_sock=client_socket) + if PYPY: + client_socket._drop() + return sockobj, address + + def do_close(self, sock, *args): + # pylint:disable=arguments-differ + sock.close() + + def wrap_socket_and_handle(self, client_socket, address): + # used in case of ssl sockets + ssl_socket = self.wrap_socket(client_socket, **self.ssl_args) + return self.handle(ssl_socket, address) + + +class DatagramServer(BaseServer): + """A UDP server""" + + reuse_addr = DEFAULT_REUSE_ADDR + + def __init__(self, *args, **kwargs): + # The raw (non-gevent) socket, if possible + self._socket = None + BaseServer.__init__(self, *args, **kwargs) + from gevent.lock import Semaphore + self._writelock = Semaphore() + + def init_socket(self): + if not hasattr(self, 'socket'): + # FIXME: clean up the socket lifetime + # pylint:disable=attribute-defined-outside-init + self.socket = self.get_listener(self.address, self.family) + self.address = self.socket.getsockname() + self._socket = self.socket + try: + self._socket = self._socket._sock + except AttributeError: + pass + + @classmethod + def get_listener(cls, address, family=None): + return _udp_socket(address, reuse_addr=cls.reuse_addr, family=family) + + def do_read(self): + try: + data, address = self._socket.recvfrom(8192) + except _socket.error as err: + if err.args[0] == EWOULDBLOCK: + return + raise + return data, address + + def sendto(self, *args): + self._writelock.acquire() + try: + self.socket.sendto(*args) + finally: + self._writelock.release() + + +def _tcp_listener(address, backlog=50, reuse_addr=None, family=_socket.AF_INET): + """A shortcut to create a TCP socket, bind it and put it into listening state.""" + sock = socket(family=family) + if reuse_addr is not None: + sock.setsockopt(_socket.SOL_SOCKET, _socket.SO_REUSEADDR, reuse_addr) + try: + sock.bind(address) + except _socket.error as ex: + strerror = getattr(ex, 'strerror', None) + if strerror is not None: + ex.strerror = strerror + ': ' + repr(address) + raise + sock.listen(backlog) + sock.setblocking(0) + return sock + + +def _udp_socket(address, backlog=50, reuse_addr=None, family=_socket.AF_INET): + # backlog argument for compat with tcp_listener + # pylint:disable=unused-argument + + # we want gevent.socket.socket here + sock = socket(family=family, type=_socket.SOCK_DGRAM) + if reuse_addr is not None: + sock.setsockopt(_socket.SOL_SOCKET, _socket.SO_REUSEADDR, reuse_addr) + try: + sock.bind(address) + except _socket.error as ex: + strerror = getattr(ex, 'strerror', None) + if strerror is not None: + ex.strerror = strerror + ': ' + repr(address) + raise + return sock diff --git a/python/gevent/signal.py b/python/gevent/signal.py new file mode 100644 index 0000000..fc46018 --- /dev/null +++ b/python/gevent/signal.py @@ -0,0 +1,137 @@ +""" +Cooperative implementation of special cases of :func:`signal.signal`. + +This module is designed to work with libev's child watchers, as used +by default in :func:`gevent.os.fork` Note that each ``SIGCHLD`` handler +will be run in a new greenlet when the signal is delivered (just like +:class:`gevent.hub.signal`) + +The implementations in this module are only monkey patched if +:func:`gevent.os.waitpid` is being used (the default) and if +:const:`signal.SIGCHLD` is available; see :func:`gevent.os.fork` for +information on configuring this not to be the case for advanced uses. + +.. versionadded:: 1.1b4 +""" + +from __future__ import absolute_import + +from gevent._util import _NONE as _INITIAL +from gevent._util import copy_globals + +import signal as _signal + +__implements__ = [] +__extensions__ = [] + + +_child_handler = _INITIAL + +_signal_signal = _signal.signal +_signal_getsignal = _signal.getsignal + + +def getsignal(signalnum): + """ + Exactly the same as :func:`signal.signal` except where + :const:`signal.SIGCHLD` is concerned. + + For :const:`signal.SIGCHLD`, this cooperates with :func:`signal` + to provide consistent answers. + """ + if signalnum != _signal.SIGCHLD: + return _signal_getsignal(signalnum) + + global _child_handler + if _child_handler is _INITIAL: + _child_handler = _signal_getsignal(_signal.SIGCHLD) + + return _child_handler + + +def signal(signalnum, handler): + """ + Exactly the same as :func:`signal.signal` except where + :const:`signal.SIGCHLD` is concerned. + + .. note:: + + A :const:`signal.SIGCHLD` handler installed with this function + will only be triggered for children that are forked using + :func:`gevent.os.fork` (:func:`gevent.os.fork_and_watch`); + children forked before monkey patching, or otherwise by the raw + :func:`os.fork`, will not trigger the handler installed by this + function. (It's unlikely that a SIGCHLD handler installed with + the builtin :func:`signal.signal` would be triggered either; + libev typically overwrites such a handler at the C level. At + the very least, it's full of race conditions.) + + .. note:: + + Use of ``SIG_IGN`` and ``SIG_DFL`` may also have race conditions + with libev child watchers and the :mod:`gevent.subprocess` module. + + .. versionchanged:: 1.2a1 + If ``SIG_IGN`` or ``SIG_DFL`` are used to ignore ``SIGCHLD``, a + future use of ``gevent.subprocess`` and libev child watchers + will once again work. However, on Python 2, use of ``os.popen`` + will fail. + + .. versionchanged:: 1.1rc2 + Allow using ``SIG_IGN`` and ``SIG_DFL`` to reset and ignore ``SIGCHLD``. + However, this allows the possibility of a race condition if ``gevent.subprocess`` + had already been used. + """ + if signalnum != _signal.SIGCHLD: + return _signal_signal(signalnum, handler) + + # TODO: raise value error if not called from the main + # greenlet, just like threads + + if handler != _signal.SIG_IGN and handler != _signal.SIG_DFL and not callable(handler): + # exact same error message raised by the stdlib + raise TypeError("signal handler must be signal.SIG_IGN, signal.SIG_DFL, or a callable object") + + old_handler = getsignal(signalnum) + global _child_handler + _child_handler = handler + if handler == _signal.SIG_IGN or handler == _signal.SIG_DFL: + # Allow resetting/ignoring this signal at the process level. + # Note that this conflicts with gevent.subprocess and other users + # of child watchers, until the next time gevent.subprocess/loop.install_sigchld() + # is called. + from gevent import get_hub # Are we always safe to import here? + _signal_signal(signalnum, handler) + get_hub().loop.reset_sigchld() + return old_handler + + +def _on_child_hook(): + # This is called in the hub greenlet. To let the function + # do more useful work, like use blocking functions, + # we run it in a new greenlet; see gevent.hub.signal + if callable(_child_handler): + # None is a valid value for the frame argument + from gevent import Greenlet + greenlet = Greenlet(_child_handler, _signal.SIGCHLD, None) + greenlet.switch() + + +import gevent.os + +if 'waitpid' in gevent.os.__implements__ and hasattr(_signal, 'SIGCHLD'): + # Tightly coupled here to gevent.os and its waitpid implementation; only use these + # if necessary. + gevent.os._on_child_hook = _on_child_hook + __implements__.append("signal") + __implements__.append("getsignal") +else: + # XXX: This breaks test__all__ on windows + __extensions__.append("signal") + __extensions__.append("getsignal") + +__imports__ = copy_globals(_signal, globals(), + names_to_ignore=__implements__ + __extensions__, + dunder_names_to_keep=()) + +__all__ = __implements__ + __extensions__ diff --git a/python/gevent/socket.py b/python/gevent/socket.py new file mode 100644 index 0000000..50f7a59 --- /dev/null +++ b/python/gevent/socket.py @@ -0,0 +1,106 @@ +# Copyright (c) 2009-2014 Denis Bilenko and gevent contributors. See LICENSE for details. + +"""Cooperative low-level networking interface. + +This module provides socket operations and some related functions. +The API of the functions and classes matches the API of the corresponding +items in the standard :mod:`socket` module exactly, but the synchronous functions +in this module only block the current greenlet and let the others run. + +For convenience, exceptions (like :class:`error ` and :class:`timeout `) +as well as the constants from the :mod:`socket` module are imported into this module. +""" +# Our import magic sadly makes this warning useless +# pylint: disable=undefined-variable + +import sys +from gevent._compat import PY3 +from gevent._util import copy_globals + + +if PY3: + from gevent import _socket3 as _source # python 2: pylint:disable=no-name-in-module +else: + from gevent import _socket2 as _source + +# define some things we're expecting to overwrite; each module +# needs to define these +__implements__ = __dns__ = __all__ = __extensions__ = __imports__ = () + + +class error(Exception): + errno = None + + +def getfqdn(*args): + # pylint:disable=unused-argument + raise NotImplementedError() + +copy_globals(_source, globals(), + dunder_names_to_keep=('__implements__', '__dns__', '__all__', + '__extensions__', '__imports__', '__socket__'), + cleanup_globs=False) + +# The _socket2 and _socket3 don't import things defined in +# __extensions__, to help avoid confusing reference cycles in the +# documentation and to prevent importing from the wrong place, but we +# *do* need to expose them here. (NOTE: This may lead to some sphinx +# warnings like: +# WARNING: missing attribute mentioned in :members: or __all__: +# module gevent._socket2, attribute cancel_wait +# These can be ignored.) +from gevent import _socketcommon +copy_globals(_socketcommon, globals(), + only_names=_socketcommon.__extensions__) + +try: + _GLOBAL_DEFAULT_TIMEOUT = __socket__._GLOBAL_DEFAULT_TIMEOUT +except AttributeError: + _GLOBAL_DEFAULT_TIMEOUT = object() + + +def create_connection(address, timeout=_GLOBAL_DEFAULT_TIMEOUT, source_address=None): + """Connect to *address* and return the socket object. + + Convenience function. Connect to *address* (a 2-tuple ``(host, + port)``) and return the socket object. Passing the optional + *timeout* parameter will set the timeout on the socket instance + before attempting to connect. If no *timeout* is supplied, the + global default timeout setting returned by :func:`getdefaulttimeout` + is used. If *source_address* is set it must be a tuple of (host, port) + for the socket to bind as a source address before making the connection. + A host of '' or port 0 tells the OS to use the default. + """ + + host, port = address + err = None + for res in getaddrinfo(host, port, 0 if has_ipv6 else AF_INET, SOCK_STREAM): + af, socktype, proto, _, sa = res + sock = None + try: + sock = socket(af, socktype, proto) + if timeout is not _GLOBAL_DEFAULT_TIMEOUT: + sock.settimeout(timeout) + if source_address: + sock.bind(source_address) + sock.connect(sa) + return sock + except error as ex: + # without exc_clear(), if connect() fails once, the socket is referenced by the frame in exc_info + # and the next bind() fails (see test__socket.TestCreateConnection) + # that does not happen with regular sockets though, because _socket.socket.connect() is a built-in. + # this is similar to "getnameinfo loses a reference" failure in test_socket.py + if not PY3: + sys.exc_clear() # pylint:disable=no-member,useless-suppression + if sock is not None: + sock.close() + err = ex + if err is not None: + raise err # pylint:disable=raising-bad-type + else: + raise error("getaddrinfo returns an empty list") + +# This is promised to be in the __all__ of the _source, but, for circularity reasons, +# we implement it in this module. Mostly for documentation purposes, put it +# in the _source too. +_source.create_connection = create_connection diff --git a/python/gevent/ssl.py b/python/gevent/ssl.py new file mode 100644 index 0000000..42f2b1b --- /dev/null +++ b/python/gevent/ssl.py @@ -0,0 +1,26 @@ +""" +Secure Sockets Layer (SSL/TLS) module. +""" +from gevent._compat import PY2 +from gevent._util import copy_globals + +# things we expect to override, here for static analysis +def wrap_socket(_sock, **_kwargs): + # pylint:disable=unused-argument + raise NotImplementedError() + +if PY2: + if hasattr(__import__('ssl'), 'SSLContext'): + # It's not sufficient to check for >= 2.7.9; some distributions + # have backported most of PEP 466. Try to accommodate them. See Issue #702. + # We're just about to import ssl anyway so it's fine to import it here, just + # don't pollute the namespace + from gevent import _sslgte279 as _source + else: + from gevent import _ssl2 as _source # pragma: no cover +else: + # Py3 + from gevent import _ssl3 as _source # pragma: no cover + + +copy_globals(_source, globals()) diff --git a/python/gevent/subprocess.py b/python/gevent/subprocess.py new file mode 100644 index 0000000..2ea165e --- /dev/null +++ b/python/gevent/subprocess.py @@ -0,0 +1,1480 @@ +""" +Cooperative ``subprocess`` module. + +.. caution:: On POSIX platforms, this module is not usable from native + threads other than the main thread; attempting to do so will raise + a :exc:`TypeError`. This module depends on libev's fork watchers. + On POSIX systems, fork watchers are implemented using signals, and + the thread to which process-directed signals are delivered `is not + defined`_. Because each native thread has its own gevent/libev + loop, this means that a fork watcher registered with one loop + (thread) may never see the signal about a child it spawned if the + signal is sent to a different thread. + +.. note:: The interface of this module is intended to match that of + the standard library :mod:`subprocess` module (with many backwards + compatible extensions from Python 3 backported to Python 2). There + are some small differences between the Python 2 and Python 3 + versions of that module (the Python 2 ``TimeoutExpired`` exception, + notably, extends ``Timeout`` and there is no ``SubprocessError``) and between the + POSIX and Windows versions. The HTML documentation here can only + describe one version; for definitive documentation, see the + standard library or the source code. + +.. _is not defined: http://www.linuxprogrammingblog.com/all-about-linux-signals?page=11 +""" +from __future__ import absolute_import, print_function +# Can we split this up to make it cleaner? See https://github.com/gevent/gevent/issues/748 +# pylint: disable=too-many-lines +# Import magic +# pylint: disable=undefined-all-variable,undefined-variable +# Most of this we inherit from the standard lib +# pylint: disable=bare-except,too-many-locals,too-many-statements,attribute-defined-outside-init +# pylint: disable=too-many-branches,too-many-instance-attributes +# Most of this is cross-platform +# pylint: disable=no-member,expression-not-assigned,unused-argument,unused-variable +import errno +import gc +import os +import signal +import sys +import traceback +from gevent.event import AsyncResult +from gevent.hub import get_hub, linkproxy, sleep, getcurrent +from gevent._compat import integer_types, string_types, xrange +from gevent._compat import PY3 +from gevent._compat import reraise +from gevent._util import _NONE +from gevent._util import copy_globals +from gevent.fileobject import FileObject +from gevent.greenlet import Greenlet, joinall +spawn = Greenlet.spawn +import subprocess as __subprocess__ + + +# Standard functions and classes that this module re-implements in a gevent-aware way. +__implements__ = [ + 'Popen', + 'call', + 'check_call', + 'check_output', +] +if PY3 and not sys.platform.startswith('win32'): + __implements__.append("_posixsubprocess") + _posixsubprocess = None + +# Some symbols we define that we expect to export; +# useful for static analysis +PIPE = "PIPE should be imported" + +# Standard functions and classes that this module re-imports. +__imports__ = [ + 'PIPE', + 'STDOUT', + 'CalledProcessError', + # Windows: + 'CREATE_NEW_CONSOLE', + 'CREATE_NEW_PROCESS_GROUP', + 'STD_INPUT_HANDLE', + 'STD_OUTPUT_HANDLE', + 'STD_ERROR_HANDLE', + 'SW_HIDE', + 'STARTF_USESTDHANDLES', + 'STARTF_USESHOWWINDOW', +] + + +__extra__ = [ + 'MAXFD', + '_eintr_retry_call', + 'STARTUPINFO', + 'pywintypes', + 'list2cmdline', + '_subprocess', + '_winapi', + # Python 2.5 does not have _subprocess, so we don't use it + # XXX We don't run on Py 2.5 anymore; can/could/should we use _subprocess? + # It's only used on mswindows + 'WAIT_OBJECT_0', + 'WaitForSingleObject', + 'GetExitCodeProcess', + 'GetStdHandle', + 'CreatePipe', + 'DuplicateHandle', + 'GetCurrentProcess', + 'DUPLICATE_SAME_ACCESS', + 'GetModuleFileName', + 'GetVersion', + 'CreateProcess', + 'INFINITE', + 'TerminateProcess', + + # These were added for 3.5, but we make them available everywhere. + 'run', + 'CompletedProcess', +] + +if sys.version_info[:2] >= (3, 3): + __imports__ += [ + 'DEVNULL', + 'getstatusoutput', + 'getoutput', + 'SubprocessError', + 'TimeoutExpired', + ] +else: + __extra__.append("TimeoutExpired") + + +if sys.version_info[:2] >= (3, 5): + __extra__.remove('run') + __extra__.remove('CompletedProcess') + __implements__.append('run') + __implements__.append('CompletedProcess') + + # Removed in Python 3.5; this is the exact code that was removed: + # https://hg.python.org/cpython/rev/f98b0a5e5ef5 + __extra__.remove('MAXFD') + try: + MAXFD = os.sysconf("SC_OPEN_MAX") + except: + MAXFD = 256 + +if sys.version_info[:2] >= (3, 6): + # This was added to __all__ for windows in 3.6 + __extra__.remove('STARTUPINFO') + __imports__.append('STARTUPINFO') + +actually_imported = copy_globals(__subprocess__, globals(), + only_names=__imports__, + ignore_missing_names=True) +# anything we couldn't import from here we may need to find +# elsewhere +__extra__.extend(set(__imports__).difference(set(actually_imported))) +__imports__ = actually_imported +del actually_imported + + +# In Python 3 on Windows, a lot of the functions previously +# in _subprocess moved to _winapi +_subprocess = getattr(__subprocess__, '_subprocess', _NONE) +_winapi = getattr(__subprocess__, '_winapi', _NONE) + +_attr_resolution_order = [__subprocess__, _subprocess, _winapi] + +for name in list(__extra__): + if name in globals(): + continue + value = _NONE + for place in _attr_resolution_order: + value = getattr(place, name, _NONE) + if value is not _NONE: + break + + if value is _NONE: + __extra__.remove(name) + else: + globals()[name] = value + +del _attr_resolution_order +__all__ = __implements__ + __imports__ +# Some other things we want to document +for _x in ('run', 'CompletedProcess', 'TimeoutExpired'): + if _x not in __all__: + __all__.append(_x) + + +mswindows = sys.platform == 'win32' +if mswindows: + import msvcrt # pylint: disable=import-error + if PY3: + class Handle(int): + closed = False + + def Close(self): + if not self.closed: + self.closed = True + _winapi.CloseHandle(self) + + def Detach(self): + if not self.closed: + self.closed = True + return int(self) + raise ValueError("already closed") + + def __repr__(self): + return "Handle(%d)" % int(self) + + __del__ = Close + __str__ = __repr__ +else: + import fcntl + import pickle + from gevent import monkey + fork = monkey.get_original('os', 'fork') + from gevent.os import fork_and_watch + +def call(*popenargs, **kwargs): + """ + call(args, *, stdin=None, stdout=None, stderr=None, shell=False, timeout=None) -> returncode + + Run command with arguments. Wait for command to complete or + timeout, then return the returncode attribute. + + The arguments are the same as for the Popen constructor. Example:: + + retcode = call(["ls", "-l"]) + + .. versionchanged:: 1.2a1 + The ``timeout`` keyword argument is now accepted on all supported + versions of Python (not just Python 3) and if it expires will raise a + :exc:`TimeoutExpired` exception (under Python 2 this is a subclass of :exc:`~.Timeout`). + """ + timeout = kwargs.pop('timeout', None) + with Popen(*popenargs, **kwargs) as p: + try: + return p.wait(timeout=timeout, _raise_exc=True) + except: + p.kill() + p.wait() + raise + +def check_call(*popenargs, **kwargs): + """ + check_call(args, *, stdin=None, stdout=None, stderr=None, shell=False, timeout=None) -> 0 + + Run command with arguments. Wait for command to complete. If + the exit code was zero then return, otherwise raise + :exc:`CalledProcessError`. The ``CalledProcessError`` object will have the + return code in the returncode attribute. + + The arguments are the same as for the Popen constructor. Example:: + + retcode = check_call(["ls", "-l"]) + """ + retcode = call(*popenargs, **kwargs) + if retcode: + cmd = kwargs.get("args") + if cmd is None: + cmd = popenargs[0] + raise CalledProcessError(retcode, cmd) + return 0 + +def check_output(*popenargs, **kwargs): + r""" + check_output(args, *, input=None, stdin=None, stderr=None, shell=False, universal_newlines=False, timeout=None) -> output + + Run command with arguments and return its output. + + If the exit code was non-zero it raises a :exc:`CalledProcessError`. The + ``CalledProcessError`` object will have the return code in the returncode + attribute and output in the output attribute. + + + The arguments are the same as for the Popen constructor. Example:: + + >>> check_output(["ls", "-1", "/dev/null"]) + '/dev/null\n' + + The ``stdout`` argument is not allowed as it is used internally. + + To capture standard error in the result, use ``stderr=STDOUT``:: + + >>> check_output(["/bin/sh", "-c", + ... "ls -l non_existent_file ; exit 0"], + ... stderr=STDOUT) + 'ls: non_existent_file: No such file or directory\n' + + There is an additional optional argument, "input", allowing you to + pass a string to the subprocess's stdin. If you use this argument + you may not also use the Popen constructor's "stdin" argument, as + it too will be used internally. Example:: + + >>> check_output(["sed", "-e", "s/foo/bar/"], + ... input=b"when in the course of fooman events\n") + 'when in the course of barman events\n' + + If ``universal_newlines=True`` is passed, the return value will be a + string rather than bytes. + + .. versionchanged:: 1.2a1 + The ``timeout`` keyword argument is now accepted on all supported + versions of Python (not just Python 3) and if it expires will raise a + :exc:`TimeoutExpired` exception (under Python 2 this is a subclass of :exc:`~.Timeout`). + .. versionchanged:: 1.2a1 + The ``input`` keyword argument is now accepted on all supported + versions of Python, not just Python 3 + """ + timeout = kwargs.pop('timeout', None) + if 'stdout' in kwargs: + raise ValueError('stdout argument not allowed, it will be overridden.') + if 'input' in kwargs: + if 'stdin' in kwargs: + raise ValueError('stdin and input arguments may not both be used.') + inputdata = kwargs['input'] + del kwargs['input'] + kwargs['stdin'] = PIPE + else: + inputdata = None + with Popen(*popenargs, stdout=PIPE, **kwargs) as process: + try: + output, unused_err = process.communicate(inputdata, timeout=timeout) + except TimeoutExpired: + process.kill() + output, unused_err = process.communicate() + raise TimeoutExpired(process.args, timeout, output=output) + except: + process.kill() + process.wait() + raise + retcode = process.poll() + if retcode: + raise CalledProcessError(retcode, process.args, output=output) + return output + +_PLATFORM_DEFAULT_CLOSE_FDS = object() + +if 'TimeoutExpired' not in globals(): + # Python 2 + + # Make TimeoutExpired inherit from _Timeout so it can be caught + # the way we used to throw things (except Timeout), but make sure it doesn't + # init a timer. Note that we can't have a fake 'SubprocessError' that inherits + # from exception, because we need TimeoutExpired to just be a BaseException for + # bwc. + from gevent.timeout import Timeout as _Timeout + + class TimeoutExpired(_Timeout): + """ + This exception is raised when the timeout expires while waiting for + a child process in `communicate`. + + Under Python 2, this is a gevent extension with the same name as the + Python 3 class for source-code forward compatibility. However, it extends + :class:`gevent.timeout.Timeout` for backwards compatibility (because + we used to just raise a plain ``Timeout``); note that ``Timeout`` is a + ``BaseException``, *not* an ``Exception``. + + .. versionadded:: 1.2a1 + """ + def __init__(self, cmd, timeout, output=None): + _Timeout.__init__(self, timeout, _use_timer=False) + self.cmd = cmd + self.timeout = timeout + self.output = output + + def __str__(self): + return ("Command '%s' timed out after %s seconds" % + (self.cmd, self.timeout)) + + +class Popen(object): + """ + The underlying process creation and management in this module is + handled by the Popen class. It offers a lot of flexibility so that + developers are able to handle the less common cases not covered by + the convenience functions. + + .. seealso:: :class:`subprocess.Popen` + This class should have the same interface as the standard library class. + + .. versionchanged:: 1.2a1 + Instances can now be used as context managers under Python 2.7. Previously + this was restricted to Python 3. + + .. versionchanged:: 1.2a1 + Instances now save the ``args`` attribute under Python 2.7. Previously this was + restricted to Python 3. + """ + + def __init__(self, args, bufsize=None, executable=None, + stdin=None, stdout=None, stderr=None, + preexec_fn=None, close_fds=_PLATFORM_DEFAULT_CLOSE_FDS, shell=False, + cwd=None, env=None, universal_newlines=False, + startupinfo=None, creationflags=0, threadpool=None, + **kwargs): + """Create new Popen instance. + + :param kwargs: *Only* allowed under Python 3; under Python 2, any + unrecognized keyword arguments will result in a :exc:`TypeError`. + Under Python 3, keyword arguments can include ``pass_fds``, ``start_new_session``, + ``restore_signals``, ``encoding`` and ``errors`` + + .. versionchanged:: 1.2b1 + Add the ``encoding`` and ``errors`` parameters for Python 3. + """ + + if not PY3 and kwargs: + raise TypeError("Got unexpected keyword arguments", kwargs) + pass_fds = kwargs.pop('pass_fds', ()) + start_new_session = kwargs.pop('start_new_session', False) + restore_signals = kwargs.pop('restore_signals', True) + # Added in 3.6. These are kept as ivars + encoding = self.encoding = kwargs.pop('encoding', None) + errors = self.errors = kwargs.pop('errors', None) + + hub = get_hub() + + if bufsize is None: + # bufsize has different defaults on Py3 and Py2 + if PY3: + bufsize = -1 + else: + bufsize = 0 + if not isinstance(bufsize, integer_types): + raise TypeError("bufsize must be an integer") + + if mswindows: + if preexec_fn is not None: + raise ValueError("preexec_fn is not supported on Windows " + "platforms") + any_stdio_set = (stdin is not None or stdout is not None or + stderr is not None) + if close_fds is _PLATFORM_DEFAULT_CLOSE_FDS: + if any_stdio_set: + close_fds = False + else: + close_fds = True + elif close_fds and any_stdio_set: + raise ValueError("close_fds is not supported on Windows " + "platforms if you redirect stdin/stdout/stderr") + if threadpool is None: + threadpool = hub.threadpool + self.threadpool = threadpool + self._waiting = False + else: + # POSIX + if close_fds is _PLATFORM_DEFAULT_CLOSE_FDS: + # close_fds has different defaults on Py3/Py2 + if PY3: # pylint: disable=simplifiable-if-statement + close_fds = True + else: + close_fds = False + + if pass_fds and not close_fds: + import warnings + warnings.warn("pass_fds overriding close_fds.", RuntimeWarning) + close_fds = True + if startupinfo is not None: + raise ValueError("startupinfo is only supported on Windows " + "platforms") + if creationflags != 0: + raise ValueError("creationflags is only supported on Windows " + "platforms") + assert threadpool is None + self._loop = hub.loop + + self.args = args # Previously this was Py3 only. + self.stdin = None + self.stdout = None + self.stderr = None + self.pid = None + self.returncode = None + self.universal_newlines = universal_newlines + self.result = AsyncResult() + + # Input and output objects. The general principle is like + # this: + # + # Parent Child + # ------ ----- + # p2cwrite ---stdin---> p2cread + # c2pread <--stdout--- c2pwrite + # errread <--stderr--- errwrite + # + # On POSIX, the child objects are file descriptors. On + # Windows, these are Windows file handles. The parent objects + # are file descriptors on both platforms. The parent objects + # are None when not using PIPEs. The child objects are None + # when not redirecting. + + (p2cread, p2cwrite, + c2pread, c2pwrite, + errread, errwrite) = self._get_handles(stdin, stdout, stderr) + + # We wrap OS handles *before* launching the child, otherwise a + # quickly terminating child could make our fds unwrappable + # (see #8458). + if mswindows: + if p2cwrite is not None: + p2cwrite = msvcrt.open_osfhandle(p2cwrite.Detach(), 0) + if c2pread is not None: + c2pread = msvcrt.open_osfhandle(c2pread.Detach(), 0) + if errread is not None: + errread = msvcrt.open_osfhandle(errread.Detach(), 0) + + text_mode = PY3 and (self.encoding or self.errors or universal_newlines) + + if p2cwrite is not None: + if PY3 and text_mode: + # Under Python 3, if we left on the 'b' we'd get different results + # depending on whether we used FileObjectPosix or FileObjectThread + self.stdin = FileObject(p2cwrite, 'wb', bufsize) + self.stdin.translate_newlines(None, + write_through=True, + line_buffering=(bufsize == 1), + encoding=self.encoding, errors=self.errors) + else: + self.stdin = FileObject(p2cwrite, 'wb', bufsize) + if c2pread is not None: + if universal_newlines or text_mode: + if PY3: + # FileObjectThread doesn't support the 'U' qualifier + # with a bufsize of 0 + self.stdout = FileObject(c2pread, 'rb', bufsize) + # NOTE: Universal Newlines are broken on Windows/Py3, at least + # in some cases. This is true in the stdlib subprocess module + # as well; the following line would fix the test cases in + # test__subprocess.py that depend on python_universal_newlines, + # but would be inconsistent with the stdlib: + #msvcrt.setmode(self.stdout.fileno(), os.O_TEXT) + self.stdout.translate_newlines('r', encoding=self.encoding, errors=self.errors) + else: + self.stdout = FileObject(c2pread, 'rU', bufsize) + else: + self.stdout = FileObject(c2pread, 'rb', bufsize) + if errread is not None: + if universal_newlines or text_mode: + if PY3: + self.stderr = FileObject(errread, 'rb', bufsize) + self.stderr.translate_newlines(None, encoding=encoding, errors=errors) + else: + self.stderr = FileObject(errread, 'rU', bufsize) + else: + self.stderr = FileObject(errread, 'rb', bufsize) + + self._closed_child_pipe_fds = False + try: + self._execute_child(args, executable, preexec_fn, close_fds, + pass_fds, cwd, env, universal_newlines, + startupinfo, creationflags, shell, + p2cread, p2cwrite, + c2pread, c2pwrite, + errread, errwrite, + restore_signals, start_new_session) + except: + # Cleanup if the child failed starting. + # (gevent: New in python3, but reported as gevent bug in #347. + # Note that under Py2, any error raised below will replace the + # original error so we have to use reraise) + if not PY3: + exc_info = sys.exc_info() + for f in filter(None, (self.stdin, self.stdout, self.stderr)): + try: + f.close() + except (OSError, IOError): + pass # Ignore EBADF or other errors. + + if not self._closed_child_pipe_fds: + to_close = [] + if stdin == PIPE: + to_close.append(p2cread) + if stdout == PIPE: + to_close.append(c2pwrite) + if stderr == PIPE: + to_close.append(errwrite) + if hasattr(self, '_devnull'): + to_close.append(self._devnull) + for fd in to_close: + try: + os.close(fd) + except (OSError, IOError): + pass + if not PY3: + try: + reraise(*exc_info) + finally: + del exc_info + raise + + def __repr__(self): + return '<%s at 0x%x pid=%r returncode=%r>' % (self.__class__.__name__, id(self), self.pid, self.returncode) + + def _on_child(self, watcher): + watcher.stop() + status = watcher.rstatus + if os.WIFSIGNALED(status): + self.returncode = -os.WTERMSIG(status) + else: + self.returncode = os.WEXITSTATUS(status) + self.result.set(self.returncode) + + def _get_devnull(self): + if not hasattr(self, '_devnull'): + self._devnull = os.open(os.devnull, os.O_RDWR) + return self._devnull + + _stdout_buffer = None + _stderr_buffer = None + + def communicate(self, input=None, timeout=None): + """Interact with process: Send data to stdin. Read data from + stdout and stderr, until end-of-file is reached. Wait for + process to terminate. The optional input argument should be a + string to be sent to the child process, or None, if no data + should be sent to the child. + + communicate() returns a tuple (stdout, stderr). + + :keyword timeout: Under Python 2, this is a gevent extension; if + given and it expires, we will raise :exc:`TimeoutExpired`, which + extends :exc:`gevent.timeout.Timeout` (note that this only extends :exc:`BaseException`, + *not* :exc:`Exception`) + Under Python 3, this raises the standard :exc:`TimeoutExpired` exception. + + .. versionchanged:: 1.1a2 + Under Python 2, if the *timeout* elapses, raise the :exc:`gevent.timeout.Timeout` + exception. Previously, we silently returned. + .. versionchanged:: 1.1b5 + Honor a *timeout* even if there's no way to communicate with the child + (stdin, stdout, and stderr are not pipes). + """ + greenlets = [] + if self.stdin: + greenlets.append(spawn(write_and_close, self.stdin, input)) + + # If the timeout parameter is used, and the caller calls back after + # getting a TimeoutExpired exception, we can wind up with multiple + # greenlets trying to run and read from and close stdout/stderr. + # That's bad because it can lead to 'RuntimeError: reentrant call in io.BufferedReader'. + # We can't just kill the previous greenlets when a timeout happens, + # though, because we risk losing the output collected by that greenlet + # (and Python 3, where timeout is an official parameter, explicitly says + # that no output should be lost in the event of a timeout.) Instead, we're + # watching for the exception and ignoring it. It's not elegant, + # but it works + if self.stdout: + def _read_out(): + try: + data = self.stdout.read() + except RuntimeError: + return + if self._stdout_buffer is not None: + self._stdout_buffer += data + else: + self._stdout_buffer = data + stdout = spawn(_read_out) + greenlets.append(stdout) + else: + stdout = None + + if self.stderr: + def _read_err(): + try: + data = self.stderr.read() + except RuntimeError: + return + if self._stderr_buffer is not None: + self._stderr_buffer += data + else: + self._stderr_buffer = data + stderr = spawn(_read_err) + greenlets.append(stderr) + else: + stderr = None + + # If we were given stdin=stdout=stderr=None, we have no way to + # communicate with the child, and thus no greenlets to wait + # on. This is a nonsense case, but it comes up in the test + # case for Python 3.5 (test_subprocess.py + # RunFuncTestCase.test_timeout). Instead, we go directly to + # self.wait + if not greenlets and timeout is not None: + self.wait(timeout=timeout, _raise_exc=True) + + done = joinall(greenlets, timeout=timeout) + if timeout is not None and len(done) != len(greenlets): + raise TimeoutExpired(self.args, timeout) + + if self.stdout: + try: + self.stdout.close() + except RuntimeError: + pass + if self.stderr: + try: + self.stderr.close() + except RuntimeError: + pass + self.wait() + stdout_value = self._stdout_buffer + self._stdout_buffer = None + stderr_value = self._stderr_buffer + self._stderr_buffer = None + # XXX: Under python 3 in universal newlines mode we should be + # returning str, not bytes + return (None if stdout is None else stdout_value or b'', + None if stderr is None else stderr_value or b'') + + def poll(self): + """Check if child process has terminated. Set and return :attr:`returncode` attribute.""" + return self._internal_poll() + + def __enter__(self): + return self + + def __exit__(self, t, v, tb): + if self.stdout: + self.stdout.close() + if self.stderr: + self.stderr.close() + try: # Flushing a BufferedWriter may raise an error + if self.stdin: + self.stdin.close() + finally: + # Wait for the process to terminate, to avoid zombies. + # JAM: gevent: If the process never terminates, this + # blocks forever. + self.wait() + + def _gevent_result_wait(self, timeout=None, raise_exc=PY3): + result = self.result.wait(timeout=timeout) + if raise_exc and timeout is not None and not self.result.ready(): + raise TimeoutExpired(self.args, timeout) + return result + + + if mswindows: + # + # Windows methods + # + def _get_handles(self, stdin, stdout, stderr): + """Construct and return tuple with IO objects: + p2cread, p2cwrite, c2pread, c2pwrite, errread, errwrite + """ + if stdin is None and stdout is None and stderr is None: + return (None, None, None, None, None, None) + + p2cread, p2cwrite = None, None + c2pread, c2pwrite = None, None + errread, errwrite = None, None + + try: + DEVNULL + except NameError: + _devnull = object() + else: + _devnull = DEVNULL + + if stdin is None: + p2cread = GetStdHandle(STD_INPUT_HANDLE) + if p2cread is None: + p2cread, _ = CreatePipe(None, 0) + if PY3: + p2cread = Handle(p2cread) + _winapi.CloseHandle(_) + elif stdin == PIPE: + p2cread, p2cwrite = CreatePipe(None, 0) + if PY3: + p2cread, p2cwrite = Handle(p2cread), Handle(p2cwrite) + elif stdin == _devnull: + p2cread = msvcrt.get_osfhandle(self._get_devnull()) + elif isinstance(stdin, int): + p2cread = msvcrt.get_osfhandle(stdin) + else: + # Assuming file-like object + p2cread = msvcrt.get_osfhandle(stdin.fileno()) + p2cread = self._make_inheritable(p2cread) + + if stdout is None: + c2pwrite = GetStdHandle(STD_OUTPUT_HANDLE) + if c2pwrite is None: + _, c2pwrite = CreatePipe(None, 0) + if PY3: + c2pwrite = Handle(c2pwrite) + _winapi.CloseHandle(_) + elif stdout == PIPE: + c2pread, c2pwrite = CreatePipe(None, 0) + if PY3: + c2pread, c2pwrite = Handle(c2pread), Handle(c2pwrite) + elif stdout == _devnull: + c2pwrite = msvcrt.get_osfhandle(self._get_devnull()) + elif isinstance(stdout, int): + c2pwrite = msvcrt.get_osfhandle(stdout) + else: + # Assuming file-like object + c2pwrite = msvcrt.get_osfhandle(stdout.fileno()) + c2pwrite = self._make_inheritable(c2pwrite) + + if stderr is None: + errwrite = GetStdHandle(STD_ERROR_HANDLE) + if errwrite is None: + _, errwrite = CreatePipe(None, 0) + if PY3: + errwrite = Handle(errwrite) + _winapi.CloseHandle(_) + elif stderr == PIPE: + errread, errwrite = CreatePipe(None, 0) + if PY3: + errread, errwrite = Handle(errread), Handle(errwrite) + elif stderr == STDOUT: + errwrite = c2pwrite + elif stderr == _devnull: + errwrite = msvcrt.get_osfhandle(self._get_devnull()) + elif isinstance(stderr, int): + errwrite = msvcrt.get_osfhandle(stderr) + else: + # Assuming file-like object + errwrite = msvcrt.get_osfhandle(stderr.fileno()) + errwrite = self._make_inheritable(errwrite) + + return (p2cread, p2cwrite, + c2pread, c2pwrite, + errread, errwrite) + + def _make_inheritable(self, handle): + """Return a duplicate of handle, which is inheritable""" + return DuplicateHandle(GetCurrentProcess(), + handle, GetCurrentProcess(), 0, 1, + DUPLICATE_SAME_ACCESS) + + def _find_w9xpopen(self): + """Find and return absolute path to w9xpopen.exe""" + w9xpopen = os.path.join(os.path.dirname(GetModuleFileName(0)), + "w9xpopen.exe") + if not os.path.exists(w9xpopen): + # Eeek - file-not-found - possibly an embedding + # situation - see if we can locate it in sys.exec_prefix + w9xpopen = os.path.join(os.path.dirname(sys.exec_prefix), + "w9xpopen.exe") + if not os.path.exists(w9xpopen): + raise RuntimeError("Cannot locate w9xpopen.exe, which is " + "needed for Popen to work with your " + "shell or platform.") + return w9xpopen + + def _execute_child(self, args, executable, preexec_fn, close_fds, + pass_fds, cwd, env, universal_newlines, + startupinfo, creationflags, shell, + p2cread, p2cwrite, + c2pread, c2pwrite, + errread, errwrite, + unused_restore_signals, unused_start_new_session): + """Execute program (MS Windows version)""" + + assert not pass_fds, "pass_fds not supported on Windows." + + if not isinstance(args, string_types): + args = list2cmdline(args) + + # Process startup details + if startupinfo is None: + startupinfo = STARTUPINFO() + if None not in (p2cread, c2pwrite, errwrite): + startupinfo.dwFlags |= STARTF_USESTDHANDLES + startupinfo.hStdInput = p2cread + startupinfo.hStdOutput = c2pwrite + startupinfo.hStdError = errwrite + + if shell: + startupinfo.dwFlags |= STARTF_USESHOWWINDOW + startupinfo.wShowWindow = SW_HIDE + comspec = os.environ.get("COMSPEC", "cmd.exe") + args = '{} /c "{}"'.format(comspec, args) + if GetVersion() >= 0x80000000 or os.path.basename(comspec).lower() == "command.com": + # Win9x, or using command.com on NT. We need to + # use the w9xpopen intermediate program. For more + # information, see KB Q150956 + # (http://web.archive.org/web/20011105084002/http://support.microsoft.com/support/kb/articles/Q150/9/56.asp) + w9xpopen = self._find_w9xpopen() + args = '"%s" %s' % (w9xpopen, args) + # Not passing CREATE_NEW_CONSOLE has been known to + # cause random failures on win9x. Specifically a + # dialog: "Your program accessed mem currently in + # use at xxx" and a hopeful warning about the + # stability of your system. Cost is Ctrl+C wont + # kill children. + creationflags |= CREATE_NEW_CONSOLE + + # Start the process + try: + hp, ht, pid, tid = CreateProcess(executable, args, + # no special security + None, None, + int(not close_fds), + creationflags, + env, + cwd, + startupinfo) + except IOError as e: # From 2.6 on, pywintypes.error was defined as IOError + # Translate pywintypes.error to WindowsError, which is + # a subclass of OSError. FIXME: We should really + # translate errno using _sys_errlist (or similar), but + # how can this be done from Python? + if PY3: + raise # don't remap here + raise WindowsError(*e.args) + finally: + # Child is launched. Close the parent's copy of those pipe + # handles that only the child should have open. You need + # to make sure that no handles to the write end of the + # output pipe are maintained in this process or else the + # pipe will not close when the child process exits and the + # ReadFile will hang. + def _close(x): + if x is not None and x != -1: + if hasattr(x, 'Close'): + x.Close() + else: + _winapi.CloseHandle(x) + + _close(p2cread) + _close(c2pwrite) + _close(errwrite) + if hasattr(self, '_devnull'): + os.close(self._devnull) + + # Retain the process handle, but close the thread handle + self._child_created = True + self._handle = Handle(hp) if not hasattr(hp, 'Close') else hp + self.pid = pid + _winapi.CloseHandle(ht) if not hasattr(ht, 'Close') else ht.Close() + + def _internal_poll(self): + """Check if child process has terminated. Returns returncode + attribute. + """ + if self.returncode is None: + if WaitForSingleObject(self._handle, 0) == WAIT_OBJECT_0: + self.returncode = GetExitCodeProcess(self._handle) + self.result.set(self.returncode) + return self.returncode + + def rawlink(self, callback): + if not self.result.ready() and not self._waiting: + self._waiting = True + Greenlet.spawn(self._wait) + self.result.rawlink(linkproxy(callback, self)) + # XXX unlink + + def _blocking_wait(self): + WaitForSingleObject(self._handle, INFINITE) + self.returncode = GetExitCodeProcess(self._handle) + return self.returncode + + def _wait(self): + self.threadpool.spawn(self._blocking_wait).rawlink(self.result) + + def wait(self, timeout=None, _raise_exc=PY3): + """Wait for child process to terminate. Returns returncode + attribute.""" + if self.returncode is None: + if not self._waiting: + self._waiting = True + self._wait() + return self._gevent_result_wait(timeout, _raise_exc) + + def send_signal(self, sig): + """Send a signal to the process + """ + if sig == signal.SIGTERM: + self.terminate() + elif sig == signal.CTRL_C_EVENT: + os.kill(self.pid, signal.CTRL_C_EVENT) + elif sig == signal.CTRL_BREAK_EVENT: + os.kill(self.pid, signal.CTRL_BREAK_EVENT) + else: + raise ValueError("Unsupported signal: {}".format(sig)) + + def terminate(self): + """Terminates the process + """ + TerminateProcess(self._handle, 1) + + kill = terminate + + else: + # + # POSIX methods + # + + def rawlink(self, callback): + # Not public documented, part of the link protocol + self.result.rawlink(linkproxy(callback, self)) + # XXX unlink + + def _get_handles(self, stdin, stdout, stderr): + """Construct and return tuple with IO objects: + p2cread, p2cwrite, c2pread, c2pwrite, errread, errwrite + """ + p2cread, p2cwrite = None, None + c2pread, c2pwrite = None, None + errread, errwrite = None, None + + try: + DEVNULL + except NameError: + _devnull = object() + else: + _devnull = DEVNULL + + if stdin is None: + pass + elif stdin == PIPE: + p2cread, p2cwrite = self.pipe_cloexec() + elif stdin == _devnull: + p2cread = self._get_devnull() + elif isinstance(stdin, int): + p2cread = stdin + else: + # Assuming file-like object + p2cread = stdin.fileno() + + if stdout is None: + pass + elif stdout == PIPE: + c2pread, c2pwrite = self.pipe_cloexec() + elif stdout == _devnull: + c2pwrite = self._get_devnull() + elif isinstance(stdout, int): + c2pwrite = stdout + else: + # Assuming file-like object + c2pwrite = stdout.fileno() + + if stderr is None: + pass + elif stderr == PIPE: + errread, errwrite = self.pipe_cloexec() + elif stderr == STDOUT: + errwrite = c2pwrite + elif stderr == _devnull: + errwrite = self._get_devnull() + elif isinstance(stderr, int): + errwrite = stderr + else: + # Assuming file-like object + errwrite = stderr.fileno() + + return (p2cread, p2cwrite, + c2pread, c2pwrite, + errread, errwrite) + + def _set_cloexec_flag(self, fd, cloexec=True): + try: + cloexec_flag = fcntl.FD_CLOEXEC + except AttributeError: + cloexec_flag = 1 + + old = fcntl.fcntl(fd, fcntl.F_GETFD) + if cloexec: + fcntl.fcntl(fd, fcntl.F_SETFD, old | cloexec_flag) + else: + fcntl.fcntl(fd, fcntl.F_SETFD, old & ~cloexec_flag) + + def _remove_nonblock_flag(self, fd): + flags = fcntl.fcntl(fd, fcntl.F_GETFL) & (~os.O_NONBLOCK) + fcntl.fcntl(fd, fcntl.F_SETFL, flags) + + def pipe_cloexec(self): + """Create a pipe with FDs set CLOEXEC.""" + # Pipes' FDs are set CLOEXEC by default because we don't want them + # to be inherited by other subprocesses: the CLOEXEC flag is removed + # from the child's FDs by _dup2(), between fork() and exec(). + # This is not atomic: we would need the pipe2() syscall for that. + r, w = os.pipe() + self._set_cloexec_flag(r) + self._set_cloexec_flag(w) + return r, w + + def _close_fds(self, keep): + # `keep` is a set of fds, so we + # use os.closerange from 3 to min(keep) + # and then from max(keep + 1) to MAXFD and + # loop through filling in the gaps. + # Under new python versions, we need to explicitly set + # passed fds to be inheritable or they will go away on exec + if hasattr(os, 'set_inheritable'): + set_inheritable = os.set_inheritable + else: + set_inheritable = lambda i, v: True + if hasattr(os, 'closerange'): + keep = sorted(keep) + min_keep = min(keep) + max_keep = max(keep) + os.closerange(3, min_keep) + os.closerange(max_keep + 1, MAXFD) + for i in xrange(min_keep, max_keep): + if i in keep: + set_inheritable(i, True) + continue + + try: + os.close(i) + except: + pass + else: + for i in xrange(3, MAXFD): + if i in keep: + set_inheritable(i, True) + continue + try: + os.close(i) + except: + pass + + def _execute_child(self, args, executable, preexec_fn, close_fds, + pass_fds, cwd, env, universal_newlines, + startupinfo, creationflags, shell, + p2cread, p2cwrite, + c2pread, c2pwrite, + errread, errwrite, + restore_signals, start_new_session): + """Execute program (POSIX version)""" + + if PY3 and isinstance(args, (str, bytes)): + args = [args] + elif not PY3 and isinstance(args, string_types): + args = [args] + else: + args = list(args) + + if shell: + args = ["/bin/sh", "-c"] + args + if executable: + args[0] = executable + + if executable is None: + executable = args[0] + + self._loop.install_sigchld() + + # For transferring possible exec failure from child to parent + # The first char specifies the exception type: 0 means + # OSError, 1 means some other error. + errpipe_read, errpipe_write = self.pipe_cloexec() + # errpipe_write must not be in the standard io 0, 1, or 2 fd range. + low_fds_to_close = [] + while errpipe_write < 3: + low_fds_to_close.append(errpipe_write) + errpipe_write = os.dup(errpipe_write) + for low_fd in low_fds_to_close: + os.close(low_fd) + try: + try: + gc_was_enabled = gc.isenabled() + # Disable gc to avoid bug where gc -> file_dealloc -> + # write to stderr -> hang. http://bugs.python.org/issue1336 + gc.disable() + try: + self.pid = fork_and_watch(self._on_child, self._loop, True, fork) + except: + if gc_was_enabled: + gc.enable() + raise + if self.pid == 0: + # Child + try: + # Close parent's pipe ends + if p2cwrite is not None: + os.close(p2cwrite) + if c2pread is not None: + os.close(c2pread) + if errread is not None: + os.close(errread) + os.close(errpipe_read) + + # When duping fds, if there arises a situation + # where one of the fds is either 0, 1 or 2, it + # is possible that it is overwritten (#12607). + if c2pwrite == 0: + c2pwrite = os.dup(c2pwrite) + if errwrite == 0 or errwrite == 1: + errwrite = os.dup(errwrite) + + # Dup fds for child + def _dup2(a, b): + # dup2() removes the CLOEXEC flag but + # we must do it ourselves if dup2() + # would be a no-op (issue #10806). + if a == b: + self._set_cloexec_flag(a, False) + elif a is not None: + os.dup2(a, b) + self._remove_nonblock_flag(b) + _dup2(p2cread, 0) + _dup2(c2pwrite, 1) + _dup2(errwrite, 2) + + # Close pipe fds. Make sure we don't close the + # same fd more than once, or standard fds. + closed = set([None]) + for fd in [p2cread, c2pwrite, errwrite]: + if fd not in closed and fd > 2: + os.close(fd) + closed.add(fd) + + if cwd is not None: + os.chdir(cwd) + + if preexec_fn: + preexec_fn() + + # Close all other fds, if asked for. This must be done + # after preexec_fn runs. + if close_fds: + fds_to_keep = set(pass_fds) + fds_to_keep.add(errpipe_write) + self._close_fds(fds_to_keep) + elif hasattr(os, 'get_inheritable'): + # close_fds was false, and we're on + # Python 3.4 or newer, so "all file + # descriptors except standard streams + # are closed, and inheritable handles + # are only inherited if the close_fds + # parameter is False." + for i in xrange(3, MAXFD): + try: + if i == errpipe_write or os.get_inheritable(i): + continue + os.close(i) + except: + pass + + if restore_signals: + # restore the documented signals back to sig_dfl; + # not all will be defined on every platform + for sig in 'SIGPIPE', 'SIGXFZ', 'SIGXFSZ': + sig = getattr(signal, sig, None) + if sig is not None: + signal.signal(sig, signal.SIG_DFL) + + if start_new_session: + os.setsid() + + if env is None: + os.execvp(executable, args) + else: + if PY3: + # Python 3.6 started testing for + # bytes values in the env; it also + # started encoding strs using + # fsencode and using a lower-level + # API that takes a list of keys + # and values. We don't have access + # to that API, so we go the reverse direction. + env = {os.fsdecode(k) if isinstance(k, bytes) else k: + os.fsdecode(v) if isinstance(v, bytes) else v + for k, v in env.items()} + os.execvpe(executable, args, env) + + except: + exc_type, exc_value, tb = sys.exc_info() + # Save the traceback and attach it to the exception object + exc_lines = traceback.format_exception(exc_type, + exc_value, + tb) + exc_value.child_traceback = ''.join(exc_lines) + os.write(errpipe_write, pickle.dumps(exc_value)) + + finally: + # Make sure that the process exits no matter what. + # The return code does not matter much as it won't be + # reported to the application + os._exit(1) + + # Parent + self._child_created = True + if gc_was_enabled: + gc.enable() + finally: + # be sure the FD is closed no matter what + os.close(errpipe_write) + + # self._devnull is not always defined. + devnull_fd = getattr(self, '_devnull', None) + if p2cread is not None and p2cwrite is not None and p2cread != devnull_fd: + os.close(p2cread) + if c2pwrite is not None and c2pread is not None and c2pwrite != devnull_fd: + os.close(c2pwrite) + if errwrite is not None and errread is not None and errwrite != devnull_fd: + os.close(errwrite) + if devnull_fd is not None: + os.close(devnull_fd) + # Prevent a double close of these fds from __init__ on error. + self._closed_child_pipe_fds = True + + # Wait for exec to fail or succeed; possibly raising exception + errpipe_read = FileObject(errpipe_read, 'rb') + data = errpipe_read.read() + finally: + if hasattr(errpipe_read, 'close'): + errpipe_read.close() + else: + os.close(errpipe_read) + + if data != b"": + self.wait() + child_exception = pickle.loads(data) + for fd in (p2cwrite, c2pread, errread): + if fd is not None: + os.close(fd) + raise child_exception + + def _handle_exitstatus(self, sts): + if os.WIFSIGNALED(sts): + self.returncode = -os.WTERMSIG(sts) + elif os.WIFEXITED(sts): + self.returncode = os.WEXITSTATUS(sts) + else: + # Should never happen + raise RuntimeError("Unknown child exit status!") + + def _internal_poll(self): + """Check if child process has terminated. Returns returncode + attribute. + """ + if self.returncode is None: + if get_hub() is not getcurrent(): + sig_pending = getattr(self._loop, 'sig_pending', True) + if sig_pending: + sleep(0.00001) + return self.returncode + + def wait(self, timeout=None, _raise_exc=PY3): + """ + Wait for child process to terminate. Returns :attr:`returncode` + attribute. + + :keyword timeout: The floating point number of seconds to + wait. Under Python 2, this is a gevent extension, and + we simply return if it expires. Under Python 3, if + this time elapses without finishing the process, + :exc:`TimeoutExpired` is raised. + """ + return self._gevent_result_wait(timeout, _raise_exc) + + def send_signal(self, sig): + """Send a signal to the process + """ + # Skip signalling a process that we know has already died. + if self.returncode is None: + os.kill(self.pid, sig) + + def terminate(self): + """Terminate the process with SIGTERM + """ + self.send_signal(signal.SIGTERM) + + def kill(self): + """Kill the process with SIGKILL + """ + self.send_signal(signal.SIGKILL) + + +def write_and_close(fobj, data): + try: + if data: + fobj.write(data) + if hasattr(fobj, 'flush'): + # 3.6 started expecting flush to be called. + fobj.flush() + except (OSError, IOError) as ex: + if ex.errno != errno.EPIPE and ex.errno != errno.EINVAL: + raise + finally: + try: + fobj.close() + except EnvironmentError: + pass + +def _with_stdout_stderr(exc, stderr): + # Prior to Python 3.5, most exceptions didn't have stdout + # and stderr attributes and can't take the stderr attribute in their + # constructor + exc.stdout = exc.output + exc.stderr = stderr + return exc + +class CompletedProcess(object): + """ + A process that has finished running. + + This is returned by run(). + + Attributes: + - args: The list or str args passed to run(). + - returncode: The exit code of the process, negative for signals. + - stdout: The standard output (None if not captured). + - stderr: The standard error (None if not captured). + + .. versionadded:: 1.2a1 + This first appeared in Python 3.5 and is available to all + Python versions in gevent. + """ + def __init__(self, args, returncode, stdout=None, stderr=None): + self.args = args + self.returncode = returncode + self.stdout = stdout + self.stderr = stderr + + def __repr__(self): + args = ['args={!r}'.format(self.args), + 'returncode={!r}'.format(self.returncode)] + if self.stdout is not None: + args.append('stdout={!r}'.format(self.stdout)) + if self.stderr is not None: + args.append('stderr={!r}'.format(self.stderr)) + return "{}({})".format(type(self).__name__, ', '.join(args)) + + def check_returncode(self): + """Raise CalledProcessError if the exit code is non-zero.""" + if self.returncode: + raise _with_stdout_stderr(CalledProcessError(self.returncode, self.args, self.stdout), self.stderr) + + +def run(*popenargs, **kwargs): + """ + run(args, *, stdin=None, input=None, stdout=None, stderr=None, shell=False, timeout=None, check=False) -> CompletedProcess + + Run command with arguments and return a CompletedProcess instance. + + The returned instance will have attributes args, returncode, stdout and + stderr. By default, stdout and stderr are not captured, and those attributes + will be None. Pass stdout=PIPE and/or stderr=PIPE in order to capture them. + If check is True and the exit code was non-zero, it raises a + CalledProcessError. The CalledProcessError object will have the return code + in the returncode attribute, and output & stderr attributes if those streams + were captured. + + If timeout is given, and the process takes too long, a TimeoutExpired + exception will be raised. + + There is an optional argument "input", allowing you to + pass a string to the subprocess's stdin. If you use this argument + you may not also use the Popen constructor's "stdin" argument, as + it will be used internally. + The other arguments are the same as for the Popen constructor. + If universal_newlines=True is passed, the "input" argument must be a + string and stdout/stderr in the returned object will be strings rather than + bytes. + + .. versionadded:: 1.2a1 + This function first appeared in Python 3.5. It is available on all Python + versions gevent supports. + """ + input = kwargs.pop('input', None) + timeout = kwargs.pop('timeout', None) + check = kwargs.pop('check', False) + + if input is not None: + if 'stdin' in kwargs: + raise ValueError('stdin and input arguments may not both be used.') + kwargs['stdin'] = PIPE + + with Popen(*popenargs, **kwargs) as process: + try: + stdout, stderr = process.communicate(input, timeout=timeout) + except TimeoutExpired: + process.kill() + stdout, stderr = process.communicate() + raise _with_stdout_stderr(TimeoutExpired(process.args, timeout, output=stdout), stderr) + except: + process.kill() + process.wait() + raise + retcode = process.poll() + if check and retcode: + raise _with_stdout_stderr(CalledProcessError(retcode, process.args, stdout), stderr) + + return CompletedProcess(process.args, retcode, stdout, stderr) diff --git a/python/gevent/thread.py b/python/gevent/thread.py new file mode 100644 index 0000000..0a1af38 --- /dev/null +++ b/python/gevent/thread.py @@ -0,0 +1,115 @@ +""" +Implementation of the standard :mod:`thread` module that spawns greenlets. + +.. note:: + + This module is a helper for :mod:`gevent.monkey` and is not + intended to be used directly. For spawning greenlets in your + applications, prefer higher level constructs like + :class:`gevent.Greenlet` class or :func:`gevent.spawn`. +""" +from __future__ import absolute_import +import sys + +__implements__ = ['allocate_lock', + 'get_ident', + 'exit', + 'LockType', + 'stack_size', + 'start_new_thread', + '_local'] + +__imports__ = ['error'] +if sys.version_info[0] <= 2: + import thread as __thread__ # pylint:disable=import-error +else: + import _thread as __thread__ # pylint:disable=import-error + __target__ = '_thread' + __imports__ += ['RLock', + 'TIMEOUT_MAX', + 'allocate', + 'exit_thread', + 'interrupt_main', + 'start_new'] +error = __thread__.error +from gevent._compat import PY3 +from gevent._compat import PYPY +from gevent._util import copy_globals +from gevent.hub import getcurrent, GreenletExit +from gevent.greenlet import Greenlet +from gevent.lock import BoundedSemaphore +from gevent.local import local as _local + + +def get_ident(gr=None): + if gr is None: + gr = getcurrent() + return id(gr) + + +def start_new_thread(function, args=(), kwargs=None): + if kwargs is not None: + greenlet = Greenlet.spawn(function, *args, **kwargs) + else: + greenlet = Greenlet.spawn(function, *args) + return get_ident(greenlet) + + +class LockType(BoundedSemaphore): + # Change the ValueError into the appropriate thread error + # and any other API changes we need to make to match behaviour + _OVER_RELEASE_ERROR = __thread__.error + + if PYPY and PY3: + _OVER_RELEASE_ERROR = RuntimeError + + if PY3: + _TIMEOUT_MAX = __thread__.TIMEOUT_MAX # python 2: pylint:disable=no-member + + def acquire(self, blocking=True, timeout=-1): + # Transform the default -1 argument into the None that our + # semaphore implementation expects, and raise the same error + # the stdlib implementation does. + if timeout == -1: + timeout = None + if not blocking and timeout is not None: + raise ValueError("can't specify a timeout for a non-blocking call") + if timeout is not None: + if timeout < 0: + # in C: if(timeout < 0 && timeout != -1) + raise ValueError("timeout value must be strictly positive") + if timeout > self._TIMEOUT_MAX: + raise OverflowError('timeout value is too large') + + return BoundedSemaphore.acquire(self, blocking, timeout) + +allocate_lock = LockType + + +def exit(): + raise GreenletExit + + +if hasattr(__thread__, 'stack_size'): + _original_stack_size = __thread__.stack_size + + def stack_size(size=None): + if size is None: + return _original_stack_size() + if size > _original_stack_size(): + return _original_stack_size(size) + else: + pass + # not going to decrease stack_size, because otherwise other greenlets in this thread will suffer +else: + __implements__.remove('stack_size') + +__imports__ = copy_globals(__thread__, globals(), + only_names=__imports__, + ignore_missing_names=True) + +__all__ = __implements__ + __imports__ +__all__.remove('_local') + +# XXX interrupt_main +# XXX _count() diff --git a/python/gevent/threading.py b/python/gevent/threading.py new file mode 100644 index 0000000..5098aed --- /dev/null +++ b/python/gevent/threading.py @@ -0,0 +1,231 @@ +""" +Implementation of the standard :mod:`threading` using greenlets. + +.. note:: + + This module is a helper for :mod:`gevent.monkey` and is not + intended to be used directly. For spawning greenlets in your + applications, prefer higher level constructs like + :class:`gevent.Greenlet` class or :func:`gevent.spawn`. +""" +from __future__ import absolute_import + + +__implements__ = [ + 'local', + '_start_new_thread', + '_allocate_lock', + 'Lock', + '_get_ident', + '_sleep', + '_DummyThread', +] + + +import threading as __threading__ +_DummyThread_ = __threading__._DummyThread +from gevent.local import local +from gevent.thread import start_new_thread as _start_new_thread, allocate_lock as _allocate_lock, get_ident as _get_ident +from gevent._compat import PYPY +from gevent.hub import sleep as _sleep, getcurrent + +# Exports, prevent unused import warnings +local = local +start_new_thread = _start_new_thread +allocate_lock = _allocate_lock +_get_ident = _get_ident +_sleep = _sleep +getcurrent = getcurrent + +Lock = _allocate_lock + + +def _cleanup(g): + __threading__._active.pop(id(g), None) + +def _make_cleanup_id(gid): + def _(_r): + __threading__._active.pop(gid, None) + return _ + +_weakref = None + +class _DummyThread(_DummyThread_): + # We avoid calling the superclass constructor. This makes us about + # twice as fast (1.16 vs 0.68usec on PyPy, 29.3 vs 17.7usec on + # CPython 2.7), and has the important effect of avoiding + # allocation and then immediate deletion of _Thread__block, a + # lock. This is especially important on PyPy where locks go + # through the cpyext API and Cython, which is known to be slow and + # potentially buggy (e.g., + # https://bitbucket.org/pypy/pypy/issues/2149/memory-leak-for-python-subclass-of-cpyext#comment-22347393) + + # These objects are constructed quite frequently in some cases, so + # the optimization matters: for example, in gunicorn, which uses + # pywsgi.WSGIServer, every request is handled in a new greenlet, + # and every request uses a logging.Logger to write the access log, + # and every call to a log method captures the current thread (by + # default). + # + # (Obviously we have to duplicate the effects of the constructor, + # at least for external state purposes, which is potentially + # slightly fragile.) + + # For the same reason, instances of this class will cleanup their own entry + # in ``threading._active`` + + # Capture the static things as class vars to save on memory/ + # construction time. + # In Py2, they're all private; in Py3, they become protected + _Thread__stopped = _is_stopped = _stopped = False + _Thread__initialized = _initialized = True + _Thread__daemonic = _daemonic = True + _Thread__args = _args = () + _Thread__kwargs = _kwargs = None + _Thread__target = _target = None + _Thread_ident = _ident = None + _Thread__started = _started = __threading__.Event() + _Thread__started.set() + _tstate_lock = None + + def __init__(self): + #_DummyThread_.__init__(self) # pylint:disable=super-init-not-called + + # It'd be nice to use a pattern like "greenlet-%d", but maybe somebody out + # there is checking thread names... + self._name = self._Thread__name = __threading__._newname("DummyThread-%d") + self._set_ident() + + g = getcurrent() + gid = _get_ident(g) # same as id(g) + __threading__._active[gid] = self + rawlink = getattr(g, 'rawlink', None) + if rawlink is not None: + # raw greenlet.greenlet greenlets don't + # have rawlink... + rawlink(_cleanup) + else: + # ... so for them we use weakrefs. + # See https://github.com/gevent/gevent/issues/918 + global _weakref + if _weakref is None: + _weakref = __import__('weakref') + ref = _weakref.ref(g, _make_cleanup_id(gid)) + self.__raw_ref = ref + + def _Thread__stop(self): + pass + + _stop = _Thread__stop # py3 + + def _wait_for_tstate_lock(self, *args, **kwargs): + # pylint:disable=arguments-differ + pass + +if hasattr(__threading__, 'main_thread'): # py 3.4+ + def main_native_thread(): + return __threading__.main_thread() # pylint:disable=no-member +else: + _main_threads = [(_k, _v) for _k, _v in __threading__._active.items() + if isinstance(_v, __threading__._MainThread)] + assert len(_main_threads) == 1, "Too many main threads" + + def main_native_thread(): + return _main_threads[0][1] + +# Make sure the MainThread can be found by our current greenlet ID, +# otherwise we get a new DummyThread, which cannot be joined. +# Fixes tests in test_threading_2 under PyPy, and generally makes things nicer +# when gevent.threading is imported before monkey patching or not at all +# XXX: This assumes that the import is happening in the "main" greenlet/thread. +# XXX: We should really only be doing this from gevent.monkey. +if _get_ident() not in __threading__._active: + _v = main_native_thread() + _k = _v.ident + del __threading__._active[_k] + _v._ident = _v._Thread__ident = _get_ident() + __threading__._active[_get_ident()] = _v + del _k + del _v + + # Avoid printing an error on shutdown trying to remove the thread entry + # we just replaced if we're not fully monkey patched in + # XXX: This causes a hang on PyPy for some unknown reason (as soon as class _active + # defines __delitem__, shutdown hangs. Maybe due to something with the GC? + # XXX: This may be fixed in 2.6.1+ + if not PYPY: + # pylint:disable=no-member + _MAIN_THREAD = __threading__._get_ident() if hasattr(__threading__, '_get_ident') else __threading__.get_ident() + + class _active(dict): + def __delitem__(self, k): + if k == _MAIN_THREAD and k not in self: + return + dict.__delitem__(self, k) + + __threading__._active = _active(__threading__._active) + + +import sys +if sys.version_info[:2] >= (3, 4): + # XXX: Issue 18808 breaks us on Python 3.4. + # Thread objects now expect a callback from the interpreter itself + # (threadmodule.c:release_sentinel). Because this never happens + # when a greenlet exits, join() and friends will block forever. + # The solution below involves capturing the greenlet when it is + # started and deferring the known broken methods to it. + + class Thread(__threading__.Thread): + _greenlet = None + + def is_alive(self): + return bool(self._greenlet) + + isAlive = is_alive + + def _set_tstate_lock(self): + self._greenlet = getcurrent() + + def run(self): + try: + super(Thread, self).run() + finally: + # avoid ref cycles, but keep in __dict__ so we can + # distinguish the started/never-started case + self._greenlet = None + self._stop() # mark as finished + + def join(self, timeout=None): + if '_greenlet' not in self.__dict__: + raise RuntimeError("Cannot join an inactive thread") + if self._greenlet is None: + return + self._greenlet.join(timeout=timeout) + + def _wait_for_tstate_lock(self, *args, **kwargs): + # pylint:disable=arguments-differ + raise NotImplementedError() + + __implements__.append('Thread') + + # The main thread is patched up with more care in monkey.py + #t = __threading__.current_thread() + #if isinstance(t, __threading__.Thread): + # t.__class__ = Thread + # t._greenlet = getcurrent() + +if sys.version_info[:2] >= (3, 3): + __implements__.remove('_get_ident') + __implements__.append('get_ident') + get_ident = _get_ident + __implements__.remove('_sleep') + + # Python 3 changed the implementation of threading.RLock + # Previously it was a factory function around threading._RLock + # which in turn used _allocate_lock. Now, it wants to use + # threading._CRLock, which is imported from _thread.RLock and as such + # is implemented in C. So it bypasses our _allocate_lock function. + # Fortunately they left the Python fallback in place + assert hasattr(__threading__, '_CRLock'), "Unsupported Python version" + _CRLock = None + __implements__.append('_CRLock') diff --git a/python/gevent/threadpool.py b/python/gevent/threadpool.py new file mode 100644 index 0000000..1d0e98d --- /dev/null +++ b/python/gevent/threadpool.py @@ -0,0 +1,498 @@ +# Copyright (c) 2012 Denis Bilenko. See LICENSE for details. +from __future__ import absolute_import +import sys +import os +from gevent._compat import integer_types +from gevent.hub import get_hub, getcurrent, sleep, _get_hub +from gevent.event import AsyncResult +from gevent.greenlet import Greenlet +from gevent.pool import GroupMappingMixin +from gevent.lock import Semaphore +from gevent._threading import Lock, Queue, start_new_thread + + +__all__ = ['ThreadPool', + 'ThreadResult'] + + +class ThreadPool(GroupMappingMixin): + """ + .. note:: The method :meth:`apply_async` will always return a new + greenlet, bypassing the threadpool entirely. + """ + + def __init__(self, maxsize, hub=None): + if hub is None: + hub = get_hub() + self.hub = hub + self._maxsize = 0 + self.manager = None + self.pid = os.getpid() + self.fork_watcher = hub.loop.fork(ref=False) + self._init(maxsize) + + def _set_maxsize(self, maxsize): + if not isinstance(maxsize, integer_types): + raise TypeError('maxsize must be integer: %r' % (maxsize, )) + if maxsize < 0: + raise ValueError('maxsize must not be negative: %r' % (maxsize, )) + difference = maxsize - self._maxsize + self._semaphore.counter += difference + self._maxsize = maxsize + self.adjust() + # make sure all currently blocking spawn() start unlocking if maxsize increased + self._semaphore._start_notify() + + def _get_maxsize(self): + return self._maxsize + + maxsize = property(_get_maxsize, _set_maxsize) + + def __repr__(self): + return '<%s at 0x%x %s/%s/%s>' % (self.__class__.__name__, id(self), len(self), self.size, self.maxsize) + + def __len__(self): + # XXX just do unfinished_tasks property + return self.task_queue.unfinished_tasks + + def _get_size(self): + return self._size + + def _set_size(self, size): + if size < 0: + raise ValueError('Size of the pool cannot be negative: %r' % (size, )) + if size > self._maxsize: + raise ValueError('Size of the pool cannot be bigger than maxsize: %r > %r' % (size, self._maxsize)) + if self.manager: + self.manager.kill() + while self._size < size: + self._add_thread() + delay = 0.0001 + while self._size > size: + while self._size - size > self.task_queue.unfinished_tasks: + self.task_queue.put(None) + if getcurrent() is self.hub: + break + sleep(delay) + delay = min(delay * 2, .05) + if self._size: + self.fork_watcher.start(self._on_fork) + else: + self.fork_watcher.stop() + + size = property(_get_size, _set_size) + + def _init(self, maxsize): + self._size = 0 + self._semaphore = Semaphore(1) + self._lock = Lock() + self.task_queue = Queue() + self._set_maxsize(maxsize) + + def _on_fork(self): + # fork() only leaves one thread; also screws up locks; + # let's re-create locks and threads. + # NOTE: See comment in gevent.hub.reinit. + pid = os.getpid() + if pid != self.pid: + self.pid = pid + # Do not mix fork() and threads; since fork() only copies one thread + # all objects referenced by other threads has refcount that will never + # go down to 0. + self._init(self._maxsize) + + def join(self): + """Waits until all outstanding tasks have been completed.""" + delay = 0.0005 + while self.task_queue.unfinished_tasks > 0: + sleep(delay) + delay = min(delay * 2, .05) + + def kill(self): + self.size = 0 + + def _adjust_step(self): + # if there is a possibility & necessity for adding a thread, do it + while self._size < self._maxsize and self.task_queue.unfinished_tasks > self._size: + self._add_thread() + # while the number of threads is more than maxsize, kill one + # we do not check what's already in task_queue - it could be all Nones + while self._size - self._maxsize > self.task_queue.unfinished_tasks: + self.task_queue.put(None) + if self._size: + self.fork_watcher.start(self._on_fork) + else: + self.fork_watcher.stop() + + def _adjust_wait(self): + delay = 0.0001 + while True: + self._adjust_step() + if self._size <= self._maxsize: + return + sleep(delay) + delay = min(delay * 2, .05) + + def adjust(self): + self._adjust_step() + if not self.manager and self._size > self._maxsize: + # might need to feed more Nones into the pool + self.manager = Greenlet.spawn(self._adjust_wait) + + def _add_thread(self): + with self._lock: + self._size += 1 + try: + start_new_thread(self._worker, ()) + except: + with self._lock: + self._size -= 1 + raise + + def spawn(self, func, *args, **kwargs): + """ + Add a new task to the threadpool that will run ``func(*args, **kwargs)``. + + Waits until a slot is available. Creates a new thread if necessary. + + :return: A :class:`gevent.event.AsyncResult`. + """ + while True: + semaphore = self._semaphore + semaphore.acquire() + if semaphore is self._semaphore: + break + + thread_result = None + try: + task_queue = self.task_queue + result = AsyncResult() + # XXX We're calling the semaphore release function in the hub, otherwise + # we get LoopExit (why?). Previously it was done with a rawlink on the + # AsyncResult and the comment that it is "competing for order with get(); this is not + # good, just make ThreadResult release the semaphore before doing anything else" + thread_result = ThreadResult(result, hub=self.hub, call_when_ready=semaphore.release) + task_queue.put((func, args, kwargs, thread_result)) + self.adjust() + except: + if thread_result is not None: + thread_result.destroy() + semaphore.release() + raise + return result + + def _decrease_size(self): + if sys is None: + return + _lock = getattr(self, '_lock', None) + if _lock is not None: + with _lock: + self._size -= 1 + + _destroy_worker_hub = False + + def _worker(self): + # pylint:disable=too-many-branches + need_decrease = True + try: + while True: + task_queue = self.task_queue + task = task_queue.get() + try: + if task is None: + need_decrease = False + self._decrease_size() + # we want first to decrease size, then decrease unfinished_tasks + # otherwise, _adjust might think there's one more idle thread that + # needs to be killed + return + func, args, kwargs, thread_result = task + try: + value = func(*args, **kwargs) + except: # pylint:disable=bare-except + exc_info = getattr(sys, 'exc_info', None) + if exc_info is None: + return + thread_result.handle_error((self, func), exc_info()) + else: + if sys is None: + return + thread_result.set(value) + del value + finally: + del func, args, kwargs, thread_result, task + finally: + if sys is None: + return # pylint:disable=lost-exception + task_queue.task_done() + finally: + if need_decrease: + self._decrease_size() + if sys is not None and self._destroy_worker_hub: + hub = _get_hub() + if hub is not None: + hub.destroy(True) + del hub + + def apply_e(self, expected_errors, function, args=None, kwargs=None): + """ + .. deprecated:: 1.1a2 + Identical to :meth:`apply`; the ``expected_errors`` argument is ignored. + """ + # pylint:disable=unused-argument + # Deprecated but never documented. In the past, before + # self.apply() allowed all errors to be raised to the caller, + # expected_errors allowed a caller to specify a set of errors + # they wanted to be raised, through the wrap_errors function. + # In practice, it always took the value Exception or + # BaseException. + return self.apply(function, args, kwargs) + + def _apply_immediately(self): + # If we're being called from a different thread than the one that + # created us, e.g., because a worker task is trying to use apply() + # recursively, we have no choice but to run the task immediately; + # if we try to AsyncResult.get() in the worker thread, it's likely to have + # nothing to switch to and lead to a LoopExit. + return get_hub() is not self.hub + + def _apply_async_cb_spawn(self, callback, result): + callback(result) + + def _apply_async_use_greenlet(self): + # Always go to Greenlet because our self.spawn uses threads + return True + + +class ThreadResult(object): + + # Using slots here helps to debug reference cycles/leaks + __slots__ = ('exc_info', 'async', '_call_when_ready', 'value', + 'context', 'hub', 'receiver') + + def __init__(self, receiver, hub=None, call_when_ready=None): + if hub is None: + hub = get_hub() + self.receiver = receiver + self.hub = hub + self.context = None + self.value = None + self.exc_info = () + self.async = hub.loop.async() + self._call_when_ready = call_when_ready + self.async.start(self._on_async) + + @property + def exception(self): + return self.exc_info[1] if self.exc_info else None + + def _on_async(self): + self.async.stop() + if self._call_when_ready: + # Typically this is pool.semaphore.release and we have to + # call this in the Hub; if we don't we get the dreaded + # LoopExit (XXX: Why?) + self._call_when_ready() + try: + if self.exc_info: + self.hub.handle_error(self.context, *self.exc_info) + self.context = None + self.async = None + self.hub = None + self._call_when_ready = None + if self.receiver is not None: + self.receiver(self) + finally: + self.receiver = None + self.value = None + if self.exc_info: + self.exc_info = (self.exc_info[0], self.exc_info[1], None) + + def destroy(self): + if self.async is not None: + self.async.stop() + self.async = None + self.context = None + self.hub = None + self._call_when_ready = None + self.receiver = None + + def _ready(self): + if self.async is not None: + self.async.send() + + def set(self, value): + self.value = value + self._ready() + + def handle_error(self, context, exc_info): + self.context = context + self.exc_info = exc_info + self._ready() + + # link protocol: + def successful(self): + return self.exception is None + + +def wrap_errors(errors, function, args, kwargs): + """ + .. deprecated:: 1.1a2 + Previously used by ThreadPool.apply_e. + """ + try: + return True, function(*args, **kwargs) + except errors as ex: + return False, ex + +try: + import concurrent.futures +except ImportError: + pass +else: + __all__.append("ThreadPoolExecutor") + + from gevent.timeout import Timeout as GTimeout + from gevent._util import Lazy + from concurrent.futures import _base as cfb + + def _wrap_error(future, fn): + def cbwrap(_): + del _ + # we're called with the async result, but + # be sure to pass in ourself. Also automatically + # unlink ourself so that we don't get called multiple + # times. + try: + fn(future) + except Exception: # pylint: disable=broad-except + future.hub.print_exception((fn, future), *sys.exc_info()) + cbwrap.auto_unlink = True + return cbwrap + + def _wrap(future, fn): + def f(_): + fn(future) + f.auto_unlink = True + return f + + class _FutureProxy(object): + def __init__(self, asyncresult): + self.asyncresult = asyncresult + + # Internal implementation details of a c.f.Future + + @Lazy + def _condition(self): + from gevent import monkey + if monkey.is_module_patched('threading') or self.done(): + import threading + return threading.Condition() + # We can only properly work with conditions + # when we've been monkey-patched. This is necessary + # for the wait/as_completed module functions. + raise AttributeError("_condition") + + @Lazy + def _waiters(self): + self.asyncresult.rawlink(self.__when_done) + return [] + + def __when_done(self, _): + # We should only be called when _waiters has + # already been accessed. + waiters = getattr(self, '_waiters') + for w in waiters: # pylint:disable=not-an-iterable + if self.successful(): + w.add_result(self) + else: + w.add_exception(self) + + __when_done.auto_unlink = True + + @property + def _state(self): + if self.done(): + return cfb.FINISHED + return cfb.RUNNING + + def set_running_or_notify_cancel(self): + # Does nothing, not even any consistency checks. It's + # meant to be internal to the executor and we don't use it. + return + + def result(self, timeout=None): + try: + return self.asyncresult.result(timeout=timeout) + except GTimeout: + # XXX: Theoretically this could be a completely + # unrelated timeout instance. Do we care about that? + raise concurrent.futures.TimeoutError() + + def exception(self, timeout=None): + try: + self.asyncresult.get(timeout=timeout) + return self.asyncresult.exception + except GTimeout: + raise concurrent.futures.TimeoutError() + + def add_done_callback(self, fn): + if self.done(): + fn(self) + else: + self.asyncresult.rawlink(_wrap_error(self, fn)) + + def rawlink(self, fn): + self.asyncresult.rawlink(_wrap(self, fn)) + + def __str__(self): + return str(self.asyncresult) + + def __getattr__(self, name): + return getattr(self.asyncresult, name) + + class ThreadPoolExecutor(concurrent.futures.ThreadPoolExecutor): + """ + A version of :class:`concurrent.futures.ThreadPoolExecutor` that + always uses native threads, even when threading is monkey-patched. + + The ``Future`` objects returned from this object can be used + with gevent waiting primitives like :func:`gevent.wait`. + + .. caution:: If threading is *not* monkey-patched, then the ``Future`` + objects returned by this object are not guaranteed to work with + :func:`~concurrent.futures.as_completed` and :func:`~concurrent.futures.wait`. + The individual blocking methods like :meth:`~concurrent.futures.Future.result` + and :meth:`~concurrent.futures.Future.exception` will always work. + + .. versionadded:: 1.2a1 + This is a provisional API. + """ + + def __init__(self, max_workers): + super(ThreadPoolExecutor, self).__init__(max_workers) + self._threadpool = ThreadPool(max_workers) + self._threadpool._destroy_worker_hub = True + + def submit(self, fn, *args, **kwargs): + with self._shutdown_lock: # pylint:disable=not-context-manager + if self._shutdown: + raise RuntimeError('cannot schedule new futures after shutdown') + + future = self._threadpool.spawn(fn, *args, **kwargs) + return _FutureProxy(future) + + def shutdown(self, wait=True): + super(ThreadPoolExecutor, self).shutdown(wait) + # XXX: We don't implement wait properly + kill = getattr(self._threadpool, 'kill', None) + if kill: # pylint:disable=using-constant-test + self._threadpool.kill() + self._threadpool = None + + kill = shutdown # greentest compat + + def _adjust_thread_count(self): + # Does nothing. We don't want to spawn any "threads", + # let the threadpool handle that. + pass diff --git a/python/gevent/timeout.py b/python/gevent/timeout.py new file mode 100644 index 0000000..f08b81a --- /dev/null +++ b/python/gevent/timeout.py @@ -0,0 +1,261 @@ +# Copyright (c) 2009-2010 Denis Bilenko. See LICENSE for details. +""" +Timeouts. + +Many functions in :mod:`gevent` have a *timeout* argument that allows +limiting the time the function will block. When that is not available, +the :class:`Timeout` class and :func:`with_timeout` function in this +module add timeouts to arbitrary code. + +.. warning:: + + Timeouts can only work when the greenlet switches to the hub. + If a blocking function is called or an intense calculation is ongoing during + which no switches occur, :class:`Timeout` is powerless. +""" + +from gevent._compat import string_types +from gevent.hub import getcurrent, _NONE, get_hub + +__all__ = ['Timeout', + 'with_timeout'] + + +class _FakeTimer(object): + # An object that mimics the API of get_hub().loop.timer, but + # without allocating any native resources. This is useful for timeouts + # that will never expire. + # Also partially mimics the API of Timeout itself for use in _start_new_or_dummy + pending = False + active = False + + def start(self, *args, **kwargs): + # pylint:disable=unused-argument + raise AssertionError("non-expiring timer cannot be started") + + def stop(self): + return + + def cancel(self): + return + +_FakeTimer = _FakeTimer() + + +class Timeout(BaseException): + """ + Raise *exception* in the current greenlet after given time period:: + + timeout = Timeout(seconds, exception) + timeout.start() + try: + ... # exception will be raised here, after *seconds* passed since start() call + finally: + timeout.cancel() + + .. note:: If the code that the timeout was protecting finishes + executing before the timeout elapses, be sure to ``cancel`` the + timeout so it is not unexpectedly raised in the future. Even if + it is raised, it is a best practice to cancel it. This + ``try/finally`` construct or a ``with`` statement is a + recommended pattern. + + When *exception* is omitted or ``None``, the :class:`Timeout` instance itself is raised: + + >>> import gevent + >>> gevent.Timeout(0.1).start() + >>> gevent.sleep(0.2) #doctest: +IGNORE_EXCEPTION_DETAIL + Traceback (most recent call last): + ... + Timeout: 0.1 seconds + + To simplify starting and canceling timeouts, the ``with`` statement can be used:: + + with gevent.Timeout(seconds, exception) as timeout: + pass # ... code block ... + + This is equivalent to the try/finally block above with one additional feature: + if *exception* is the literal ``False``, the timeout is still raised, but the context manager + suppresses it, so the code outside the with-block won't see it. + + This is handy for adding a timeout to the functions that don't + support a *timeout* parameter themselves:: + + data = None + with gevent.Timeout(5, False): + data = mysock.makefile().readline() + if data is None: + ... # 5 seconds passed without reading a line + else: + ... # a line was read within 5 seconds + + .. caution:: If ``readline()`` above catches and doesn't re-raise :class:`BaseException` + (for example, with a bare ``except:``), then your timeout will fail to function and control + won't be returned to you when you expect. + + When catching timeouts, keep in mind that the one you catch may + not be the one you have set (a calling function may have set its + own timeout); if you going to silence a timeout, always check that + it's the instance you need:: + + timeout = Timeout(1) + timeout.start() + try: + ... + except Timeout as t: + if t is not timeout: + raise # not my timeout + + If the *seconds* argument is not given or is ``None`` (e.g., + ``Timeout()``), then the timeout will never expire and never raise + *exception*. This is convenient for creating functions which take + an optional timeout parameter of their own. (Note that this is not the same thing + as a *seconds* value of 0.) + + .. caution:: + A *seconds* value less than 0.0 (e.g., -1) is poorly defined. In the future, + support for negative values is likely to do the same thing as a value + if ``None``. + + .. versionchanged:: 1.1b2 + If *seconds* is not given or is ``None``, no longer allocate a libev + timer that will never be started. + .. versionchanged:: 1.1 + Add warning about negative *seconds* values. + """ + + def __init__(self, seconds=None, exception=None, ref=True, priority=-1, _use_timer=True): + BaseException.__init__(self) + self.seconds = seconds + self.exception = exception + if seconds is None or not _use_timer: + # Avoid going through the timer codepath if no timeout is + # desired; this avoids some CFFI interactions on PyPy that can lead to a + # RuntimeError if this implementation is used during an `import` statement. See + # https://bitbucket.org/pypy/pypy/issues/2089/crash-in-pypy-260-linux64-with-gevent-11b1 + # and https://github.com/gevent/gevent/issues/618. + # Plus, in general, it should be more efficient + self.timer = _FakeTimer + else: + self.timer = get_hub().loop.timer(seconds or 0.0, ref=ref, priority=priority) + + def start(self): + """Schedule the timeout.""" + assert not self.pending, '%r is already started; to restart it, cancel it first' % self + if self.seconds is None: # "fake" timeout (never expires) + return + + if self.exception is None or self.exception is False or isinstance(self.exception, string_types): + # timeout that raises self + self.timer.start(getcurrent().throw, self) + else: # regular timeout with user-provided exception + self.timer.start(getcurrent().throw, self.exception) + + @classmethod + def start_new(cls, timeout=None, exception=None, ref=True): + """Create a started :class:`Timeout`. + + This is a shortcut, the exact action depends on *timeout*'s type: + + * If *timeout* is a :class:`Timeout`, then call its :meth:`start` method + if it's not already begun. + * Otherwise, create a new :class:`Timeout` instance, passing (*timeout*, *exception*) as + arguments, then call its :meth:`start` method. + + Returns the :class:`Timeout` instance. + """ + if isinstance(timeout, Timeout): + if not timeout.pending: + timeout.start() + return timeout + timeout = cls(timeout, exception, ref=ref) + timeout.start() + return timeout + + @staticmethod + def _start_new_or_dummy(timeout, exception=None): + # Internal use only in 1.1 + # Return an object with a 'cancel' method; if timeout is None, + # this will be a shared instance object that does nothing. Otherwise, + # return an actual Timeout. Because negative values are hard to reason about, + # and are often used as sentinels in Python APIs, in the future it's likely + # that a negative timeout will also return the shared instance. + # This saves the previously common idiom of 'timer = Timeout.start_new(t) if t is not None else None' + # followed by 'if timer is not None: timer.cancel()'. + # That idiom was used to avoid any object allocations. + # A staticmethod is slightly faster under CPython, compared to a classmethod; + # under PyPy in synthetic benchmarks it makes no difference. + if timeout is None: + return _FakeTimer + return Timeout.start_new(timeout, exception) + + @property + def pending(self): + """Return True if the timeout is scheduled to be raised.""" + return self.timer.pending or self.timer.active + + def cancel(self): + """If the timeout is pending, cancel it. Otherwise, do nothing.""" + self.timer.stop() + + def __repr__(self): + classname = type(self).__name__ + if self.pending: + pending = ' pending' + else: + pending = '' + if self.exception is None: + exception = '' + else: + exception = ' exception=%r' % self.exception + return '<%s at %s seconds=%s%s%s>' % (classname, hex(id(self)), self.seconds, exception, pending) + + def __str__(self): + """ + >>> raise Timeout #doctest: +IGNORE_EXCEPTION_DETAIL + Traceback (most recent call last): + ... + Timeout + """ + if self.seconds is None: + return '' + + suffix = '' if self.seconds == 1 else 's' + + if self.exception is None: + return '%s second%s' % (self.seconds, suffix) + if self.exception is False: + return '%s second%s (silent)' % (self.seconds, suffix) + return '%s second%s: %s' % (self.seconds, suffix, self.exception) + + def __enter__(self): + if not self.pending: + self.start() + return self + + def __exit__(self, typ, value, tb): + self.cancel() + if value is self and self.exception is False: + return True + + +def with_timeout(seconds, function, *args, **kwds): + """Wrap a call to *function* with a timeout; if the called + function fails to return before the timeout, cancel it and return a + flag value, provided by *timeout_value* keyword argument. + + If timeout expires but *timeout_value* is not provided, raise :class:`Timeout`. + + Keyword argument *timeout_value* is not passed to *function*. + """ + timeout_value = kwds.pop("timeout_value", _NONE) + timeout = Timeout.start_new(seconds) + try: + try: + return function(*args, **kwds) + except Timeout as ex: + if ex is timeout and timeout_value is not _NONE: + return timeout_value + raise + finally: + timeout.cancel() diff --git a/python/gevent/util.py b/python/gevent/util.py new file mode 100644 index 0000000..1438688 --- /dev/null +++ b/python/gevent/util.py @@ -0,0 +1,60 @@ +# Copyright (c) 2009 Denis Bilenko. See LICENSE for details. +""" +Low-level utilities. +""" + +from __future__ import absolute_import + +import functools + +__all__ = ['wrap_errors'] + + +class wrap_errors(object): + """ + Helper to make function return an exception, rather than raise it. + + Because every exception that is unhandled by greenlet will be logged, + it is desirable to prevent non-error exceptions from leaving a greenlet. + This can done with a simple ``try/except`` construct:: + + def wrapped_func(*args, **kwargs): + try: + return func(*args, **kwargs) + except (TypeError, ValueError, AttributeError) as ex: + return ex + + This class provides a shortcut to write that in one line:: + + wrapped_func = wrap_errors((TypeError, ValueError, AttributeError), func) + + It also preserves ``__str__`` and ``__repr__`` of the original function. + """ + # QQQ could also support using wrap_errors as a decorator + + def __init__(self, errors, func): + """ + Calling this makes a new function from *func*, such that it catches *errors* (an + :exc:`BaseException` subclass, or a tuple of :exc:`BaseException` subclasses) and + return it as a value. + """ + self.__errors = errors + self.__func = func + # Set __doc__, __wrapped__, etc, especially useful on Python 3. + functools.update_wrapper(self, func) + + def __call__(self, *args, **kwargs): + func = self.__func + try: + return func(*args, **kwargs) + except self.__errors as ex: + return ex + + def __str__(self): + return str(self.__func) + + def __repr__(self): + return repr(self.__func) + + def __getattr__(self, name): + return getattr(self.__func, name) diff --git a/python/gevent/win32util.py b/python/gevent/win32util.py new file mode 100644 index 0000000..7158d69 --- /dev/null +++ b/python/gevent/win32util.py @@ -0,0 +1,98 @@ +# Copyright (c) 2001-2007 Twisted Matrix Laboratories. +# Permission is hereby granted, free of charge, to any person obtaining +# a copy of this software and associated documentation files (the +# "Software"), to deal in the Software without restriction, including +# without limitation the rights to use, copy, modify, merge, publish, +# distribute, sublicense, and/or sell copies of the Software, and to +# permit persons to whom the Software is furnished to do so, subject to +# the following conditions: +# +# The above copyright notice and this permission notice shall be +# included in all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +"""Error formatting function for Windows. + +The code is taken from twisted.python.win32 module. +""" + +from __future__ import absolute_import +import os + + +__all__ = ['formatError'] + + +class _ErrorFormatter(object): + """ + Formatter for Windows error messages. + + @ivar winError: A callable which takes one integer error number argument + and returns an L{exceptions.WindowsError} instance for that error (like + L{ctypes.WinError}). + + @ivar formatMessage: A callable which takes one integer error number + argument and returns a C{str} giving the message for that error (like + L{win32api.FormatMessage}). + + @ivar errorTab: A mapping from integer error numbers to C{str} messages + which correspond to those errors (like L{socket.errorTab}). + """ + def __init__(self, WinError, FormatMessage, errorTab): + self.winError = WinError + self.formatMessage = FormatMessage + self.errorTab = errorTab + + @classmethod + def fromEnvironment(cls): + """ + Get as many of the platform-specific error translation objects as + possible and return an instance of C{cls} created with them. + """ + try: + from ctypes import WinError + except ImportError: + WinError = None + try: + from win32api import FormatMessage + except ImportError: + FormatMessage = None + try: + from socket import errorTab + except ImportError: + errorTab = None + return cls(WinError, FormatMessage, errorTab) + + def formatError(self, errorcode): + """ + Returns the string associated with a Windows error message, such as the + ones found in socket.error. + + Attempts direct lookup against the win32 API via ctypes and then + pywin32 if available), then in the error table in the socket module, + then finally defaulting to C{os.strerror}. + + @param errorcode: the Windows error code + @type errorcode: C{int} + + @return: The error message string + @rtype: C{str} + """ + if self.winError is not None: + return str(self.winError(errorcode)) + if self.formatMessage is not None: + return self.formatMessage(errorcode) + if self.errorTab is not None: + result = self.errorTab.get(errorcode) + if result is not None: + return result + return os.strerror(errorcode) + +formatError = _ErrorFormatter.fromEnvironment().formatError diff --git a/python/gevent/wsgi.py b/python/gevent/wsgi.py new file mode 100644 index 0000000..503d67b --- /dev/null +++ b/python/gevent/wsgi.py @@ -0,0 +1,15 @@ +"""Backwards compatibility alias for :mod:`gevent.pywsgi`. + +In the past, this used libevent's http support, but that was dropped +with the introduction of libev. libevent's http support had several +limitations, including not supporting stream, not supporting +pipelining, and not supporting SSL. + +.. deprecated:: 1.1 + Use :mod:`gevent.pywsgi` +""" + +from gevent.pywsgi import * # pylint:disable=wildcard-import,unused-wildcard-import +import gevent.pywsgi as _pywsgi +__all__ = _pywsgi.__all__ +del _pywsgi diff --git a/python/python.exe b/python/python.exe new file mode 100644 index 0000000000000000000000000000000000000000..d99e5bcf5cd249e587cc36be13d69c01a2cf47be GIT binary patch literal 100504 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 literal 0 HcmV?d00001 diff --git a/python/python3.dll b/python/python3.dll new file mode 100644 index 0000000000000000000000000000000000000000..3fd275244d3a2baf4f1878248d96c9b578c8a504 GIT binary patch literal 58520 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

-k0UIzjlAB7Y! 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%0Dms)xH#9(bWBs3_>P>{HJQ6k8bK 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

>ZDqQxd{YST5QKpSbi`&LYwM>8bw0T8o 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 YX@9kw2D)TMr&YnTJ2GE`J?8PhniR3AWhh1vN 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ℑ|`3;{@Ocz@-4T036N7 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%0A0em4nLIFj$PLZK@DX?&tS&`h@aFrGW?)l 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%0A0_HOyy^#OfR--@TY>n{fZiCu1w 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
yyBnbY$`mG8?sL%18R%X2qW6~xENhw(L|`Ku`T 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

3}A~q)4cbu#OPbxxr3&55_qd7{# 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

H=3sZ>3@h98wIs%F$ zgF++-tgYw;CSgG(qi9fK5tG#emW@#cfhXjXXmWcEXD0fqe`;1E1Kulm=N-kNlainu z4`ef@-OA5AhquyW>`V>){svx2SF@K9J`;2>Nu2l3aOe#B0+7@Z{GEJE2ZZ#yU_e*r z_xZj49D98mGJ>#9+Y!bB*HPf|uAFnryQEl?vMD|RF02jXg2?b_u#W>A7A#C~z{Ldz z1^P=?Q2||(byQTRlqDn`YE=9qpS+4Dba4hY! zx_HR>es>yVP8Z%_>;k8t%eqhY8^gUw?fgek z+7Qei94q$u-Gb4Z1ssggD%#Dj^2HzG5E;FG=jy;s@SA7{3aTxz>o(!zSenK@ZV0Fj z>?BAU<{ZVbx^JB-t&}0O^_vJ)c33RS0g!Ye;(!#XO{ZZuzTClNe$65dVe!8^Ft(b8wMf^+z)ma(kL9%PH7fAKUZi#-1_z1d2x9&K)PZ57!s<|9 zOAz;i7@qbgcy0EICV2d?o}<_#)+@_il1){|C`iyB$pHl8A*P%mWQZa;!Wl3k5h0Ef zCK*@YBav0z1r@yN1olZ`B7fd?ur``zDWW6>tpvs~NEh)d$N|g9qOW9{xRE$~8IF94 zzYO8^G!EcZ351A}R~4ScPRnG}Q@Y}dQQ7!;+gihg+e_f0*aLukqy2>Lvg5yU}TlCdliH%PFpm~-kQC_C}{24 zA#NqO1=YlAqmd22vJ)~C!dw;(%aer|nm?}SGo0jlh=>#fD#~9RN8-;z_zBV>ieiu+ zkoRMER1-lFH7#sFO7C}ZfYC)5SAf00kEfp`_A=LGti2^b7vI#^BSb(6Fv?%#vA zLTGJ^WGH?LPd~xNh^~Oe+6JB5FqcVpIMHDFBZ~I^gcJ)@o(Y13_(_P7Ad8LBz2m5_ zm`X1NNG(m%Fc$*}Z2XMOP_Hw{s+$>*#{7f@HzO=U;9g!2^ead8T8X~~tP3aJNd@E zdx1+G?r2Qxut~zR)UTCCB!bnHRE!SKN%~k1U{fIfSpr*l1SY@95>qlm#h`)k2(5dC z7{ou48D0w}kY^jidVC>Gy#eF|apefWrHK+Y>{vbt2*MB#@4dx>klg)F@ zX%PfNV-U475kurO|DKhVdWdA#UK_#=Ukn`cWdge4R^cZ#9mn^sY?wR+tVJjn7bi;2 zZQwj2pu=6%VdyHIO3AEP&RtDIojqVw-rPdUsIL^?xSiOuIAdW@EW3#(rA({u5?sM} zmV*+Ioa%?_oT*bW$n&1U{(Kr+ICn7Hm4YKzmCIgy4A+Ao({F{7xo;tdg-83=#}@jL zCOhAc6nQN5na3(---2{Q^Ep5|KcAh1BjXat@%e9o8nBuw0m%K+CZ{pY$(F+WB%k4_ zH6ZMHn4dGRKnmk7n(JdyqdzcZ{6SEL%Q?3!;Sb0jFf;bOEq-rTw;!Hb3)KTF-7lb? zsLep>miYk)vRU+af4dPKPQLisYcPeBXFF7wOlGE%CGcYza1zsneTt~o%M7PLKs}vTvc7N&;b$JlSaCqsu0mxcdaBq* zJwns;q6*aEew7352rj5fQIXn!quCZqmj27(2p=F+YHo~0%CRAt#S8}iqpZo*t7TnJ zTtn^*4^*Kk>{y>+Q`sKCPsZub;R2Wl!_(Y4S*qEY;aQ?_#L%=EBNOZUwbBz@yz&tp zpAdP>#yecKaSA)gVspOJSf&>v9iy|qKGw=%L?$lo6S3%FDr}eqjwU9#AV&pt;zKqDpyZgwp8ffmOLqUI_5BvkDT!1i38 zat@xZcHe5f}>5gTYsOH$#vVQ70X1kA$gffa)P>$9^?7 zG8~MRVunl(P0&H}d6d~%b;94;NsM5fVc5j>AF4ro;~G36!x(WvH;}`eBQuVk;b@zx^{FDDxGwSjW0&EKVNT zI|K+R0++pvW68_4iChAvBzRG1WWzo`agGoPwGMO65N+_gjNQeb260>9u@lZbo zzQHQ0YutzC00uISksk#wt!VFOhbSFxodNltuS_LEBs^@0?U`05uV6uwU`6QdUHeA) zg_+GB1Dl2qM!*M>xUK{)T?4TLL$A43H;f9liJEZU?|eu6LzMLs?H#oB6lg9NaDu_H?=v3_;d^_tEDvo5Vh!2{H9WIY2;3t6j9MY+lc-Mc=;OHa`cX|CXB1dE8$^O< z@g+!>rJ$($h+rbq2sv%PHF%}-8Tm~x=9bDvN4oJENZG4x1&sSeYb2GyW{glL1Qslv zz{E~E=?IzjlSJT7s&f!O*+i{7#%Cy~dNjW0UVO2H!2g$cwTqQt&M`A%*H=O`tcT`_ zRZBma~p$ z^Vw8xXZDW#u%w6>2T6kj7+;SI@+@*4a28&Hv(WzCJTRZ~?wL-BR~NBl$N?M8;S5#XP3^I3;?nW* zHOdK9N|gW?-TzC6wC?}KfsT#7RLf;R<^+U-QmKe-!h}h=c$w}bU^yV>nUGjtsk7^+n+52g-~0~h zBlA}}!+uo1;YDza3P5S7k?C>X7_LSV@J8F&YS@2HL-UJS8rT`Y(FH|Wm-skAC#oCP z4YyI=%)a>`B+&Tq-9wGyo`|6DS!!DkaO{2cN4Ubo#L#+Q*4F&2;6@u zN>2+3;3%HWV>KXblR*QvncsW902e9NTbv{hL*N#!;1B`0lNVp0iRrls=pvA90N z4NYga(f5WI`gA18w^&g~@$G`7VrDz{VmYpZ0YM- z&YQ+(O6L;DFuRo4=*nAT5BKD+&R3)qt*h>p3?VohpiiAKPslRETDbeKN?I!-e3x`ft>IAXG z>+4lov7mi44+k*!NERU)n<2>)g z*@(X0m*Bd4B>g^~H7x^zfo~&&YG-Exj_Xf*l3gC!n*$gJOF6N|;$&;7@Ap;~w4R3o z4#i9f69uq>#TZELg=+aM%)rI;1zA&H7H=2rv7N;F!x!4=l8du@8qwuGh`fz}fj|d) zGmG-bVJ`&6`|rGBuwHSvWB{p~Gzb|!j~5V_r>8rE`?0T@*rin3rpO|j&wEt8yg%UK z8+h2jvV=N)7jM6h2YNt9@|e`%_oh`i`x#kiZ}PSR!VL!PouXPX*TAYwW}~c}eb;Cz zoCq;&=G?Sd4JgFy?Vtghy&q8MncJ>D?WDC2i|p2u$T*gz<1d{chk<4a-ZGR}2e;rl z(Nw{8u-^cUpx81?gfJ}el#tc#kTQ?2_~TJ_jFmjRI{>9cm?@-o7s^wK6of}2C>Vpn zCFvOv@uAoxuoZ9OQ&3c4G~$34jBSr#v1@GfraB`TX=I3p#v7I%%1H%ud3wQxzeTCq ze-vaq$~v7ss1IdT^rb8R25B%9Hsf7!wJ*y07U?cVoyD?uQlIbe`3!)Q#&QJSoyY-0 z3)wM0+{CzcJs&+NCoJAF26vJi;xcS>hZM+h`2UEmwocwuytj04|Ea^JqhqHyeem?r zCl8lSU~7{j$4?$RRXXs@>BFbEC4y>uf~RX(*eyJWb!8i`#8$I|S7K)oiTn}Vc9LA} zj{*I%0$9oW5Yw#Y;bk6Z1@|cK6<3!|?tcn9R)n^WJI0rf^B`k^OuD$+ut(j~+W(JbXwh9eJtyF+ancN<36}sPb@;2N7Jqnpa=P!#DEqtvFz#nQ>BO z@1uP3y*$WJW8-OB5|Uc-TtLMetuSQNsd3_@y3|EjnMuc9T`i+%9HtFCIa+ z?-CY$#+|HP=EAUA?89B&9YERv+~v$-0{vz&0kf0<7ZPx9dDU^(x$Cj)&Y-)&-H7s5 zxtrWuaUODSb8p9awY%B91LtAnS#a+}o_8Y8HMqOWy&HFT<8CdKe8;`#)wp}Fy9IgO z;y&kYb+^6j6xX>U?tLiZes?>buXlI2qsVK6`+&O>=Z)@z?k=1+xevL!alX}ki~Clb zZ*$+~K8*A2DCO<$BPit&l(HFj?{N3vZV&G6z}-9Dy|~+pyMp^JcOSmE)7|eL!1*rs zz3xHx5NdF@d)PgKC-=CI7VoXz>pr$VR@~wqb>EF=TdUhH#fl^Dd)&uycb{8w$K2!i z=6=-r1Zw>y?n%^oyL-w#jrTj)%88hJY$EAC;Xa9UqwZ7g(|GfM`;1$}d8hlO?z1>Q zC^YZ+@+ovHcgE?l^uO|1hzsf$5rY}U@3G^j5%Y+3?P>lPuNqSVR@yb9kb5WRIQm{w zw`vw{XwFv7}&>di-jrq=D3QV*&32WMe3+yNjIs7VilvW4u1E)|Yy1i$| zo0y`+HTmf&o4_uktwv+IIjY-0+nudPuV@EqPN_o`5kkZRS&E2L*RTb3Cj%40H0H^E zzgiVvzkLtH(>A>6K4?b+p=K{8b#lXL3L~mniBgK)g~_aZcF)?easpGn(Y+UGgrb58 zpO@i02?PgVGQMm*u13uqQVTbO_kdNoOc4KZRIvU1`!P}~v)KCzliFG3?$KpdhJ-pHOC2|`jRkiy#7Uc|k<8nwqm!dR zcgoX+2eG`ixOu3saEmwQ+bry-`cW?&*lz5Yl6F^+Ry3hd`U9GNzfs`*!9zIkCml_Q zLBWGW2ZsXJ3DGN>Z!k$1D>QJDFs~5-h+{@fF!8b1@EI18#U@%>=i&fFJZ`)vJE)!Q zBw6K7`T}Y{JLAz^iDervU=B|wg|)5ftxo1bnNt><#46dRo@u(V2{MjuP(ry!Fhy4( z;!I%%x`jHz4_ol@nM~Gi=04nL0@AB&4r>Ul0N3ujkC$1U!_J}Y)u&TROdL`x07hqT$S&l zNZZMSqCYww1Dbc|=VkzGS9`r2z5&YoCJE!%eeB@8ouD>Q(xT;BEnb`zykB zh`NTq2=;S||3m>B*!jLD3p6rM9a46NJ+mnnqBMl5tnHoe`6miLcVE=m`|Lh3giT*4 z&tbS~MO+zdy7UPr^K()gRx zuY84CW%zY?*2$RCWu-Mz`{^n?pwLQ)QR)wlB9eC(UQn8E7I0v^AwxqMFuztbKpQH& z0i=I8-d+>NCR0`fk(j$6QX3ZmB2C3VjEDntEa(G*1@6MO=+OHF9k8(W*<^EPE6qEg zP|8g_OcY{Z0pG>FX`v=C@lItB5zI6hlO_|O3Wu6mU6US;Uqn-`EDelkwHV$0blhK zs}4=7#PvDD&^6Wep-WUDX%grTQcyyOxX7Tz^9_n_$6dd~f6PR$q7`&EJ z)p(6w8$pXGMo>XiM?;I%C3T1`BAJ?C4Bo~r2Ae=?PwYJfUJ<)=VL?$%gOcP**e{#1 z8$Th_;$z4{TiTc%@c5>JpZ~|Y?8EPBw+0(39hyCNZZ05*?I-sankvDCz*e9Hi&;CM z(IU+mA(%EASK}QUv$_uRIczIc+o7C{5~#5v1k3cX#{5aAk;n?IMAv~O!bm4wCU^+c z5k^KVvuM zbu3Em^_Cz*!vP2xnuQ)LDMK=SxzX@p)-Q>JtO9uJ;?jGM2Y*zO1kyms#Tify5Ys6b zC@FIY9zuUfngwlCJK;{hXTAIJmA9P-!n=2mavgHe5H6lUQ?jWf)-buPXC+NipWt)E za_k)Ew}UvKW+G+>HH&K%*xS%`*pf~XyM4f8b{1RiPBweU#np?oR;l#O%#$DhY3~g( zO~<7#SqG0vRfQ7bKFV9F0HG2Bl71gvyn>&MHLSu9?22R8*7gujU*)Xzyk@v@S_fSV6fk34P7Fi^LUVJUIJR z?0djU8!(?#v2pY?_dE)GN2+G4z6T|ZEBr&J6QR&3zk*)P(ZFQEULt5u5mp4b533Ed zq;opjJXfm0+)j$dl!K5WsV%c8oa!VwyS0-y#92zgR+%A`Zi)%HgS~M@W|S0AvJwo^ z@4<;W@yhs*uu8034AeB9L`)n)lqK>slyBfVs*FR>dJw5Kdg&otb+Xt$S>-E{z{GY< z4h1R1_&8+Ab8-Fv#ib%5p}m#)2+GMpLi;1>C z8`09JBo;pC9WZ%eMot6MKP9}$U&|k_=xv;aJ%DyTf3-<>J56Z7Ho>PV@D!6i@t+eW zD4i(sAx|h5Wk|+!TdM4$Y6pzDqROgl+ zz$(s(bliJ8p860^;D$dTZOl?55KbOnWeNyC z_q0OwY;=HyrVP$c|CHZP6R` z22@FuB9*9ehqOv{9P88-)V3p2W4L6)EM3x)nZg-JfVJ7>feZvl_|Akx85WagFSv_{ z|I#~o{yKU&UG`Fdc`J@`V*8+7BK=oQuaD83`1WRGUyf zLRYfCyDLYw31En-9PFVrtPh(tPfq6`h~+kHFU!ysatsvwO8g}h%8@6!V`8j*JC~s% zoT)aK{k)Am1wszVFNlNyb*=ST8(J@65uN^{vW9|^be3+!H*BqrFl(lP1voKrv97e6 zWVf>s`lk8}e3w1V&X_dzr+BR}6*n_P_T7up2K;5wD{FQ~&1siLRgU81y_*MiC!Wg# zsm1C=pZ_tEsJal(r*e+>9^7ALe?G9%{#0}PGQG*ZWDhnk+ncvWd(#;DwYP%4BtP!- zA-G=OdmPv@8m!#?7#>(a$ruo5Z3v*HA6i)dC6Y(GY*%;EUOg7gq^rY@u}+IRY^Xcm zzhKd69AesEW4Q8F4-N^Azk~QS_u{}Y2SJfGTL-aLal~Bh;+cyYBC-n+UYw-Ppap$) zio^`ss+m?EZ-2$(Tm*-tJ_r~#lv#*5r@`tyjDlb|CgvDRDJXkUM_%tmtjKyaQgJl2 zT90K#CIhTH(ixH%MnLZzI59U8(7|b!UW6*e?{VT=V_BAs`(Qms^rOFHv-E7xy^FU= z{#(M0qbQcvxDg!V-V?a@heQfDcjG4@{w-Wkj)D&qfnFeSLUXVJz+2}qaR(rUj4rE< zP`Wo^W-8g^J>*xJ+`yGK7|eOv59S=^iW#!Z!UW`e=?+PsSxA^I_L%SV*V|3&xz!6FsUi|BI z=UwfA@N!~%+iSzO1vL%qZLg0!We>`FMtdP66Nfb%;VE2&;!J6qlMXMz5@{W$LTfwg ztSm1k0zn9-6zz?lX=tmC?38z!`KArVoMLe#?I6--R*X{T03Y(<+y@{C$QC^qXHG6j zcLPKI&6%RMdB&|f_>Q9YaNK(yMO5(f|Hu>f;ddqGh1E6=2h%{C2+pKhN*mg}A1L3nU)>)a^bzs;{_672HU zUiIu{XjqL;MW!3aMf)VGh$%#zK|ov2yrZG2-acyQ41S$TQqw$t!i=Roc6^>cfel}W zT4~6CNQ0jQoKh#H3ur1)W#IwwVtjOGF#-EV zS3iYTbl*=XFymyby`v`##0(N}B0sFLJ#3^(;huNPm^=bIxAaT`tGf$<4Z6a68%hyT z&wDSgTpWxoM&(8sT~YEXmXp1#BC#}vQIf_kimIw+<7?yXp6GQg7MU`Nd5{H?w1`C} zBP-XkRsJ8bdmnyHT6+R(pZK}sE|wX4RaWamgo{~R3@cUY8UyKSMx%+aqCmDv2Vb7s zlgM30R~^804yo+A1O3&0q*~35=kcarmi8L%+N3n#ue$7XaDPZyn#W6D{ z+n8Wugy+SX>Yc-So5)7jpi(F?6HG*F!s*Qg*WioQMc83#lbS%;K%vL2QH?4(YeJ{# z#5Am9_(r#!EIe;lm3ux|R?gO>;ngNuwE| zw8n|DAT4nBF8%&43kVeJH%BctQnUpZea+hmBW3j=7)23_phfj;T`ICnhYvVgE&GkW zMi1!B3u&l;1*8y-KdQz{+2Fm20C+gaj2#0N(QiwoP*rTH2$)jrKx}f^tDNz{(e!I# zZ8@w7<9}rtG)_G;eP!0ykRhNnn?^1_<0fl|pfh$vfTlK_Y+Q|GgxQWAl+KS}=U|LL z3E?N6guz}%sv>nxV$joh75fI&8 zc;5eJF&H$sKpUngrAw=b)ys}2zcPZ+p+PEi52c#1W@qjkuft-!?2mmX)5d(t|5BpP?{-@`7|6&)X9~$cnV)> z#p+I82chiw43kXIMU@2D4}auUIfzwQEpNeeTG*x96FnphCie*ppJ|shA2X2RBVQjCQkDn*?CjUxQo@( zU2>kBml7Oj&FVicPS;)&fNHV$sM3pR{RFz< zcq8wi$;gBn#!zrkx)bs)DeqGH&P~Z(8qpMKdPhtQL1wHiOI*E^0#LhOd&%5r*Xhme zOT+G+FD|sxFD`6D)ImGGy#VQH3+mt11D&)k)a{+cyYQC102bU>Q;k~P%H$95>n^y` zxw$~N4&j3ST+YZJ#*c9oU656;sjnvxw`jx=ydq>(+MPRsGv|xLHQjie@WnOaPvjc< zAf{#Unoqg!FjHW9;#AUHBN%Ebbru>TWMVFr@x0MNq2(HxH$Fx@WOEmRLUBu@x-13O z1sK$=SJb_W&8i?#P+)$C>|p#pLW5ouIzqWeBL88Y2L8cMzdC|zi*_RO$JrwW9-E)e&6`ve+-qBQwx?>p16;<2SISVv9gj5?5T{obyNvH4DGT**d?4gq{h*FdCsF zGlnd-v4n1H@G>)I+34QFjf$+pN?A(1Q) zSXJ;E9qTxw8W@rYFs769@EUQ(5L;m)6FSt53;O*>Sy$4}SOO4=M_{8VB28d3WHj&- zHbHyR@z{U8OOky)J|2Liy*`9sVfm(aCy*M_0w>6$kuVx53{;ucVl`;3lM-&(-62#_ zJ`t3TI61a~PeYN?8i+(nA^U)LvRvsDv%cm$_9x8!)fTW(C!X-rP$2?V5(!zb@o|>K zp_RQm83(fUW5!25-#3`V#Ezt{P-_+@pF$#OF%gB(WJ3kC--ZjeSXL5!HzQwwCF@!+ z!o$Ld)kNp9%Q2qpBuhi8#48{r^9k=^VQjj3DA6_rCkkULHT4H2#}v$JUo|&KVkE9_ zn8MC~(5U7w88U=*|1d-JgHX?*yvfW}<^~(5n~}ANvj3O8cY%+py4r_Nk|B3OR76D7 z(INtpa1jv^FhD?}kRYHSUWQ3#k__a=OadVdHq~gUTD4wU+iHuq*0$E-{f3H_R&8s= zyP{TVwbi$_-dj{4|L0k2?{m&fCWO9kf8YCkzwbYAa?aj+?fcqmuf6u#Yj@ZSxZHh4 z;UQdWi8No<+?Eg)85@Uciy=|EypRg5mi^@sLoS0cmSi<7#Exw;7d}D}=l~VuS~K3t zKW+H4{UGM02la$|b!i~MRVH1BFHF8E^R9%iM-UDP3nS_4L+QRMgx$gJI}#r}RZVJv zqd7tsVf!0j=7w3EXbWV<2`?N7!E^B(hetYa3Q`eSBgDgyHBvU20XmQKWBjL*LNq65 z+p(Rh{>o$QDqmbKF(C)_#a!mbgdJcb^&DWNm`u6Tbe-cGTcYGMH-0~mfbY8zhX$Hp zZ+P|nrZk(}I4}US`hIpdjJ9M->e=hFeW`DEA+wE)w5V0|DWOG?12`T6Mk#Rc7M6PW zFM{LA3fY2J@0394yA)0+?0G3Kg;~ppOa6AOb)WdZ5VN zWO~z4dj|aD=im>HhE^@AIJrW^t4hNmUJcNK3T2pF1wc8Gm>?uVhOv-GT*M=SJ3%_Z zGgqj&Jl91gq3nW^`AkCo5J_;7)5E_;VPAhol$nPxM-D?mz6nIZsV<<8$TY?Li839k zGRyBm&<2%wDoVk2H?CTwB5ig?{Od?-E;he%o3Wi2$6{E>1hNrpg(u=IScdc5kZ{9# zhmZ=&&ZVy>Ll*%PN@qq0y)C%cOKy%>r${VdiHY@N#0iMOPvXl(a49!<5hQf@ z`2qI_Jf-{_7hnULJGSUU;0(B)P=PPMn-voj3y|M~k{?QF@_SuM39X6HKwm6_X$H$6 z-A8zlFZ_$-RIi}z64oB42sB;bR=F)Zza1~iS_Cp%D7TlM{MM-He?na4=_HyHHLs~-M_Rw;6hCbZmK$0j3- zs($ec_-8r)bn%Z&cQQ~o?sOnY?gR9Iri`ZZ86+8Z^DAZ0>@Q+!yD`8;Qer2{n>ZV= zPC&2e=C~pL=emTK1laBrcreyyD9AEd*J2rOL)~wme@6Twr0=pXoM*G}$lzIoj|h~& z&}A4b;Jt9XmtVTw1m!Ry7DKSJhuuDiGe!Fpb20`)xhgAAiHs^_+yFBB@dG-JnQgAS zHH=!&ofauS16#2M0~+RoF^hq98<=#Z$Myo>7GB3JT~HbEK_rUBIB!M8?5Bi>R~WP< zu>IbU;E^8*PD*anXghsM&wK+_)(MgeA)OxCK$vfZ1WHGy^jxuKrSmPzJPEC+vgoXU z9PEY#4Vf6R>-|k6mcF%DA_T3e{B9A5Ke!KCDw7swi_XFqCJB5^#IjTr53qp-bI@eJ zv3v!G(=-BK0T_fHV0=Xx0Si)+A?YjGbdv$pF;Y#Hh=7i3I*OVo1*HVolVieO_cE01 zf3^$Pv47I`9G9{)aD+z&r3@Qs{E^5 zz7k)#^0f>UU%E#jFoToA!d%I>vJ}aaePAk%Y2?73`<47!S-?Cq9I@D*LtE=~VP7Xp z&s^xP(7{|cnv_&P_sWrx*!9E{fE;M#o|5sh2WQ zB?WPOo9bXF*xZ#JMUAmUf{EzRq6)iEt_=tUvmt#l2H(D&o5Sdo-s7g1k5}c;5$1He zNIvXFp(GXXjVLC%J*zR1x(6jjHO^pfGYiUlxI*PBoV{KIc7SWu!T_x;2yD{OqOeH% z{tx&-yK~0pKtWr}p)-6#IRSQj(0AY~&8$0L<{-|h!!TcJ*Y--yoe|@|C3gvUT+!m@{-hsXl$tRA$!v51 zs-|<$8h#zXKb)7)Q!=J5rib(ymrlCTmd!7TeHOoDR+MyP8L^grlEhwU-odh6AEII% zRHGxXfzSwcGKRC2P3)~vNW(#|aO&X%#0_nHVGlJQR_=_8JxEsWQottl8<|MyH&%)L zM(zL_x$HfVN8XB{r*xo10>UO!3^-_v>B({`itylI0j-?<3XE1rIXQ}{r6r>dBiS8w z=A=_=9!&TEO2%EFGEOW_9Svrbj4sgDl?G$^g|5pUpvo6y97wY>6>q3m%9d^(DbhAo z?ayfB5;o*u#Ktm}=;gLq;NYQy24FaQ~wyDfAh6PTp-$*)aSL0^bcZ!yQoBFy6rH1nJ6!ORf~e zcOJgwT0wm0N3){^cDoktLUEfdTet^`TMWiiguJ{6?m>7LM*`@h1Gf*FMQy}b6Xbew zk5b1K+)vQW8{I;XsoLr+nhvp>12dtBYorQlLJ8`b5H!@_=3v~69EWNs#w&~mh{lv` zGlkbQ$8@`nCY|iQkZwA_t|+!u$rVTfrWcYB5RI$|$SK#8t_!;TuUtboG@0kH?IgDl z%4Ef11GGsq7UR?udXQ+tS~)o#hotm{QALB!TuZ#NMsN#od{b>p#^G3e80D%$Zk$+E z!}tguEf7_%Ov;`ZCL1eI8C7dlu%Lxv)gwNzd;(s}xt}BDhgqj8`UkdW)iflG>KPaE z+q0pBi{X;GtjGh)tG8J^&gzhva=7-E>9gbD)M~lVuF!^c%EBXcB5ffNrnmySetP#s z9;CB!?*-3ogSPx~F0vF{u}yAJ(_jrYhPjof_lj`)6uR}mM{qXE(g4fU2&mbT1ccq7 z16txntZ=LW21%*{3!BYl7ooI0^Nk%K$)k8TBP@gC*m*QZ? zdB-hnpkruivs$2ji#p}sDXLNMVeb1-(tH*|qx{WR)?w+&s$l(=c9JQrDifq@S?Uoq z3Hfk$=I8d;rn0a6(cX&aZJyhUYxYaGAF{nr=TMzOWy;uIAk(Aq5u$PxJ5fc+Kw&E152HYrvUpU1EA;TK4OEc24L=w zXj+CRK_+!Cyv>10yv>k4c$hW$sm3i57JW6V+>iI>WHBVD?M zRN{cWbW2}cM7sIt-@0y@<**Y_UlaRq77TC>Zp=vbn|u|?4?>oDGIl<{ zl3APW`*EVuJ`d?cygk6_UhJfzql8~z659iu`cg5HR6NKA;WCG;G$m2o|LjN|N`3JV zY@XS8gc;{b-Eeg<9zCB5lmC5;^yQeA)5WTSbB*oqdH7DP-o*@O^)Tab;geb^iUEum zFKPZJxUW*&TjS}E(HR{jW)_#lqsRTo+LeCE!w+SXQS*J4qi@DYrqGFQIRhOBrC{bh zvqY0qSfZrjB=c_n7DE*0{6583!h_S4FbyNrcSDw%lByLX)d@~2E!R@6K5(gN$>sZj zol!8mNw&9kU5Qf9*h{H<^G3z#c%%4tkdClK@$d309V z$y`u2IibQpVIFxR%Ll~?TZ6~_u}#bHB!c+k=Ymwe0|k6F_6hk8P&NlfH@l~Zs0uh%slTvU7;?Z|A_Y5^h+hv*TPk|?HWdKY> zB#c*Cad{0QlLc3dr@DPaBLTgN3k67fE`^ksKfd=?q-l%PR6%Nypf6nq5pM%d6;pQ@ zips`>7o>H@U_Vwew%C)9i#Zqv!B~4uh*okT7Q>fl9zp6wPkSmmwVTHydX=wghorBX z95+d0O#?Cgc6z;blP_t!>j82yb09~d)>`Dkd6#*h04I6&;v$^-8JR zX0CE5$}#unV)GMw3D^^gPm|3zd~vDHJ6K0&cT8Lq#mNLL|H5d^1_<8pY2>G(wg$N= zwr||y3$T1%s;0P)Kw&y2VmFxgdqeu+#x^)p9bE@4ameagN*b^Z;uY<(53bgJ27GmW zDYn`I+q2_|mWEjC_AJQfx96Y1E7awjn{3*cjkxVOChqnDlGO4*HDtN?3zKIl-2`o3 z+%(Aw$<;PX*qm%(2bVON+X8Na%WYCNCt!4fI1(QzG9-%Yhl-30(+1Cpa^fIL$>K@5 zMfZYtncanlk_`^8kJ-J@J#pDVb8+)IEL|?bD3+k)OY9xHWn+AIqv&HeI8xnPU7=BC zY$|0XMsm|AlGO_RFm5vd4tK8MK7!4iS+IG!2^Tl#T;NhK~JBpL}wR$r1FuZV}<3Pg;D^i*r zM%*-ioa_)JvaXP?oW+u-xam1Mww@1Jy>vnFo{@ftGR zo~lN_fFLVLrC&zKF1g{gsX4f+ z2^eFxj4b);*l!N#ojn{PyV#YOmmvnXXCQE)DUK23Ey3*KQ8K-4U?WN^Oh1@;Ar?2# z<3|2TAr?545Qe>%bs=1>TeIpK_W2NiahPDnhJGcaXKBa>cWH?AiKMv_6 z@5A0ov>1b^jwl;&=OiBp!hfn~RSca(5{ALtS3w9=5$*!CixM3AoSOtCIA?MAV{dk( zT0@|24lY6#YqzZdbj=tV-_kXqZyv}LD!vGZRY3QtSP1n}#MCWqbUFMmD{h} zt7ev0RGzH2W6A!(9fYQRBCvrn{O+WO5Z!Wqr8GOQY(kUUX8#RadobWc*kfB2Y684G zBYqDPAhM;Wtt_Z6sIfhj#pXbx1)$9Y9G5MtEZES&Xlzv$BQrb^46#l%Je&pYiY9S< z?GK^p8nJyYry<8ms$AqM?F>g&LK%$&*oc{AAL*5QR9|9W3ulI%Gm22e7fQW(t}SorXRcZZwjUlDMDOE+{Y+hu_`B_| zcV>VAdtrS5{Tyfol}l8Df|Y`1L9HKllLkOZ9~YiM<^=8SAHZS~1{h}0m03SZxKrxDu4|ufmRh%#GFYRz@DKUQ1O8uS@NLLB(Ddv+QBS5a(84 zF3x7CfPe@arWJH^Ru{&>sXytRnl|i!IT)&#Q_6b}fH=ms5SJW4NEi{Py?#cv=%~kl zp=8hoT(wrxaMsbB-qzHJqIyN z#lTHq;{Yfx^B5O2{W>$6GGh)d_rpbg?V5^WvE3`qeI2Lv) z{4!d$Lgvq))nxNg*`rMZ9t|}sU0sn*ihTsoNLV@m-IZ}KWYW?<$kJ+XUj-LQLNP6B zD)j+=7%7p$Cpc|KgGcl1O+z9%r&t}VC_*ug5R%H#miYMKtac5JD+1%q5pz+u<8?GV zZeXsB0eX>~>l`5IrI@=^JBo%Lo2kOoir1eA(VVej#b_7|&@xjlb+n}9Hc$$uV@H8K zTExl4Bq;-f+Rbj0NJ=I&sVt?XEvxK=!}70K5nL-oKol>+Xgw(jg_sj@8Hc1JqeK@m zpxyTZD+Ot{;}TnQGF0!i@@Tz`GLmR8#xe~&ifRb}Cs zjYkX=Qhp@^id$=3>OonShxiY|0O2uXvoQnX_6KA2ouaHFJZ>Zi=I%12r{WgbKNA&8 zW4bgQkw|ktU9s8r&xJ(@vVGM80gFAEeaI9v*?~yaZ3O1WO z8o0ONxX=@+wiaR*%4we*8Gy7)aSeMeeKAj6(aI}6adD@)m^2q~d9AqWvolw(>0I5u z)LB>9I#6a%T(i+co63Vcp&K~Oe6!|8Ea)A}HJ*S6r-`dO=@-zeJ9()GWW!%9ma8`v z0cctkR#ntN+Mu^Z+{J2#E1j;1L!ydj<0Jv`h z)>Jil;-n7}V^UU=7Goqo9sdcgieS7m*t*tAM-nby7Hx;MAz=&HLd?}Li(^LL zPl#lL@uxCA1%JV;(FaVLY=Ow2BUdI|*7gCsBR3Hj)@?3*1x4rci#tAYBv4K>DNjda zi*v$JSx_PDl&-TkKw_= ziO9*x!yw0Cr$B*sM&i)}lUd61QSeZlg-tK$LGaEnZ7He~avoiJ88xHU3kB~CGLHbofczpRdl73S_p4@WU)aF&3F zpN$7)RS-RFUkNpN7EfgdobuyM{3HFwF55oL?o7HVyCx0fI5WgSBJgWyP)3`?7fZ|E zFqJ3x=PCY4=2zmsh2PiMqNFaWJkOSb;GZE@r7N>iIi!htscI{N#H^`a+;}XVhw{$| z{^80~F3`~HAji;I!atOAs0eEgzfR?!O8ya@t`+;1a zdnvz2W<^8YYb4p7(q;B74E-7Z+>SrX2U%HJXyKwcb1Rm`H!z%O97Eiyt9ZKLi&) z7UvHt8ku{@{$I(>$sLCb{J$;x4I=~V>?j*9?;BQY=>4M)6}R)#L*)JXch&zD;~)Id zMDf2wy`6Vc{M&kZdKk1b#oxl4Xnnqd2pNp07!N5FQH|}zhT}tKmk+1E)F%gieLdL- z`*$Bi@qQVZS%CrBIcVa7!huDDiuc?9fWZe2IcVs?!wwmK=wXKkk2vxxBaRw*^r+Ee zju~50I&S=giN{VlZu0R{PMCV)wCOWWDuYELETZb_V=GrRG&VK2td1vI+t#dYU)OQg z+2@=aTG4m-S3B3A_qDFCpMOF3g%^Ee!#6L!>5e<^y8E7c@4Nqj2Orw}@FS0IdF)q@Z~gUe zo_O-9-~R6RPygYWZO=aU{0lF>^ztjOZh!6dH~#qMjz7Ki=eOVa%U|Dp@4x=`{@?%c z!G|Ax{K==E{qtWtKmX#(UAy=6!1~|+to}1+%`Tra_vCpMr<^)}L1op#(-tjWa{3ud zmz}v>>)&_y|2yjMVM3o@srX3uf9m%?O^ah{U!J{{cYg$?d&nvOC!fB`z{w)r!^!JE z`Sg|l|Mma>dkcJclD5EzGJT(^@3PDFz2R|vuiPo`uI|#A4u0GAuaS56%iooE^y#Ph z4u&>nl9haS&Aj9JzVYf|jd+*6bKUqG@xJ1)t(#xMd(z0yRu#^6x^^7D?(vzkosF+t zxOCE*+0K)db&Zexe6}a!Y?RqC2GPgQRp^NHPdrb5-skw*4oe%FW6DH z8!YbQQ^JqO&5tI!gio040Wdz?kO#Y2N;!;wbszq2f?j;rDNx7Qp;%efhjBwmiwj}h7Q(u@D2}i^ zINMs?RtuS*8->Mi8mns(ejjn$L=fH_ZS)6=+ZXIeBe&pIk0dCRkBu+>erRv}gk(_J zF=Sni6T-URRgp#ha>l48;qWq8?hQ$q!|hNP;}^;wZjUv#HNt3ThZxokL)4DDVJNAV zV^1*b+SUZizc7W#W^mLPp?x<*YgUQ`>pY? zJshO~o4=N3EI5%EFID8lFHAu%tI=@!<1`_p44SraIk*`Ln+(jCHE6EYQ0Co0qqwjD zmnfAQX)=IA)$1TuuLq_A7{&DfF^o|6khB%<6k(Kf;U@1SI1ynGK4h#cn1X=k4&(O2 z5boYaitC)Y`W7Wq6K3`%AZBcU3l zz>0q5q;dKR2&hue~*TwNY&h_|WHQ+v0E z#D^5BwK;@}NpcvM_O5ev*GDmu+7k8ZavZuLJm;n3;$_1zE<88B=@09%PDlWnA?gat z5E8dZ!1^(w_#=Y#6F1h{p_Pedk^o?jNVqju(i7kzX3ZwS5`?$LiF$mu*TViIEl(Q! zONu9ki9ufMd>d*=z}!!*BRU{*b`E1a8ePRQ5vAR6j+uwVBGT3<6|Ignp$uW67W5;+ z&}|VX)Dq*4n-jwRV5GUx(b0_b67}I@0gEj&PC$+-;In=-n@pS_jY&8lM0}C%iRLV# zICXLCcAE_3+eet>Q#=U?9p+fo5lvN9Q)w3imq0K*2X-7dnp4 z`9r`*PkB6C`%samF*o``-(b`Ns2Y&IJrpXfy2q$#xf&Xo! zlt>3Ru{DFPz*-1)qN5JRpRh^{t3mBapg<*^CPi`ZQ6QSFQQTIF5eN!SI9~qDcLeu( z^UYs^Gz6ozF;)}D27)@^Un$s1nosCbpW6ThM^OP)wn5}%0ygrSf)fZWQ=u2%pK>3O zG)alq3O=C$bEPfF61t&6AZ|`~lzKxU~3 zFz>>`KmSCc4Xt7NGM-|MnU3K`Py6PpL{#Z{$R>a|VC9<+9j3W=O3aDGKQYa zr(}eD@v#-u*hU*EU=988u|d{`QGtF6K z2cvraC{>hHMSq@uN2~>tXj5HOhAcWy0Nii`j}2w6u)sy)s7XB*(3bBD)kI@Zs4`&0 zLoBaxrLG$fbgBu;9&oobuf_Z)L)!^8Mvg1RLoj~x9p|LP5B%KYM(U(n&gjsoTZ*71 zUiUhoW-v)0qcWFN)#@4m?-(=156b&|pmPYi5pUB%z+b*cg)!Djf+@%0!rZGwI8-!K zZy(@1)6@#Qap{hAj|z_sR!eG&p;1Fsh-!}VaBvi|jt1>wB1l8Wm;@7+&o<@uqMO2y zJk-V@Ge;_zB}u?EK{M}4Z&%f(jo0MTJi!J;6crIFYX-w6KH9{KYl|#3uNDYxvpzsj zrJ#aoyPI}&lM$==D0K+LjGcgAI1)*h*fBO8@GI%UOKdnsO1khd3BW4f11*!J z1WO|^!)<~-5NqL17h~Kwo4epkl+lP6eSu3^niZ2Vx2H?;D8e*FVLUoom(pq_(luZf zQ~Zw+e;n!3cC1bfM+joD(_&zv@ub8*PvXNLgk50pP7C5RBaU-PHm>8dbo8tV`@ zu=-91H)Dp>wYgPD0#F7Bmoz|#MOrtgZELQ;6MUyjZ6p)JuU(hPe5V6DmtY`6eA0z? zGCT%kbn^>N57M0u_?YRMX^afD`GpDJ7qVJ-7aLI@!uN%|2A)aB3=%86AauGSmDwmU zi@5%BS-*5K$BmPyF@wM+nwD>GNR3!pK1FOTUmwVA3&;8xWD@wjA(M#%QYXkK@Owil z3vX5u0*~)>RUTxk@e=Z_urQg` zU;@o$$TDV4B9h-;5<#AONk#a3Ox=y-^Z8Cwkh7}KL54*te;wl2rHem9;}atw7lR?oI5^^%a9BPm zAcGy@10bO*W$U8Tz+)x*Qau{{cf`gokiji~o`s{#azA8|!b$B+-UU z;YRr&tzroIu3Cr{sQ!ySk3ocGC}g6Q%1u$OH*wPxnb;st^Md~bV~9lr{>UO0?no4~ zD*gyp4tEn4cp`sc`W{aLK{$>RAxI`Pz_rDY7v*NbigNNfIK`)>LRcNc_>)CPDggWe zBg+l1G;;qb$S^^yBduNE62Zgv;zTxFfJJ%27itddmFt%@m*_ zC=MN-6sExkLtUh42+EI*S&(K3a?n~MB;Fz`X zW&9dAt*M5XTDvJAmxc%$Dr6$N@mP5qh^Y26WD@hGlLQI%_7-f?IOeV69EW=$!=fRC zIEYo8LjM-rTP2pNxv+xzsF}7wKcJsYlrR;6@VTuKV`yzGf~)ONCc=X_^SoR`aIIh` z5gMq?MKKx?a}m13E(q(RvAX)!eT;}an-irrbtPn`9LyFS5MPHQ^gKH#1A<607Hdgv zM#As|M6wj$f?PvpbR_ZcNOwoWB;&sP=}}gUHbDKD;E6%r@{aQ=$c{;(L<}qCO<$u- z`f@U4tQM%0kp%g$MnvA4g*oxK1j{3P&7>5cYw0j#%Q%R~{iqXzvJnyqV%E~+ObL;e z^upfLAxQcp5I?aFM+WSSv-flWS`A?(uAxMPvB({h@tSR3@cqjj?v8q^r5x1JQklrjF1+Cn-Xv|Yz6SgV*pHtIaMP&M^ue$ znaT<N@*=!jjPlz-l%UFj+S<$6(}y0<&6OX24StcPb1$^&^c}N zs;SC9FfWkCnzeS`mT&AwupzNN!C%q>87^&&;RG235%Fle7I(gnwqg$=!n7Kiaa$+T zT@}MdhWV`x$66TkS4Ar~G2ABDn$lz&h+eMtbnCmuJMArmJ~(lF~jZnEo^ILA$x zNVsFC7&zm`OX2vDz-c3Ho}wQ1Q}SW?*Fxgk)}kzE6oiQZ9NpRy=toTSsvUs!Tn&g9 z*lhX{&bTrDWL|XrHID0aLap_j%1Uj#5C{kvPlL8j$R>=z55i@;5&M89;RKAZvRo#e zMf0@)*3F#44cJj^)bYARvMUi^$o;Li8(-laCm9aXbXE#Kpllp0b#$%CKz)7w#shnO z$QZlTc(FmO+ro=9Rm&`1BHfL*wSX<9I9&0LQ$Ire2#Ne_R{0QCZsFt+bIg70AX_Z8 z$kZs=GK2PZ2urvLP6vJz^_t@no|_x4hLzx_Kb&~ZO$7nQAG+5l9F`b01e^gs2AS4>;nBHy}{xL{FJOxsyY*~ zs;P64ScU8ra^sC%AcklV&p#nDOU{RqhC#Gm;n=&ZiN{)ibKo{GPvhXJ!c$X2zC=f3 zv6w{(*2UJ4=i@{nsarDdfE`}t=Z{fejJH?^X(E52SaYdYYR*@}*SUO5uX4HN)`k9B z5GIHQT*e3eV7DzLeYoWatT;@5v$!Lu%_RAUjK?g|b5ckq2@B;^e3GKFoLX0n$Z`T_ zn?atavt{;5J;bc)Y?`X+MI(y9PeUjmIO0~kv*PnmMu2_7bMd@tp;5D0p zUhSc%#3vnKNvfujG9W$3d~uD5xt_a*v=miOgldG7LAY_Z$}W}Xt~U}B8@|fok%3=n zHa2ZI`fK9&i4(DIqp<;`gCzK&X|pq9Guo7fj$P zhVdI{FokcU4AKZ5L(0!U{M=)@_>LP``g=FK;@c|Gz+XOn^e?eC+)`tRhn4_i$KYZI zNV8>Ji4mepk)+Kh{X^>Lwv+7RW4fpQ8$B5hst_)(zi{1bEPUH!e6gH0QJA-Y{1}`o zq;u+~KjeCL8{$ zAWEAUr{EN@`gZ5b<`Amjake$kQCr)L>&}yWQQl_A3+3pu6q9aYIqVz;H-$3>I|QC1 zf^evHLh8(zOb1-I9}YL9dR|Niav}IB2;-ya{BBO9mVL14@h#i2>~hLI;cmbNR@iO~ zp%5$E>U8~pIm&jov^U*YZ^uO}5Dro@+<+}z6^WwE*!wY3C)3VwV-!2LWVelU|}%IOG&|07l!Lp zuA$2z3$b*qyi_S$ZwO2Aw4&uAU{90KD5Nx2RbfY?ow5G}BTI?k#1hdob@8XXlscH2 zOBm)3$lR?(7q*BVX*uL(qAF+KRxQi$izTLcK+n(|ERkw-;SFL+H@t-gqH*P|G&b%; znrj%0@e9gV4Ppvmlj$xYrKFFxEfkJ}pPC64ACNN0h1JuAUMF3m2TLtckCI3>>Mu=~ z975GSlAXq6Z@`m9qpnz}t%bTpnheH2ssS}8(ieXSmTxG2JXQmdQM#C<=Lr&PX(jGK zAYWev-Ex?o5x1|aMFEGc6s2twwwvpa2BDrfiiRPgGZDdOFoUNv{L{ukZOSk;Mz`H3($@_+DYHljw>dY4bBcTGbIgqL)F83x` z<>w$*R5DH$%R1UfiXvhGBxt*eMvt1L%Bt2a&1LFY$K{Jy05g&*6WC9B{^TU3McmB9 z@D%$u;h>i+tAY}`wa1v@Mv)8OjC!K7#A7MFAPyQ9=);OFj5pW8*c7M*Jh(npRdtGs zrQW#WPxAND2hle&7zSV=gvrrL+g&%MG7_&s&9Fd(1|vFLlp0mXu{??3^W{W9lBMaD zItxs?&|RqIDFrDEQuO4((8`WsEH_Cu&cdq270bLXHLc)p7mRIJ!sPc)nuf4$)=9~* z(U9{1ZzH~hEr4bV`8E0%$DoYU0SkNVL?5{JhU0L-gJmV}@}k7CVqBHVm(ko3-|G1? z!0aJ_aZqz8vg2YJV0JUqh?T35c(z?;Q{K;;Sj8HI7c?v0yb2cPD1sAEUwjd-!48cS z-RF+TENFaMHbQ@W9EXtT3 z9GMmYg2kOwD2~%4JXM(%;#VR|Fbr6%P~~ULd=kz9PnFrPf+nP!!WYr#2kVR1#3F3wiMBbp~f(cj&y7;?5 zu5Tmq+rtYm=_u_|Z7c!m78LMe9b3DS=UdQmvQkmgC|vMJJyXV^ z9#!-W!No>t1hh!h0nw01Nd(^#e}Pfi$CR1Wf_=;%LhZr-W6!M_B7qtZaLg#sB0F8r z$R!g2l%BU)a#%|Uz0mc!;^aoPHd9Dz#|LsG22 ztm(Kv22A&;jpNLO!5A1~f-i4<^YA{U-NT^W^IS!sO&I zzsX(^RH&h900j;rIYf9+!UfO3^{yFlidDFF+A$ITf_8Q>$j-S`?F> zWF$d=`6s+KEJUPA5gf}A>>8rVDqHiqG^O8Y?3=wq(RW>QTxmBkDLq`mGAbTdAv1Gn zpYWKJP@)LCk$HgAf>JfsSr$S1%17f_V6$wtf?Y4UeA9t?ppErSo|jGiKs2-*ZPl^n zHkx2k>a(x#m>FbZsE)#vSq$1oI@tEoPMRNh4X`QDj^_p?%)UtljCMyNii<2TV6ZY; z*Q*-)m_CrAnsUq_CP?c0i>k6=;Z!{DF33!Zdv7004P>hvoyGJqe_@H&*qnd?seBuN zfq=RhEOo*9ZGVx*2!g8|5J*f}=00a6TrXNwm`za>Bl4m!@Y6ood;NfS&24e$ILNjm zW6a?}b|wOn&JoEOjZLLzJY)_NQCs<}`Jn|fmr?EA9>sNOlk@<1VXPm5vQ>-t0K)cc zi(}%2<}6$2j|;*PD^!&n7y%!hZ&NGu&pD36K9p;3X^5o=2vG3IUy*RIXMcDI^(6bu}l{%|gf zC3WQi#=GD2pr*rktP5mD7?aH);aF3xiNa>xQeI3e>PeoRPc>;bR+k~X3&S(jCn=3; z$1Mulq1~|X;mhqDL@>-S0K(4Pk5s^*uo)%7vS`ak$B} zH03q0NT9+RDW??^s$U3VWWSFsm0i7<;<#WAY`BB2K!cfxR5n-(MQA z=3qK>MUuX}9z;z%1lCE<@iC>O@=6G*+T4^>M#3RpQaRyHDkt1hPA@0MqWs&G&3_0T z{xgF{Os&Agr=(%$f142 zZBB#vyq#*ZcSOMfcYt*~)2x2Kgbri76z6DLjim|p4%WQQAz@O~h4BbH_WOWPP~C~0 z0`lOJ#JG@GuwRh&H`Id8%;ov0exYDB7N-FTCd79y>Dlruvea=ex#zn;vK|4XA%L!y zBbF-(TH)rLkWA;?_QP~9@;g~bBo_?tf`y@nBU{{~rFZK4PE@90R#e$OtUJ zY+2RoVhfX;%P`4OQ<8`NUZNBTgvo@nEBP~CN@q;Zz>OUb(cNh>*o0Mjgpx4AqBn## z@*9jRG=_05psiX3FQ#2;FubrjsB6P=g>al#{BFMs`=_p)#>_gdDUA>gbm{&FQ$aaJ z4vQH;otVdrnvXkws4;aDjBv>H5N6)qwo$&w%?w)z7=*YaOFG`>r72NNk|q3jb>pIf_Hf_4&Ovf_=-!t&$kMqJ3PYsH4!3s+mqY*EJc0c6Ajg&RI+EfSS zCbdu(thT!|BhQVuc*kzhE;#&;!LQVeblNjFQx%8iMKn^5trZ801>M*&x})m$HeB3r zgW&2Gv61wnNS=IzjbejTKh~R@hJHGSU7i{+Lf~iZE)b#ge1+XN5;yLBs77Q7WH{Uy z7Oqda{UpM+HDRpcJxz4%xLr6y1_8tP!(ML;tgpdN=8J{^-Znv@O^;Ie_0yHH% z0f$)}{T@m2mt8|&P1#58W)t!izDw~>v?#oOWeW*jMtPjtogt;PjEDKscD$rxwshQZ z?f+3Dbfy?LI=`eOKVQk8jQCLuu*Z#&9>lsh<&z$sVaf0&8^q&G=ZiNsI0nKitf`b~ej2Tz*PFZ>Z6eBHj3e}-3nm>lar{TW{RiuSfdy_%K5 z7FlFmn61g=ao}|WgOlKaHC}spB8~F0ve-jST)7NF>Ki`#!am=nQDck z<`xv?j6hmpOPP#qKEiU0!7T6({YMbkW2FBrK?Q!dRqsPSC0;)LM-bSOlzgB_xexh_ z@$%_Eg20YR&8K-^+U+P`KK(`z*rQVN!6pxw*M6#`KxRghWXzO?{`z+kkf^XDESUFy{G~UB+wV2Th@;rjdd@KeFyl_(;QzG9`o90g9 zNF42?))4xMD5*`G#>|9HAl|;_H^ZHDHNSm|DEZBp;mZ$1xSui-c%($+d(g%pf$h|6#7>e|4}%3*S-W_rQtVXB z6<-6R?LliKUP6*b>TqP1$5>8@vDl8ZO0o~}N_xfXpI$P*F}>sUOT`%Ps9y2X(TU!p zW=wL1sNX(~8)i9enwKZy?Gyep-VB%fl=kc&pBZVSmzU{>{_&IX&g~ViUwmV<&g5w5 zcVLiMFxrQ{A2-gTH}QKPBTAHUV{ZF`g(OF*8!`|wLdOTC;ob{vZRox#SU2#P zvMeSjwRjMLY9EvdTV@cpc*XdSm$6hR9R(=!H80zDpCU?}GPijV&sZMXmkfQ)BzBFx zILWO8RYfIfX1@s>FZ7V@oDG>wy6T(-e``gC{f_lhns~{r!Q~U{B5`}Km(s*H1vP6W zH?D1d^Mvxp8$ z*WvVpO3-y_ik(H#G}9xJvYwNq^bk_A+e=cUA5i6wh(5aQ7Vo?b#vEi!SZF%4H}4Je_Zzy$=H=5RF`)2&>DI{=t$8W&~~s*Y|g1^s$}l-#fL-~G}$zy z-33P~II^Jan0(GHZG1bVD9W^T)d~?G$hXSj7ItRRK7t8N*-6kEK>z~bGTK*na7+@I z3ZRrEx(%xH#@Pi|AL|(fv!9~_uzDr*HCYPoGui{|Y$&ZOx>@>B%SlO16iU6oNn^>{ zmfzOLXVeoxW>4L=n`#C?#GtX#m)q`9*|vtZe6QWM-tA>`O26l#X^m2$%@S0Oid$+4 zg{{ExsB%>^60Ce_gbJ9_%cgrtm!M+v-8Ob;D3|^AQKj$HayI zHM%T>fWOSc3N7xGe$e^W7jF3`@j`rUa038$O8dF%5DTADuUJZbVs1Sc0qL3Ydu*-x z`}lEzbJu=)u?v1Ry=vU|^?b@Q1LahFgbU#p)8J#{Gxjt|?T!q#n%3|lw1 zloc30E+N8nZni81PB!Z}XQcS^EN*RcgEi-Y{X=MsgVnVMGh+$a<&V`!D%@Z68N7mD z4A%(&!>rn($sf$QDG^)OpCy|cOqXeI>QJ#Iab6wsyQn;yeCW11Bi4V;f`v=YG~v@U z9c~?y7CT}Q0N>@>ItRewf2zIh0d75ivq-Kxf{h@RqH z&2G0s-vpObc*Sz&!yX8oIET~Zdz(@^&S`DY_&Q$(o?Ai0T><3=lcuKWklpuz;s5NXlM6Enga`egXPuNjO*BRCL#>%_q?;+*VOLXQJ?U6}LO z+?ZgPdq^7Jm@jx!k-I=ZrpSMts}DtZ?0CQ~f!;YnyH4QPoo4DDVE>=H)`Wo;ndn_% zKH&B;+AN_bneD+30^!GD0fhxUlmWN9GNML0E;QHhqs?&$v4()*2zAQ(7<7|m&xA~z zQ4F8Mqj5aO1>G+$mAtba*t&wXA1@!tJWYNI*H?ZT3Vs`^pU}00gn%||z>h}A)?i#-;#kD zZ-eeHTAUQaGoa@kHu0ZyUAADp55!#{X``V?q_D6bl7Lwysak5WQ_GtQ-*0hKy3RDD zn+&>CuPTEKV09a+Wsc%;Dl$cqhV!|TikMnHA6&mh+j~ofgJ)NMwY0Q!ecA$+*0dZu zxdfCf6mE=6o>bbhF5<`^?Pk!Ocyk9<)-gFB3nNG%N}xj^Dhh!0IaFx4^0n@kBoFYF z#$Ae4TqEo)sfx1!2mNcR1Giz#xj2DQJLE3S{26&UcLs_xoh?_4I(!!9d!ER1p&X~X z4>;Nf^TRp8E|XO*-X=YK@w}LyZ*Ul#=I6qh8OgZqGRx?LQp=dLGk-z(oBGFtC`%0z zH;6Ydg%sWd2h)N%T+T$OXu~z8fON^dzNyfywJoMVU8zCh2JLoJSz}-mt&L_j07xJ0 zn*bu9Cp=KJZzjOmUvB%Bfj(or;Jy<#MQ)(`oM?X&!FO6nq^$bp z76|pP?VYy20CF=XgzPUlR#HI%!Sr;7bb!(L#;qoR-J$R^f{0 zBL|mF49qIh+SY`fwg2h|E8D+xdllLi6#q#8+u3X%EgR$tf)2yV5_x zD~%&9qW(1h@~y*H=nveiB5f0Myi2&)&A~boHOJU->{?XH4}g}$1UwUQk1ocsNOTzs zYec%i(;2aY3HR*!aBG3*2eCfJ2<0fnDYppR#uzT^<9->1VayLsM zB|XG5M;$bMHyw2X@1ro8v<~x^imJrzi-C4%$Cf3<1)k9|#D#u5ELco7RABi78=cw+o|9*$0Vf0B7cBf!6JOR zcvwutI!q*)?{K^-#BB(aQtYlHrDXf-V1iXa6KF=eBruVWwLL|Syo-WA=}J9fB5p|U zXrM$-?D(vt8aS@~RWv~90aJ8U)q@aSa_>)jTu{-kB5F%OF=yC2Ta5EF>{>PUixTt` z&t7lHdl6e>kosVcMmEEkJc~q|aQ)eUV@1OaG*Y zG{GG!a$<<03Ej0>6N|1*h}s%4h-0}DiPj1f)=iUj>o#Op*U^TfE8151tJl|oz>@Ex=V`L*AfGR}8vINxc) zMT!NuS(IiOd|^Ce_lMi)dT)a@Yr#PL!1eK>6FGH6_k4_UY)~y$@8Cj+CxD-r?d6hX zU>iGClOlLhd`OkG67Ww-K>X7bx>tNt$zJjMs5ImA4j5!C2H4@A1)D&0*?S+>u^;4S z43XAARL#o~u?dQ39C60OCEbfnD;YSKqT6N*nXW-p`IX1QkhJ0Ca7`ceLqCJoLQui$ zK)lG5ougG;tH5Bj3?_K&(UN~VZ#2(LW*m*O_2n8Xs3W=lBT5H@Z(rftqjn{;}$1^sc* ziyhPutqa$zGZ3&bXskilaf>(aR}jLh^B_1P*(R594Ps@oWjWIN13rPd9n%L1ffs@0 zPUjDJpa`2xQwCg;8{x2|q9&>Q?ErtVIpZr&lAHZ6N6EDs4)~<%wmJ$Qnrr-cfpjn} z_CBMGa-{VqeCk}pG7vu1zXVf5NlZ&9&7rqribn~|q{V|JRaJ16%p&h2H=SU&Uri*I zn3)*<;#IQPq+{gH-o^;x&%rzrjaS1;fm32`EEH;OHyM~mHP1%Jm3|uI_C7iYBO0hrZ-2QB7ilfzwajV4O$=*3-8mXJ zBGiYE9veIw_9WyDBYTk;El0u=SsX3sc{Ixh+KMA5{1SS|+u(Z@00XhqP=%y%?VtD5 z%zcUy2GS%?CyC>aAD;fH&=Stc(PU=lRFgIYq`Y26+f)6tIIY#m1`y~5YiqCu>!oTr zAjo&p`E)JUhbQsf)m=JM-I&Kjqk?nuREW``v(q3H+BH8Tw;)j6F!}hc(+ZopFPOvIexN zE_!k6$ke%Qw2Z_xhf$6~{3-@4ai<#x`@fb#x6&7G8QJ)jge^^AG>$=xZ7D0ceax?PZB%*xqw=Fgu~Zt63)qOxM~JlDy4EFhq@r@nDs z_Nc|dqfVb8`*)B77^A0VRRw0=TGw=gkS^L;`k7g%JtEKOs>#+tvTl?hO_(*o1PTcX zI6Zs`lZ}&7n1?k6>2RvsO#mSFdh=8iR-A=lH^30TnHrJC8m3hu9>YRO3az(=**U}_ zFXM0^$Sx04fZG(tYZK#-TWS2YHJ4EMy)?c|9xz64x>eS{VlITOLA#T}_6vg8_JnP9 zP9O3Ua}>}rgSIEk$6(zLdj+t$)CgVP83xKwr zEKy8097Adk7h8xXZCSEM6G0Fgy=7t+Rz-6x9BH=AOin+F5vZ`$J+tj?>dm1cS(TQa zy+BsoiL)(;uEI-eB;49>391>ere+@DhG|Z(?n-xh!>O4kG1Oq237{l7i*Z->0@%0o zZU<2RrEo5D78!`WCX%b@stBr@RL1F3#3>y`Y@P_RhOy(8_;QJHRL7e zEE!4;b)<8MEm2t*)4qlT>XA#Vk<{vl0PIu#X>yeOPy%MDLyqOa;azCYpbv$@TH6Dy zu;XDxwRV`&Kob`i>^J#F2NA}Gi&n4>R6#^bPg2OKQ=#+6Vp1T{Hqd5uX3N|PI%PbQ z(q;20dgDGFeEW#Bx;<=CcPciK&vQFOa)exq6OoH?OR*ib7~G=88vt z`ggLN4^K*V2TXXXzm2!0eOOZbhJMmZO{X&jKKH53pVa*&Z{>+U`EB=wx7R&%%+9O# z#6M}8_R-`+LsLJiy5-sP|MH8kEh;+g@P--3Tv|Wi2df^Q`Q^`Fz2NY5N1S)S!B6iv zYv?*HPtd%_nz!@)QBuxa^DZ{;q2?Vl@A2kcX5I_Udxd%1c5~kunOT7W**Up+`2~do ziv|_t2XgZU4b09cbTSKa24ofF7CHkm2Mx?G%F52k$P47;Wn~O3EGWv%9*`e!2Ib~C z19CD0`Gblw3JSAxvj%1sX6HKvxmkgMIRoICS2!SJP|?6ZzLS%km6w@YFt8w}s4ycd zZ-6r>kei*EpFOB3uOQ3GEzBI4lM%=tke`_w$jQzaFsLA}D64QFcDwdozW&1hx6A+k zbbk`}h|ct#u}eziY1T<~bwV8yde z8F!a)8)wRE)65S}_+rnj(!a=h!g0pW=rKQAo^AJQeml(DCSb>Jf8jP>U-h=>^anTp zf#h=Zm7XoPO}DS|u^w-3%Ke_Lk8RKMyVU1meRnzhho#mf>UIDpUtc%=dFtPFF@X5n zpf3mhUHr^9@Q5$&OXvx|Z+7WB%e*tqTVGCBzWFfmyKH`42F{ivSJUl!;q zx9+~e1CMLGT=V`gC7rjQ*LJt*wLX%ZPw)i|xA|DO)O6oXNw+UJo6fs~lIMs1;B9zu zAN8=||J`z>mjBwV$@T89ol@&l{G7(Oco#HoJC4U2cfd4AnQ?O$kH3Y+U93)Lg>eUs zyT!Q6jJwOYyNvq^<0eA$_ceVvsr9AkSFJ6= zd)cQNeztk9Fz<+Y*PC~PdAFGNTx|W3&E-8Ux=cHL$?O!NkjQ{=lU^-saZ`XbY8^z- zG-1%xT0a(=p6hTZ2v^=P$Q3cnG^gNXYsnldlD!^oQ+0qx2m4$LbKjyfZ*)TsM?Hq) z;hU3-|Ly;_VE}QuPO}(Cm&Q2}@8x)?`Tboy_uzQ}&nI~H1NeA6l_uKFA8NZHNPZSS z8O(?Hn~i5E9;UYq9-9t8zSraV<^U`}j(3~`!tqhDQ!)78l0JJb=YTYajKw;U)j6{ zXG>}vI}coYrsBay^S0%);iHx(u?=J2jro$Huq$=Z2H> z-BhFQ)OjZImgZY;-ZuWix7B~E=~wG-`AADoUNPm}Vcr&QLg~cP3AhxKWSSc(LG=jE z#!X;xx$=F&2`3y^GI9Kb1lZ^u)~?iIgIcJKIYvU|%`b(`o;S4y~J^4Vhiw*yYTKu;^~{vZ zlk@E>{=UN5@$-VIpUuCobo(lobCiER)%_@@wdFxA?@sfkA9=z(c*q~{M>qKdx^F#g zfb{ROlyOJifj=8ZUA_NS8?RKjq0bdcy0<>9?^%7o-D=?Kw<(-TnS19OG;ljjdWk;L zOD!RFANflypZa=#MJWzWwhMpueTB*Qwr8|_^EB8Ew{RaCxOvYioZU#Y{F!~PFmOXn zdf4ifpAEO~O$P36(=Jv4z=qp*z0KF8H@}bcwi>v%O?piR&aP+dd!vDyWZ)|MfV7#sO4csyVx3CYmod)h|Q%(cc@2eURtmEJz17+MyGH<({Vi=!U z=DqnHE${EmyL*Vz1KUn*fMZ(>JxtRZYu?3XeTE?U)#ESW-W{rNJI#BrfwTF}GjPNI zqWO+B@1Z_8CP=(z+s->!(_3QR!+mf}lXy?Kn@u{K%sc3VL$E`X8CmA@x@E5_u^lmf#y4k#^q`(n&Uw$m3|7YFy%|7-2{BFWncPc#Hd{`&{&+qn! z+xRxz#%EpqKfjwW)@|ea-So5R*);rae|#HmOQ~w zqV9{kFYCUt`#as=@BU%;jom-){#p0!-FJ51+x=koBi)a6Ki>W8?kBpR>i%8#)7{T> zKimC$_lw;xcfZ>GTK5~>ZwCGpcq{Pdz}ta$0)GkoHSliWy}*A3{uX#Y@b|z!0v`lE z-1=epM_WHC|9I=i<)3W*r2NyZpO$~N^|SJSZvAKZzqbCXeCN$O-`+Xm^T_8nfByF8 zBff}yaq|~%e=*|A$d@;N`SzD1c13nwz3c8>FYNks*Wlfgb}!l8y8G(gckg~-_ourD z@0qk`$)46dm+rZ4&ux1)@A>_n*Y~`?XV;#>p5Z-Xd#3fw?>W1tp{KKFL(dgG*Y<4e zxwU6g&;31HdY(E`pcO9~8 z*sg4vPN1*gDQILn-c&OE2gnc|FhMma&qQHljuld+-aaPm<8AIB4Ml(HA%qCbq^ zso`D!)%CZoce~!}`bXCXUGI1Oz3Z*6KX>iu`cv0my8hbrcGo*)pKbZ9?9(lumi=qX zzsml(<)39AZTYC|!z~|{eX`|~vX8fX?EK8R-MP{EvGbtwh;yfNuXC|;nRC8#k@J1$ zht8GGcbpfUmz`&w=bbm4H=S3V*PLHFPdJY`k2_C0&p1yxzq@tM{d+d-xpvRHdv@-5 za?dM!M(vrhCwI@#J@tFq_srX~Y|pL0f(^ikchUP#0ux5{OzFw(8QN3d)7~?$XIan2 zFLrzp{9?ry8^7G~W$?=tUvAvFV`p&Zik%xj-|>0y^A(>j+}*Ofc=!0-+jf7r`-P~Z%iWS!mbay-tZ2)ivO!x4%L=y)EF0*Y;Vg2_h1hH^ro>9;6laYS zcg}M#@5tVmy(#mG%nviSWsc7*&TPqCn7JwI zimVT_wq=daD$Z)jTA0Q49`Pg(5B3bnC z-;Tn5(OAbhYl7pPI@xg^fY9{LnXtPt&vDMH!o0rJamKB1oIk{HrUtr7D(yyv%rA93 z{(sHQYM={b-bQl^twA#jz47DH-s+VO&nTzZTb%!7*#Bn!sHXFs@i}Y9hKv63;Awf^ zJ9ukj&gGx3Y&q_hn)hzHCi26H8(u5A`Tp0}9roUfJ2t%f+;@+ee{bHyop+puDg82oBOc1_LnL0^0}F!x(e2AfViw>UQc?U^fHjIXY{@!7Ytrk(sk z;MCn04t#FaJ^8nMaqB(DHC%h=te2j8=(V!XH{bT>hF2!Go&DyVX9m9X`kB+8{rPR< zUmZEs`QvF_r@j2-knpxg@A>rZBfhfrt~0)O&4bSjy5-^fe|Uf9sN4+$LU+De_?r>$ z72NTS&gOCZ&97hf^FzarO)sgv_llXXugPBhTE^z!bJvb3e({5EUU6-2d*4Pvx{v`rH|G*{yls8G3EepB@^x@@pm28*{(g5czh-*)@Op^t4s0aQ)Zt zSH?##taPeB{`)oA4PU(_8$R(W{9@zEfp>I@I zlx#onlg{Tajn04J%Vps^7yRM0d#1KJn{Rq+{6jCyyyeYPUcTm)>5W^Tz4^;eUwVG! zd$HNOUTvB*cSGGTw%xyCd!i&z{?4IU$A;$T|Lm#Gfp1J(Jz(L_W@a8;TwL(TMZv0K8#2lHO2ec(rLhyPIY`5(`{_NiA#A9?MzO?Th=@)HM5zw6Ae54^kd#Iqm1 z?-vaZZV6s+|KIPu>(TEQzIAWb_n*6?^@NjO{I6fGeeU`LN4^%gV94u<{R?XT+KQ8=2j04TWkl$ZF{4i&I`Bj5HeD0>)Z`6OBaoC<;Wyj80TK%uz z)kV8jPi{E)ui2}b)*SM}o*lE<85k$uler%t|e-u7b#zB2!i{9pd_l&r}s zIs!8v|6s+Nr@vWu>j#%LO<4CxZ0@CZg?~5fg4)d+pKCs9@>}(bu3207`>c}-9(rI% z=8@w@4mkah6CeEbsDg*@ymI;7#{^d1b@oqsUjEgDXSUsQ$q!#0d+6chcmdzg<|D6F*?7GvNGF9=&F8$Ng{Je#{+TopQ*%g+I9L zxhn@g^5Q%9eeinc5pTX$@WOM?Uo`8j7e3l~*BkXs7i>TL=^>AN{j8A>{PRz1H#M(4 z`M#llS)RM0W#yor-=3IVdv-y_emy^oULL!>dgt>!tHN`hX&BP}R{q9+JU8&=B^LxL ze|1;Z3E`1-Kl#^?726h^9IJS3ZPScXRz7?C>&stywYK2RvJX#u<@m+7Z~p18fB4WJ zzxK?XC%@No&-mdVKm72;zk2Yu&(*M+)w~;j+TV4|#LI@^5{RS#rdYUm0=K$fHM%9&^mtlJOHJ z9y{r{$x}`!n>lNC`JA~Y&#O4))cFf47oN6g@siWeSa#;}vsQ$wX+feswsKWNW6Nq) z<|7d?zkh=+Qm5l2WOw|O6Q-UxZ8}_}xTy*}#ry4lz~BRi95nP`O?ucN!w)^|@L*E8 zOUJR~629L3owt5H{`dMNrN4eXRGgT@`oRZ&O+cBEFN^i2ZPt%1DIG@u(?sjF(CgPv zpK(&JEdDn=k~^--^xRT(opxNE_FPjl`YzGhwq|Ynx(-t(ROy&;wjaIs5yi8DHRHR> zZdv%76@P8X{rc!{pK`;hJ1%|f7tj9TPak|VVgKUH#Kc8M-m~cHS^tW^RDHr#LofL1 zUCVEJ`1$J|@A>49f36-edr~lvG59Z$Ct7bVzi`RQTTZ=a)P;H1{NtTxKD+JL-+FQJ zzR~&i{9m7aBVzDtvq1H#M09aYbp9s&m$ka@#d~)4taFyFVFl@`{f(H{nM}i_Kv^ZQ21=gW0fB@ z|Ea6^2Ip7f{~Qb~JgRJNOWleGF1YrpFK^m@*YwASKmWBqpZm!jnOE%p$&t@ZJZ{$D zMQf|ii2v6;zq{quYrc75(`QxhjD2z7uiu*V_=t^zzaFS z-wplsynh|~#I%>6ANld*Z)a~Bvb1*1ngi!fI%EE;jZYPQKJL9IzxUoZFMij-!|ob$ z<D|7=4VOaW6FCDlhP==w7-FXN?Wk2iP#Q#& ziYAqwYjb?2?{nYx@AdmW|2_9QuebNP&e?0c)>?a=ZC%#_n}}%XnDjj_Csn z#m2gE|7SH(XVO%a#;qNYue5KYX}5-ffd`y<^~av`#)?Q5tkPEWe^Ze^cF#ja4F2yc zqMl%y^`FzC>Hjm$`oE->oAqC%mYemj*RtvQX8re5%SdAdnk-fRteSnJ;YuV}R>r_V zzD=&v{bKk$J*X8AfP$pCTmRaBkS3i zjH|RE9;_~6!Du?j8a!VGHXfA?77VccywS(aP}n*Thf1Q1+!v8~Au>6I`^mjM8M*gJ z#LIj5bOXmg>%d9lp=Myv2xs2G0n?I$gr>uTzyhnugxMZ8=)(YkQ3OdhIq{X;5)Tx>R{mfRLVI^d`x`tSLBdn!grd3vj3HF=g(m(BsK_5X0B_-E@|+c()_#HcSr zJ>*0UPh6Ub4p=Ah>^US^=t)SSK^gfHRk?FGt_ z+=xR7n!Ai-Rv~So$EYKfJqa;hlCQ}vZ63G}r>JM;Pqh+~dRV|r3O0E1q z?Ae>=us?QHSzG%}k?gLTG#n5lrKHXjK9r2M;5=pEMq_Qr8XAS`*Lz_9Ap?gv5AHu? zkRas?d+-~xY${YtQ@8V%k^&FclDm;cgK4RBeGHmvJDE#XO+h*ZLGnBaBMvT-ERev#AB;;3>c|DJH|lAZ|az?Qt{!eg+_x-sjGr9 zqczyKfJIawIGTlS|1XCuqAp02@fk#djHPqi##>8ns9_i@m5$?sBhm<=YcPM7oG1J>)BgVY6o8icK>^v!$z4zra7Xx2R`{rit>;z9H2% z8VnxTrk~@f^(MtR%IEYAiQw`W?BPB;%_NQ z8jZ8=(KI}+R&+1w{(SpV`EnT@0T_9 zU3;~cfT4dK5K`}f4V#VYk126I4Pcs+CPOf~QrqW&iCEJ;0jk@4mw8bi8JNE$&o_-$Qc$)(M{-jmsgrIVIx#Sm!Sq|w zBpl5rZ(MdscASkfxmv}4&N7Zu8xw(=NOMNx1RK!g-^8ykVjb=u2c8g{rf|teZR6O2 z$pdcQ>e*syM3bp=(DQ(u^eNVVqzrR3On@-w zNN3VJ{&Cfx3H{}cuaJ2ve0;odZ!c*Inx-x_j0wpMALa}6G=#xo(Spg9E}55-uyuZPTQtTzt#95{cXaj2@-9gUq|GLDvJ zpkVN59Nz3X`G3s6O>2whePhk6;okJQg_>Q|EH?4nMNOP@NX^fi*sdM?Cq_eK?tw9l zyjw4!k$)~Pl=$@W{$C}wA3AoRCtNi(RyRh?hk)4Ur-S3flRro&b+iZ`qb#u|`kKP_{ z7BBANc|^xU>prcwZ}BO2d}!fJ6+6*gyT_LWRDbxklTxCZ3BnF<5a*A4}mM`&MD| zsx$ncvL-{L!R=J2zcm^e4nM2{Cq%$N@q=Gtp;O?_V{K2KazpXH#o|GQm73opxy-RfgT55F67`~jskB1@(EKle4<0a|GU}&L1XJQ z{rT_zbN>7Pod5nm=l`Go&yi*T4=2kG^8=jwpCuf7X`K%r?_C!=dr>A!UQF>o^b*T1 z`4tr1OsuM@FD|Ql-U`XvH!eOqZ-rw*+6}AJ#h6*qXcL<<;&xQs^wl0U{)*DIxSo%cI`)3ks|ITI*17q{wO8)MTrr12c42{U}Ute>`b{aa?&;cbA&n zVZY;QV@~>3O`L6c-eZ_UIjxPveejA8s9x-d6kV{AKh#V#U+Z3AoRm;yv#Y4g<&@F+ z441KW1zlHWrWjmLNou37ah3OVD)n9#P#0(tzkrm2qL^d2;vk1qef%8Mo_TW8V5fl#A^q51ZkcVZVYZ*~(en z^^2+TE+w+<*~yyE(i1JZUd#~pu%?l`x3XqjtOSz;ko*Y_S*Vher-;a^z@1U zF(EeS*_SxCzDIp+ou^ppcN*kiruC_i7;`Ae7mq3rigT)oS2fgDzB*O(t6^4h$=%@@ z#aHW{6B7z_lQ&M67aklEl(~CMYQj*1tkiCo>+|%N6la?tLXFZmyw2yETiK-L#zj*` znz6MlY&>3{i3&e6*CY1+s8Z+kI+czq&gW_DT(H2huw$afWUhdnkXjWxvaBqe?Tk2@ zE90G8ZFaQm@z_dZgqcR_F~TV!V^u)*vYSNS>UQVr9#eHS=hkKx)!a=f`%+z~o4q^9 z>S$QG(`JVnhlTIr!mjM|jk+CaDSYeW;8RiITppaEdwx!!yh`3JsCL}T+T0d9in1(2 zk{9%|%Si8;pMCzt_w@2#u2*aC&HPn$qcALM?k_fX!wCKK+&L}__U71H_5NtCJE*^p zL+6-SC*8vpQNEu`!Z7CqpBb^aLZGa)zPNQ|#jUG(SHCAMD1AEGEaiZqP12D|Q5jp7 zdK4`15o}uOhP!k;=VtD-(Ae1CGZhJGnI(@uT_2~IR~#_5%Xyc1Vx3LumQ3SAk5bI{ zSZc^$vQEg)4FLhA_ldac?U4#UGQJ*N=U6)Pj@8wGHi=1&ctOg*`(_YRtDMbTvvl=sCdzH~dIh$FWxW!Z^}!nQw4GL76467Ax1liiNlmPCCsFAg2*Q|UP)_7|5I7WAl&jXytF zpLjpb#rNyMZ2kNX>1JC8Ty;x~{$;yH8vlbQ7HLM@S>C@uTZhhT1Ma4R~vy!wH zwnMb@u{Oplhu&;`Z{d2QiW)_$@!vb@6Kn44891gH3?IcCMs2sV8g=b%deujMBHcO8qK?6vru7uw;{r$J`FQ@^&^Wp~gtd2EbHTXvYaO}~b=Ggjoc8~0*H z`=>tRTuOVd9I|5d<)O#E8M+R8@8xE=V9^NN_4KeHw8e0`z33b{d-GuDvkwMoW?2ke zaEfv|ba!39*I~E&Kh`uIugAw+1R+AmiPCL|li3VC$_+yCJb_^4b_`-Ai&LhQeg1jUjEpbYSo?6T|v)J zj30lzWw+p@(5E5R#ihROx0?IOx)5XHrY4X68CZ@K>s!fIA7#hxe4IKib>lgo10Qro zeUZ6)pRt|q<<$zh(To=^qwQ*1TfcZurfqxcU#EKa;#uFS+e_Y6CpzzabAk_j z{UN{2uZy>C{!9yB-;kxF_}$y2W4+~!`#(I-rG1~8&42T))~KD6Q1r=e_<|3nl+VYt z9{P3Ldli4KUzhat+Hd5GN|;_o4L*L~c;OA~}@hV9b z{TR0H?6�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 z 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≫HM?E>7DRo-S_2hYG)LC^-omV4jR9#RP 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 L&K#4hv-As2t7^;TRbXd*&YVDtG0)>D#pvdJG8% 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�`c-in8(SMDj{8O_Qrfnjrez*v-w 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�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 Pf7IvBR_`pH(BXdou##$X literal 0 HcmV?d00001 diff --git a/python/python36.zip b/python/python36.zip new file mode 100644 index 0000000000000000000000000000000000000000..481cb58faef2311b889bacf9cb9ead3f2e483686 GIT binary patch literal 2238731 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%0D}2wFQO1EJ=;z2uil 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

b4o$xXKsZ#KkpOAWEZt~F0T#AU$Pu#VhXhoE z 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

    HrP^&|>3Ibw>%RlFs4h%-CH?j`$F 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

    Qqvc3> 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

    skTA)E0UEY-$*Qx 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�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 z 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±N+0y> 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�@GF&eZT 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

    &}{7ofwq;9R$YJIDXk%;@a9ZS^J9)fX<% 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�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

    N!_|QKB_9^*`r1aRHKm^P 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
    hC`rx5wlO5Z0DjuIlnCiICfVSecT(}iHL7QL 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 z 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 qht^p{zOmO| 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 z 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

    2-i0oin%9#_N2EiL6q! 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

    F}hu{I*$}OpJZb))@WWf(z$$>c$JYX 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

    v*c~%`d=O_NK9PUNN18=E1i~Q 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 z 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

    QMNzKA57R& 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%0AkD8J>JBlH-_hZ}M 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�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 literal 0 HcmV?d00001 diff --git a/python/vcruntime140.dll b/python/vcruntime140.dll new file mode 100644 index 0000000000000000000000000000000000000000..1ea25774238a7c37615d3270365955566c09009d GIT binary patch literal 89752 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%0DPxQgZwJD(eBnT{jdU->;mf~z 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ⅅ(m|XOF_4MM~uyz=c*Fb=wXQug2X^G$k zUT^x9TZ;QB%QG;@eTLxyUG|st&~hQ~<70J=nNumg5!@^ygnHI}@DnY|f7dK9%g}X0 zvXm=u1cePk1})D~Q6Uq4obciIy-BlBK^VT+ekvp1JeJrYs&d zFn z;MgTfsLe$fG{|qLkx70SF90Hru`OfbhZ~TwfClHIhE-c4EK%#_l)a&pdIx{# z6~DXiyIa&L`d`U@(Si@+=@6G05b5Zm$Lp~WE-=6c?iMM_ySd=~iI^K29LskqWkbQF z41tKAtw^`c!3Wcpgh)SRB;F9cK&A2Uhb~w~+yA2fCI6>X4J~119PavV>Y+OQxeyMP zx8dh>0)ymT>AWqb^MOJ0I7~F;WT*$r&iTTB;XWjKm%LuTy*Z%-L-k3Baxm-c2Z1g& zhk#yDO=x4e{m~3+zH8KQR{6Pbcvc9@!|mVAb7h3|2ZzF_Dh<)dIdFK`4MuG&f`u1v z>qY{BIrt*FRM{Lqmmrwle6xO{T*?RhhX|PkZNZuJIRw8SbH*I~jGG;=9t8~^gxErR zAp8>LUlRldW4!B(_|Qmv?XUy1J^*PFZ2>np-#hC8^g>BBp-J>DRQ<>nA$rF7xo8gj zUp^>(cTe+Dh(sd%p()rdpeX29&D?8m_vb+vaY9GXVYK-oP>^Ap)kXf-MS3hNs!y&z za|04ekTo@W#noB#uLVFX^qmiDvPTIx+?@~92H_;4Xk1$ZZR>FX;vRrJ)xO z=C7STG=m;eAtRy#S}^=C8ZIglk>9$*@~81o|Cmi+22c1yGYF^tW%!pZ-n6dX6$$7x z_(S&~8yLc1G5lZX2aM0U>R`SRA3&WDjQ9OQll@))u_S$_Og~sc4352SpoVKy&cf+y z-_NSu2NF7lBc^oC!v7_H;!yV`HZVX5)Kus?p6#W`+{c>!d#q0WzsVSuDHJmYhW3Li z{Dl09E+0*YF}Z%f5Q#-)wyws*6x=#SiMr%i1TSyQc|+=tSacWH*i%ojk|0%zK-NXq zQ^z=#VKV(=rFKh7x8i*0A@aBjx}GxT1hU_+QXz}raHZ8n-Ywh*^KggqxhH;HAkKP7 z!RW|K;KO90{lQFRh3giNPpmoE-WLAQrhBl6md2d`%b>6r`dhZSi**Rsr%KV~M!L+-aJ=Jpbiis$S4=YBvzfj@L1yH${u>R(~=p8u)|{E7|^ zxm|^xy8QsAzmIFc>Lkp?|NC`tEJxp)*Y;Wqh>%O5qNv`rt)NSUynu^&;O?u|>7oP} zn(wTqc6RgC^x0sE2}`t<>ghIC;N_u;)MPxH=#!ECF_$Zy;$9z$hkk~`H1+@bI`^Qc zuPcs&f+lLUFiAAg04r39Se}WGAV@**5rYQtQ3&D!i!$9;SzZPj*!YH06w~QwbVNl) zDkW;&+oT0KWF@d&zyViIp@C5p$glR z%EFMcmUW(A)H;V6FmFLZI*G#K^s=BtoC&fD%kZ5QxDuvtf0ne3BeUgcGS{%(j=tR| zvQPZXOX`sC;nfji6rzpD>&q#>Pf<5g3r)my}{YHKjkmCQ3%sH5VO@wq5^hO;ELakxD-8$je;oFy9nhU4ijX3dS z%&9eha*736eJN3t5x|`{jnuniCXD#~4J^P#ITPyLkst9qxn1EavCUUs!ZN-AqYn)^ z@y#3wsg*OBddec?eA^h8l>u$(p)K0T##;)gL`-+s*BO`cB47MFc;a#H6q{9uXlVLI ziKkh+7UNnfdz*9LgUtg@2-J>PRbv`p`_-CDZYwdZX(ZUmnp^sN6chqPu*;Wv^NFE*OP zFkATxdW5<}|7dr{@l7HYa9(eE?LQjBXzW`8Mol=~odabW#a;nN+HJ0wKN8OMM|`w- z6MZ<6(qNZ#qF}h#`}q-$O1BqRPj?^810qtQ_#p{CF6iR6FTXwi*tO?wCm06wB%P|~ z`BF}13ZLuz%`@d)Es&%N6uRgs3LpfzqgH2K*Ca>$@y}uIRD>--1c1`9e1@8j8iGRa zK!gXNNS2SU5Q0LMo1XsAjSXPz2ZK%{J7!Xb<@iI*=bB%5^7^VgP((%$YISY12}N(v zTQ})sK;Ql8w|j(A2Jlg>ZVV-Uv=MkERx^)tdG%nys z$cDzon=e03KK;Bi7-C{T+E?*9$I;{@YwU|*i?;o9!>)&m(5{{6K^i0aV|Wsu;$}u= z&w^YqL`4G{w{n-uapW@K9m~HMPz^0@##l*NfxqTiX&Iu-I2TWU7&&I`MaUI_5r}GP z(rS(cnV5orLQ@Z;UiEkkD_8>>U66Vuu_Q=@TMB&Av#j1TH;)1)?463WCWVJtvdA%~ z!1c9Hm!1IWFi6yE7Nv3|q_#}XPGKL++h1I~Q#C;!1dfmj5EO+8KQ}7+LBwdH5?ZjpgZQh*q@+5Ye zbn2-`Zj+&O`%${vtbk(AMx0&d2CL9{^I=yseui&gS$bn88x-{6S09QSw;t$1s;NDj zc#yar$7$;PziKACKpf$OGOj_oif@bllWg-n%0cg~5DvMYe#A56C3NLI7 zQH7U7v`U!7R1*10{-6j;v|g5EyR&Y?+z$%To#J&c4T3p1Z@}Evaw%j)H7Yp7r@xJ z;+{c|7Up5ck&a=SV;oMd7`W)dQzs98E<_VAt7(K7SI@C{G{QT}#wK4T*XN>``xhdPZ%ON#2zfz@apHTA9MEEMydGd%LjVVysse`b(%*Pd6bbo1PgMTo@9oKCZqFIBqDfR<~Yb6n>c9d++g7l z7~Ql1Vi_TpC&6`HVR5MNnxam}t!O0t=79b`{BHa`z{F!as(4UvN@T?FD;Gmzzif0bBD>Kk)L(4Agu5$DLQ3p!d!UAH6a*+ zsq6%MsfXop^$CS1#(BN>5?p-d+wg_>_-pOL>rWl@&% zW{#AxeccvIP8bMAgP&_ZM?#qv%Z5A0n&NwGg(DhQU^o9O8{k+uC_uyS08GDH;~5OQ zIu5BkNFR3K|MsJNj;JN7l`Az>9PyjF2_T85eRQmk9nR5EYmjT+{kHGBV<3zcA9d=3 zBcvFmRrukOh`G}cV}dc>(Cv+1jvV3`k;phuT&vCEWXTxSq!U>=t1<7OV|&q9DI+Bv zWhq$qt$Vrq1yRO9yn3OE*)d*95tpRJy>@0@bHL|Fj6d|-1^rURq`OHmN&|7=haFqR zL&ZK!HRvA4b(NGOd-)+?ed3EoY>BS%l4{r6+YSO9a}6pxR#DuH20ef_G#-PJSG1qM-v+=rlii5+U1gTS$r4IeQCI?R%M7c(p$39Enf2K1AdO8O^ zQTJR~JVeoM8il9|yf#K9_Fyb?%@Hw1#Vnr`h??07h!D(xgI!b`Ale z@n9)Rb{FJweq?(*2EnAMQXzCVhZx38tyV^e2*)$eMqsznB}ghn|93+G+}=>o<|pxf z_iv&0 z9Xcsy>_i45*Dja*`hsZaW*t6iDi;3y4p(*243Xr-33CPNe%_m(fGFI@ z$;vC+)qzN~4X)#9Q>ECSA6KMe4&IW)!CN9O@oWx<+vk<9e# zch>+SkbfTF!-w;H7wT$j)0p&E?=CXomfCsvhMC^)?tBETQSafJ~-2VvCpn)rWry^K6I) z>L4H>s0}g@7Jd4ll7i1XBhyB(m09O+iw$rPK!TJ5kW>tD{y6Hg07Qg z48|ylZL|VcRxQ}e4l@gsnXe-cZ82*2a)^YMA_%35dJn~`A%cpjGfNO84+AW*?9_H1 z1c@podQh*xAjHM0R#0dL{M@k6pAh-9iV3#oEy5 z5kyeN5~aQb93*p6`Os7%KZ2-~G7YWB<3`oPfT%a~=ucpM^9H;lL(K$~$tP36Oy@#5 z>H(%$C@j;<5Mt3iI`owp`Y|Dr zSn6gND{&tw{9>vI5;=t-@y#=N0#kG~X;&rZj0%FFF2co&7-E^8kpe*73)O@De9vM2 zMtb|_8QA9;eux8uEHG4Z7C~uLseT^)Tnw|uxEksga5Z%d)tT}U7pZ{|C2-)Y-{u=& zC62NNN2#HvgS|#7r3UeP*;J|-_0*b0{K6>zG}9^~500{g`WxEe!guodC}Hpwg46wo}(65ym`~R3N5At=Ab$o;aTG&I4O}dz zF3fDWcodH;<$?4&V8Bs0rBQM$=he;goce$#Lrx{9FHq20D>*#?L%T>N=Lr_}91K8k z$4b$Go42n8^bsDN(AJc6vkg)RUkdYNrfne*m=$?37{I`5o1d!l{Rn zV>us!0+pOsAfC7F9ANXdU1wnn>Y}z?02;+oQVAC;jDe&DEYs9I&}Q?xnZ_DQip5$= z3jW#_kNE#oQlF*dYmh^2MU7%L#v@dzMU7!FujF+U#BweH_DaqXShD7o><0{0GBQLG zhnx_^0o;p_cq$Dc$s#X1!3Uyoj4IFxtpvv?jpeL?a*NHWfHar`Z7hs|!dSF$KUxk8 z+z_MXwgL2$Kxq_HpqEjqVP=Sff~G**YeL~D#l>>G?tcyLFob?c)q|18YCv>e!lLt% zKJ;aVh#71xaFhZXRDz4Ql-!G>)WU#gh{&UKXhmgQq>H2mO~|NJGsQAQ23Mit>?DssZTfh$zvx>W_^Y;dX7&@bHWdccgI4K?qr78?6rnj# z-?qQ%JA&5d_*Z?e(E5CSt&a@F7?qI>wvb268XatzeU!qvP8L<WS*s0`na>Y{Q=!I0}xZpA!cP2&7 z7j(>K3L*-^czA)1Uhqe+C*)IqG93YH$~r(6+xm%>?yUo4ejg+7j58MsM^_i1!(70y zB8D>^($qMZ2&vbAjpYSl>Y4cjFZe7T(Eh$SSfXHYVfHK3W-A=!2RZ~PpJ2HcIQ<96 zqb`}(Q7*cLBn^75MMW3Q(@@_A0S$}NGMF^z6#Z^Eiip}K1Tl%MVo=KG`*Vk$T-8I2 zNqv>6O1WvQQ3nL7fFKhNj|vEy4GS#iEQ6WrU-Opp=K+0zCx?kI=Pv??x_2)apl@H1 z2Ll43HbBn=*P{JU%#>2b>cX5E-3$gP5a-PK1rV5!t}($eg#lMC)87t_ zAN_&Z-Gn29B#}_mIegH$xd5^;`??tF=lM2^`$T;L&7<-GM#_??77{n^v`GGM%%+Cs znCA)CX$J}t_ld|6^?|eu_C_C}n*n$afZ18mmYe4Vk5@>d9{B_lg^Gwj6lBgWuW^yn z3=$u@XIg^}DFGa%9vaLV@~LyE0@cx_I03^Nm|<8w0VD;2Byb;7lF_e{cuXi&z0FY2 zgi;4`q#?KW86;U_-y2w15vJZG?o%LSY%mDow*aFcbAynrTQ7}zssz~|^7f`&q8 z!{>PqLrle+av-7s7td(~^olv*MbJ+Vu0=5s1u%*~50#h15OSB0XB8Nd{Bn`Gskb?sjeO$cJu)rno2JAG@ zN_o*rVeQpth;RW4Gcw=LmNlgtI6q3GvXdq2z%{st7pS-FnR8sk4^$0QE7038e)|!s zJE{hnVu(z`3GAn#q#fotA212z!X`q%s0_-ZWte?qe!XFc90X1{Wq`++<6ZsFwQ}^= zwX*BawUYEP@_7`9S$3i}@;SQAKo*uO=tI1agg&JSQs>7Jj)IBMaQ5@;AgzrI5aS@N zq~Nge5gpSW-y>;kCj=s<5dCWyA~)<)&;^ug1~x3LSwu-e=5mFLUst{oHBGGmKtCLu zv~bZ3BFqG}RClNkR;kDe9-LO2Z#Qd|BBGo77g%(2#9IFr$vQPJE9_rnp?6RJu`GsE zFKQSnQxF#$A}O{o8AKAOF#o8)83Bu(KL`q>8B)qBIr$-pc7ccyX9F`sL&|GI$_Imp z5rP-d-5_Gr-HTvi5HajUBzPDtsWYUs7*aUV}ch+ zrJ6!BT=IcAs0GqujfM>=)rPTVG)h&h{dlYu-3X@a{kTZ}J8&vx7(`ZaNDb>T1Po!0 z0Es%KTo{BXqvOcMh7dRC_@H1l=ff#FBa(*oUxS177X1&rEO4vBZwVB~KuJ85G=jx) zRYWHuFpM^qfFlB1E)Wj629S#$xsh0_4p8Kq7A-_lrJAW4s*xEDl!~>d3gmb3G9|J> z8Gh6{f&5NkKd(y8VL14}G6!4yKEPn=WoE7Mvp_l4`k8_-OdYQ5D;Bq;4i{@B2(zi6 zB$qZ9Ntwb~2qhw`cq%zF0fA0~{4}CsV>$0YiYOFWg{|bg04OJ_9p^c~(4L_Iy^Inv zzj;9i5jtPRKpynp3g%o#;pc_ZJS?k&Fs}i#)@w8iU51$-L+UY{yBJc1%=iH_4uAtE zL+U6qwqwS7m~j;|SDA@RGGi`g%)^ZNn6W7{KERB9nDIRS8)n&e%-Dw++c0B8CXWI$ zzRINdGGih$KEaFwm~lBX4q?WF%(w~;V+^T$W_+I+-(<$;nDI$wOk~Ec%=jQP-o=cy znei279K(z+Fyl+icqPPd-k@v7-^2Vae8GDQ@UQzVMu)x?x*x?+`e2$sj}ko8XK<=K zH@}3vfm~*eN_B(=v}CEkr7}txG#oVQ{}UgV-n^REb?0Fe3m#>`JuIlnf}2>7hXsG= z%$NJfg2gO&j|E?|_#U!g2Mdm~;DVE4H0QBW7EEQqg?usX1#BL&{Vly(>(_i2R{kj# zOk=@f7Tm>x-&pW9t9%0sy0Tyl3tnQuoh+!pf=#UQe5^E$rFS0-eqq5;ofSn0>C`~|wt-~4ia1F{ay!)~013w%n;e@!pYT?ASD|B%1H_fJq?f4+PN z3!;1rZzt$HiFPMd6$oq4oWJsx0**c@5FwBFw>%h}NH`RZfxH-29*~&dr3K`_8!pm+ zvFOq*^Y&G-;Nmwetxi9`W|_hu4n7^AgcUV>TSXwGfPVSel}5DT1)mWxmBodU~Op zf*TP8Hd}wvB$bp937~ELlNP{y-zWtI6x`9b6iGF-9N58pno&?va&~n?kUB{7pk;RK zhtu*71C;0E-)JbY<5!vu%18Z$X2L8x{5Kj(r2UPy11+q)xLy;cJf2@@dztbCf2A?` z#D1Y!GWoDT12?hkuw?Qn0gVF#G}hY`+W*kA>3mu;C@9F~Ft`BW0jDv2;7fFtG%=X3 z_ZOPYe7%clmh*hrUug4uGC*rU>kXKH!$RNgQc>OJ+X1vfkYtVde$S$TW^i@^+M@P? z+kSYj(u9o)Z0A{gAQ?V==09ZNElnTNG+1O54*U6`*$Z!j3vXzMBg_Lpo_{No3Nd=8GAYZ!M=KC!A4VZd#@;_=F38})AUtRt%Q49E!vGiPycmQRO*3Wl zBYeJGJ{TSjgvXb|husnM`@1fzG%s3S0>%MLkKL;gqzQsPj3pFe*f0p&-bM8+$oV_u z=Ro*X`4E0zuDuvx9z@s$f+aU1tjdK5D+~Jkspo>e|5eD8%ZuiwMyE-S@xym3goHzq()PVBZ^vH*<3LLgtr5m8}Xc9v541J)MY02)>}rDg^KB?d9t3M)D=#{oP#%c&2DX4FTQU ziSAAw?m?^!g4YRmUvDo@I7TCgB7%1V*~}9D?p~f?KM3;l1S`P~F9N!rGbMmBo{0Ki zIG%u5A%p;Tkg*W~H36}l*V7gKB@KeC1dZnNMF5-U&_VFN1UGOGSVlbJOK^fpyq%pq zP&4sP@Iw!GA|8?+hn<{{F+D$T(>yDalYq)az2Qah$1^L!%zF=2npv;jFaATDP;9Yp zyqtV}z5Q98KxAOB|Ud-@!2}cM{KELF@;Mh;}*x}?ugub`K z8}4J^_c}Ew&D7ib7|CZR%O^%&MBhLJ`GDpeaQ7vWoII?&z%UmCxzB0kH9xRii~^hq zKBxlj1OW?p06>G)U=!em09zqY zL7xtQ9B`i@26PlELXZJm31Aq64&ZqXuol8c!0P~pz-2%T@H7A%f^Z3N;dKadXg$o| zfZGAQ3LzQrWPs@X^liWqxKY=DPzX2*PeOPBcoe{Q5E=mg2=FGHf4%_@_eIPz7!7dr zJ^?)kg@X<#JP3gY=>Plu&-VcO_J-cS!Ei^6ARLE)HvJM-0Pw%x|2H1sK-j@nC724} zK?X?$i1v%;0AU(L>Hq>*^esiu{Qx{YhogH1NQ9&1#Q?%p76O+=;hX?*0MVB-M}X*C zTmV4y9_}1K^fC4>K(rs00z~`WM}X*k@i0IDi@y2yKOVM!PsjcPUE|--;m3N&UZ&EE z#Df7S-SHpjKL0?UH~wGcocjm<)PJBq{0DmJKhW#`f!^^C^x=P?GaG%e`Yb;PqK)~> zH}4t) zS?-kAkihy8;ZWh^0Y_9Fi9mv%gq|)xpSF{qAHnmmM<5mic=_o_kbJ!~{hW^wJe~aH zJ>8vsz5TphiSlsZ)^zgoR5-Ck0t<&GcUQRmIIy@j5QW8R6Mad3MD#54UzDaI!7K+Q z{owfQ>rM=0rGes0I8K6E2rhel-A};j%8lUnXXfH;Bj(8)%r+&QAb4Os&{#*p$gjOD{i?kB_%6*baZHWa6SD5lm24+OkDeO>}@^ ztg5P{tgPm`O~vUymZ0jS?5eCmP?1+tIlN6?RaJG1{9&hU&hjo>x4Eb~sXA>XsA&Ah z61KQ*Rp08YzExgBiLgapRas@5{5G}2hvhX?T$Eh5x+u9gssASuGzdzr>P}mfKT&Ae67`d66} zy3q9q+KRtOTMdMV`V?cpbZ&Iteh`*WV!s-T4aCxQO49y&z5 zeGPn_kGK;F&ghkmj>K<}LpluOV>cnt5=JvjZCll#%WPHMqN?ib?7GFpRRZhbRrW( z?$0?!pDqw;(g?dQ$?TIfIxnZ-KO**K>2zhsvO)Uy$(gqZMGE;!e%HAQQ9-yqv{eqZ z%@pJk8MBi+1fzOiteW8GIjN*+h~X(0-pHpf_=ng&s~G<;B&Fp6qZ~Mz$%dsusJC2wq!7oq zQR3&sz+Y;pzut5ln=8@v(ac#ZwiQjE=_qHMEm-z-o&P#J3n}at#DF@Qzpj6zz0LRh z2z^Iw^T=HA%`G<*KFiyUJq~n!%D5N(+p^>%tJ=e6CX$|F^wtYKpPe>)-rsqVlWevH zT7d1=fupzHXCN`0pEE2kHjmNTRy=%X%at0&h!8ry;aqINdfnJhaktDSin<;|KJWS- z{X3r?a%r%HF=rJT?!mPp>iveK2o3|W`PRO#$u(RrJ^1t{qsmzK@#k#8sElrB@tK3~ zM274ed$RMmA3lBhv(I6n_B)`B#C}*(9`N}4 zq3{~Tl8~&D?SfI5<@KBYFZ9y?THimWE9#i@qrD`oA@||YkoMC(fz{_rirs2&E^oW0 zG;pSfyJKeVg}4dTsEqxBUs>4zfJuGOL0)m6ojxIcRJpTer^I+MoM9P*w;GpW z5Vz}|a0N%I<7L0}TEQ+o3ft${BzLRt$`-xg6IUd9(op_`tNs{Hv2pKwd1uqv;(*na z*4vX0{ygsS=xpMe-cdl6sC$JmU|TdMWxfE^E#7Txd_+3b0{mw1u2}$Up~$HfsTK*DmNW0D9SjyO$S&p?3T|zDeqv@SdTz~|+8}*P<6DH{%HuGj_>e+$$O^Ii3zN2G3DhMQ_VV&@acGKG5R8)i%;^Q?Y zs_tjf-TY-XSqFKa+M1YDshqJT;!!)l%o%}6@)!?!&|KUkN}QValc3&yot`1Fx;jLP82Ik(|phL6&OO~*`zzIfSX1L?Tvwr@Y{bBLQ)k2H50l6`Ndip!on zBU+a;E#l3Ub%KL-H~3$^;t6} zyyrO6D<$b$pK}XxVeajbo}9km)SAsTdw~?TTaj+nY|t{4&yaG_##G8mw~xIXS}S*( zW7FFu=ul!Du^kXB8O!Cq(4&3B_~g6j^TJVmBGe9p9VW<1CL|x&@{)bRn@UC=garuC z6q7y%WnYYP!EngoX-!)Yof`9#*+FbCS{!oLHGAs`w5Y#jLzdk*SjLzgJgz-V8!=oy zysPA1eYM%-C*Rqq{6TZ08QI2Wep(K_ZAEJ1*}5Y+!6{vrF817HFU?FFsBANiK^$^U zwa?XLfBk-A$${PY%oCf^w(1LqJARA3m42M~=q6v^`9|x6M6XXVc=~y3N6H2Dk|XtN z9sC+y3xg+Dkf&4eVUpG0uyn}cn zg3p4ZR$=Q%2KUX_&R>x}=^F zxm^3xo}w@^4>~+3`H}xBM(_74Qx}3$ZqMas=-Nz5zbBu4wYNUMWFU8cxp~NFapnC< zHCdQ$&x8yG=*0GA?nYoDp?^&%OsngW_qf}+G1q~&GGW3ray>ss-(m#YYUZWk) zOzbi@V#w{;#S1O4pG|UDB>Q?{Q?H?{(Zdf%I{gH6tf>A8DliRhG+xT)jsS#|E#@yhxtuvk6VHiI#D;AKh5SN zWz0x_96I)@STDHd)uFC!He>yEVGbQTj8_CX44gi@tsOqgEzii>nlNk>2}>_xZlp&8AddzlZE^D}l&c$^o= z{w%j`ndUy1)-%qBpWV+ER2}H=8IB2)i`hG(+QYvl#L}s!c3pb%b6S2XzQy}@%UyD1 zd!)-R8jH^KZBX)prCMp(6Z)&}yFz5_%AW=r$IA!HFJOJGlQ~jehnU}ZWZX+yYin0s z_?<)EIltDjEBngi0sHjH=ND${PbB;HiHEfckB`~LpXm^~bAes&>K9jRDThq>zS`k6 zxf@fhx$Jm_t$3u(Z>rwB<(jN-zTBrwdc8LBUY-B(V!EMX5iZ64_J>-VE`0p%;2Tx7 z-)6d!)Z5L4qcf`X^5(L3w#v};?@L}e@Jg@Q+Zpx(8VB2sYkj_gk)+?-e^CC0%qAi`7;x;QAm%=w~<+i`ag!hH|eR{oqd!)mh z^TX^zBI+84`cINS$LKxQnmJOL64!O<{mvj>eFMFVGhq*S^pr5@-evIldaD}q2)zfA z2iWuIn>wY7i5)WJiR==>?EO3W2?Dbti6d2=iOBeCPg1XLsx(digunRd?3u+R3_PjQ|Z%O z%_Zd?jFa+sT$cM|-+2C2zkG6yEls^iq#v;7A)X(BzPv*l*rM zx4*D1?CI8_Amk5z-M+TD!tfL`TI92YcTr39;CS`$oO*$|C)Its_5S3L(_N%B-Y-sO zC3OgKBf%nJN1X(`yUZ9wAODoN(EFFkD|6ek0%S;R&({@$izMLG<67Ru5(Ts5w+4JF~El0V}Z^lIR{=R=?MK(73 zq9U(W-o!Jf^-|tV8l|^H469d!vyq?W&nfX-AnEBeXEAo~sTP~ay~AHUYP^pp_iHRS zHn~6}&gW?h*?VkH1evV8Q(v~Yp~qjI{G|BH+o?%yj1@1kise!`pkb;FUF>MaTB4jzu}>H-tHPO9z3tfywm1k*h+dRRSb&w;|*_v&O5_bHHk zb;28;aTW|bYw`J3wS291fM8{UIKI)XSCCUFLgRtDrBm~xhrgd{!TU{JCmWa0TQ}A^ zw%6G_xz=oZ)TM~_xZEGhexvLEm=@aCz^{6x=GY+Si*Jp5b=NK9gs+b( z*H;vW&iK%2Be%ahtHrQg#lAb$k)T2r+|*r!?9b4}7G$Szln9YvbFsBEAx-eC#U5>B zdM<5!snVx>lH4<|);L?QJkA8&X_>*io|{%-f5?RMI(p zjJsdzt9NVAY7eRvoERv7U|)cwKJjiZjxZK95%f8e(Rg&na`MsPzz3<%#w2K1f%R{m zaL&fb2!-d(woY1p8Cia#D0p(2UHazrrB^>>cjSKFP)w#u-qgxDDV>l~w)?H1q5^61 zeXg_m1W~2@)GBT{^7POh;m_NZp>6FMha*!l}75TUU0Ko0LDiPvpq9AmeFs4IgSA5sj32 z^$wAPOotr_S~26hu=m(2!+1N|ZQGEj^e4^tvJ=%`RDRf0T7=wn;IhPf6^6ZQD+=Zw zYqgL|dc~ z-SWYA#hSYwAv^Dk7tej)ow1%=_$D!(hIFW|`4l?+hL1Anza)P1Dz@Um9$5U7eYeR@ z?-PlTZ?#q+3GO`9E%-Fl(vEw;YvswaF@3Fv!l~<%^kdo_%S!9i_lDlMnYf32pfdcG zZmK2wy=>%YHdo=mt6(lJ3$`@mRZQB+FgSw2p@L^_wBPtbGtnY=Tj3+)o5L5?ay*BB z=he-hMMCg;qGWpufmZ4ROLB@$pzIz6h6CxCce>E;mcIAPQxXT|HtK(r{oO7uyK8&x zWqo?Z$K=Snw!@YV+(gxr_-&Y#v!97xEs&ZG<(vI2V&qVj>9$KXwOxa= zwH-TBf@GxVi1Nk)jic7$LLs(_m#02IXw=~fnwhq$Ns%4P(ioXqalxy2g#XD+@{J!q zbV_>BKyn=>4_HyZtXPh2BjSpI#p0sagT^_f7Pk@$pxyx*zTgv19?^mX- zPfzXpq|n}+?KgvIdY5@|U^3BTi~v0y7wGQY;(aGBRC8aY41FYQNs-67JJJnocg{5S z7+zQI8P)8j@UuA>4r8!KD;adRh?nhaufs7_>2Tb^IrOk`T6aRQIJnTwidMR3Vw=tZ z+d$Ff|NjTU_G8o%zQ&Rot}O({`> z7IiO~$7z1mV;lvRj(Nro2OGGOcTG>cZ0BH`F+C-*OJBG&ruqq8K=-(C$y}ay7tuno z@XJ^3;)DxblG_itv}W6og$n(350P62bu~AwOiAeazALTXf}^ivkHdJ^lNRfAn&8v2 zbn#B}R{zORgO<}43epC8si`djL?nhHeQ!*FRU7+Fnt+ z`D>!?jNvX?-ovE5s9|%3R~)pd=}+h!?H_itYtssujTdCYW#|-RlXF4)-50;IPodRe z3CaArmOplggdxghdUAF=fr5fnd_l_-@gj2#d4pk-cR8bWmtLzqsP|hfoVAoBMxz+e zh~!zn_IHJQ26Y6c-#f3EPAfOhDttcUZ8PI1fc1_o{oQqa;qTIQPv(wF<88*&ZKkm< zdh0^N>9BQI7{z=IDOpW>vfqXGT+e9#=8*5#5ubdA>lU1!YxHO3^!p#tgH^G7j;2#o z9oO6x+b{*X{z!~o-b`Ui3V+KF-Bk6$$jR}Zr=Rz|{wkdy5@0M|DVx4&MP>WNtZ|j| z)?Mb^Mf%xQ>0dRk{UN?%L+$9rm+A!k^WogYF6X=z!E7~Q&a+37M4xY{)s z);9c3VogZ+%}n!sjN;8D^x7+3 zJ)VWZJG2ivnfsp<(0psUJNx#xXPF$9&2VhmYY-Eso^+eOqPbo6+Su$VJH3QaX)XFm zuW0ei@&208e!hq_9-nEuA;11wd0j!<+1GX+Bh{m)2WZDXa$RBYT~%XvUgL{;)y6J% zdR2%~!XL}qh{@NkRp-q4>%a*=nWN#-PxhugG*~+wTH${lGPOU*T)jZC`1lF$Q{%QT zGhMHU3lFO_&h$&nNfBBUvn~STvt(#}= z4WAwucMdA1Pd2qQykvu&%p0 zx6-Jo#FUI!=`ugMY=7;CP$X}zRej`c$@l)=0!-<^vSHJ$o7`WAT6shm*orf(Y{PbY zlDP)^GOx7n8?2S26O4}6jlF7)Yv&Fnv=3?2ocWw4P$P5|94bFO6=wdT3D5syIicC? zrl<%xwfW7H6e9k-o!+^uaf|v;sLywDP0^*Emy6V%WXPEpp1VEU zP?~bRpL@E!<6`3A?#}`KJ(Jh|pdq;XI;q#%o6RQQ|8#KpTH`kdC)|N3*$uaIbiKQ? zgvg{;yy{nTxNT~>DR6IQQOFmtgQYtGecM~MY}4<7u^@NKm-|R-W!G;1RNuVA{j|9MOfUW6$6|uT zboB5MyFb<##YkOl_fgL`XA}6wJ>3wFuYMSODVS|QdWl^4BRrcaJNH=ysgp;K_B0N0 zrD%6rADi*C4^_UEC$gf`cx1$WtygdFqiLIco!sYmY3EzavjyZjtdFm=dqmnX{W3M_ zm6d(q&Ci){Ue=N#bQS2AzHXe-yO?Tgy4OI? zA+qgmMI_^auFJ&53;3;RYi>BGr|cqaa{qQ-y;x4xXM4=`9@qV3Vgql``4M|$|E^nm zchu_Ud7a+$uwPGn$iJmoVcEd-%b&tNxhFY+g&Y1=ob}{mHjo2<(5t zD^r4b_4BEx#fbj+^N(8TMVbu{bhVq!^1Rxq`|32PGB*hsZ)sYkZntR$dSlH>qn(O*!kB z;gf>wL!1%P^zTxLn_9ul=&KVw=O58GBUPF7r?4Iot;KKpxvgv?o+($VZ%t3J)8oz8 z^!GVoGqYvlKOOH)5R84Y1i$ZxXFoU(k*oqAX}b<@9%7ZubV=t?=-%xR`ld*Dg)^INvviM`ZY#EA`dmpbZ;$w&L| z*w8J*N>Zbbdak^2_u|^ID7pc z-DsMk=keuEkAF&(s1Y$zL&rg96ne?FFfc5;M0=t@fB&ja?- zhbG5bLytNO*sF`%jE%_`9rZ4G*1o+uYtz24lE!cg1zW#aINDsExK}XKbke`%`)iN! zu-=H96Fm{S_Ess?eSQJwYT?cyQ@o+8(m-dfS=*AD8^d`<>6PGYTL2Vy*-8_jL-~)|y$G z6xZMJIIE}A&8tW^*f-j&uaR?_m=u5;p0d$Xd|A1HVqR|k{E2@5%kAPD_#9to`#o;% zD`;PVzd6=yL=SwBQld`c?{C}DPj+ZaI(dh_Ka{SeORDnv zpoMJ^=D5H3&Av5TrE=pEiWp{x?vSU$(%Hj=2h-^Q^v1DYlY56-p3g+(fP z+_d$O=rfe57@W?8tB;)JX)f~P?zcQVzGa;qdTlx|;5F<%^(jVA(0Ep5H|DDCi58BV zsgoZi=1hcYl?vv>n?9#pKbbEgFcj9M@a1^srdDo*QX-!C<%-)mkLfL>{tcbh_OsfS z{&;R#UMpI~Cczs`CFwPAEY(Uwn$8t2)!*jvyWNT9ryd>ieoWUc!Dj><5s~q#wv`y> z)x9@tT^OLHm_Qr5gSj(h8n0b+bjV+H)z|aV^gDaB?NO z%?W5<^PqO+w4fy2$pT+@>%i0}4&B=BTA`3sx7oa5cK!aSsVBWzdDcAa^+#0i@9J=Q z61hkCP&B@^!?~}oizCaj&b;}xR^Br?Iqq;{<$J9*bSjeAh`YSL zAKZx$*)Cm^Uh%v1^G#BzLcVR&1z$Bk7C*!kobaj;unS#|J~(|B7isJo`SNy$YiG~7 z3B~-_)6PO(g zYki~}O8R&9mrY-b`}8`KcDgIJa9_dI?(`nb+>)5a9s}Jr`KxEUuRU!MaPb#=rmD3} z#1M0TL*RPk9KKtWlxA61`)sghsC#dI!cW@8JLv}Nc|(pVHqQ3&gynp798y!PNb>%2 zKK??=5<^nQxQ_nVvE$_SrxeA5vHrvR64$2&$Y#I$P~ShdKe?^T__r65>L=mZ z;^2Td39Ka$gxqg8L^UDT@_GAv*4%6#}%P?*j%>FIj*KK$9q z2|tSWz4qq3DWfI9rc-q7PV-Cp{5v-!*c9b+ECH!i$u_Isv5`Z z>^L@H<#5WtgC_;HxW;jQf92^T; zKKHnP6ULwg5jfdI&;JpA{rjzE+TB4O9K5d466Y?^9!_3P{8}+o`0mGOwzeR5wdL>X zyhoRJHrgAfSX4wY_Dk*3VaaeRp5Q+ou0*y`lBn`I{gP;CJomNeab4CdTEYPoQ-gx z?N*!hvkJE&IF_F{dr_T~nENfQGSKCb~?qV z7mrH(DE{zp)=HGh{^otqI-{uIoc_?p*5>#xO#?0IYUI4b3DnH&-s^tfyQkKvCw*oA za0Tx+V9{P9Po6y3M?U*xeIUAbN-XxcsMaW&XEl(lx1Xc$dWs#nal-ta>@3|f*>@F# zo~7<$zB!cZi0;i$dr_)IZ3dh7lTjo2u(pO)$vRPL`k*iEggsX4%tq4CsqhrfeueB# z_$9#5qddBHc}j?b+-wUv^QX^jv#NQuX`1#$E=sNY>yoBJwVClc$#-+N+=X9qjJgg) z>lXH&cJdd`9u1znS@YyUNtoEdJOLj*dfxcOpY^hA^*MBb;;M$$!gqz6Oi!kq{#;mr ze{4OzFGAql(5O(Xvg3ndi)tG(5)R#T?ncq~H!19dKkmjI93*x~2O=2>ZmJZ70x@LuihG`F9SmM6CCTsV|rz=ag;;5bx#dj~SJkc7| z-gGTdZ^%vT^y-gY&0@!B80Yh6Gwz=LLaqaYo0Pgr^UUTsr# z;^wdx@58Pq6tv3H8*RtfN6zZ%KEEgw?KC=_^q~3vDqDdhdq$(>xJam;Xo%NT;}_jS zA*8JACF9rbli#lo4Jk^=w|;BWeziW=hvZ<9E~=g}p6iEOFFa&qhW9bLIqeWKL^V-pN) zg$A*^(CFFVy?x|$n$7scHo3Piw!;=fzi>`ez|r^l;LP_i#lz=bdN(Di2!-4ek&gX& zizBmJ8dm0YEeda%rqu=dyd5n?Lf5LjP5=3|nbgxgu5u=FZ+&oJ1Uy^!G>&EFh2AJI zU)k<5wNYHAmVGQ+jj`;MO!yYZo+|;X^p}UVtO%bRZq6Cr6P1!;%@!(2PnJ_?;BgBO zlu^2_{nEx7?pErbwn~ub93>Bq=#gQ{zV}^)b2^-URM*0*M73VWx|**fwu*bLz}3*` zS$u{WO~-q z%T89~Bfo81Pp!|RhwFZ*tvzm#o>MG8o&9~Xy02bvk7l!Zsz4QA(e)O^f|0R3*84<7 z=Bl`xie8iDOXAC|`PeOPO9s@0(7E5=S4`K$?0X>|zNIzMx(ilSAt!6@fLG1dkGi$Z zbWSqhkNMUTjKs4h^6psLlj}FFuiqx&JyiT4EuneXVwHEb{7R}tI(K^0>@Keo@yu-9 zHXq8Y&Qdshmdp8j>=fgGAL3N)q+>$!6E^EL(lYzWt3PJ!8RU<|PASw{ZJp&v4@xjT z^gf+3+P|8J^nM{%*9eSfWM3`}Sfd~x9A`N`Aw;cL`%#xQdFz=y&7>}`QM#!WdES#W zgwdH4hilobUqY%+z4?rfr@4IyRef=5-5p9O?RtvNfte}m!lTOhHF7Ol0xwfYE9It- zuqV9hw&wPxp6%;un7zJv&e!9umVr5M6uG&4CR1R%*P)(s1}W&yJrh{@N@PYz?B`?QcvUY?D*wj<5|Qa~yuD#Mm*FQYOghbES&H4!^tl z=w}tgcqZR!JV-vDQM4&d#_$s0s?LIL8iSEY9{p>lN*HyCGsidsWQVZ*p_k3{ zt}twc;kJFbI{uMJ%R9WA`J}9EFlJ^@cOCrZgagwXcO-a@%{catCFfN<=5|zJqQDvR~GSB?KjG< zGZYKEdw1JqKm~||_~3_NCAQHrY1O_u`M$=|4|V#@d#dZ?N5{n& z7h&uVvXY?xoBc@h;#d=1eYJ|qJmQXmrE~LvZ-^J6uD2Q(gEFo^DEpXZqpQC(e)gai z<`QP+I%J6_Q|`H{Nro9`bqA*l^81fo_23v}x|hh`D=R5Jy`P%Wo%t03kBT8BnTj1P zaT-&m67}vyJml+2vf6W>%du3=|w6gzkKT|Lym?NgI=VNc5O zytSOUIu}1#zs=|(ArYq-4!{&Ijrx1%c-q0KaNpW)!>%MQNiCju?Mds~3p4wBs~dcr zi`8@_a+7l9LYQdZt###q;tey8nRYlOq^aldJKQE&P*^|A*0oe#g1W z=?CwAUvC(3+Gwn**e|}cc00fexi64LT>wSxhsu;L)HROuEO+0?5Jr1@i8%)zpT;-M zY`s_UZ3*8_g_>yrd$n++T+Vw~m?C)M#-3@s&%MslRr}pG&#$hobC)AZzm@DE@rYX@ zHWWp@G3BFwDJ3n0`M$SnP{$?b^;ta^$`!Ficu)MZZ9KHnZA~h2bJjo5d!3V}0JZC# zMQ6`;6%CDqx>EP1<@dm_lu^59*)L-h^>ap*G*`~An*_zM(S z$J^B7hy^xS^as*xR#t8Oc45y~jxqJ!@IvU=H z#x#rET~|e+iQTp2MYq1580Wn#@A+|c!X3LWC0upv*!N=NmP+tGhkfa0MBRr6#d~8; zh;Q15hkIEmdJuS85uFh9Dkiytzj^8!5nH%ju&DqRy` z5JC-E3?bocf%vO6xnaKkGA^-MFEahE938g`OE?DKKYh_tAMompj}W|{u5^Y0xK#u(7<&DVRPCoZC1!| z^HQL2>2TLeRB_msubRp>qhM3R1G^8PAixuwd#KdE5RchNw@i7E^O*2a@p3A^c*=@g z9wMcB*JHtm+K*9Ma%1W!yoY!J#~k|H1ottD`Z8^{Gu3^})>`PxQ=_JEFH`LDjwVKx z4wn=SsI>?79Jow+1a%i)wT9bend%B!#r(A_EB5EQndhJ6mTEY@ahDCXsL@+OMm^as zo9@lj={0g#e{SWo%p^FWdykV#&P&0WbTKM;KG|8!3>?#`yK(Rn>VW>po~G~|&P)n- ztmp-$rM^n;^G{1>D%WSjO3DcZ`&<`3SK#T)?K6)|!H@rDFVk=T(zRD;Kc%afL$C=W z!kc)|lbNRT$X?+Oeb1U^$lfRCzOXmkqhC}5FIf@0f*6Fnm0Sm@P>X5efxWLBhU#J1 z&+^o2L0=cCPLxvfoNB%DRs2*N-RS-WNrqcm78diDdK{dl#1e7`)JvvEKFsx8v&}tK zOYVA(8cC23#dDddpjr9q!rdY=Bl`WzOR8{P=aXFJv*$QCIP{0=1KmDQkxGAhm$UT2 zj>&$6^To)hcWe9t%Ol3uDutYa`qOVRVdP&`hy%ZtgL)$mVZ25WzT=EbpU7e~<(h%D zHHE*wKcd26=4*uzr!<{*+vSgy?6cElc0uuZ*-KZe1$7LfYE*vg8uPZs;8A!B;jSz1 z<{Y0vspp`U!&THbo!&Q7Nt>&lX2!bA6<(&FYR?>JfRVh1u70w6wc45eN;tEXb?W`& z+$CrzZ3g#UW{MVGB6Xo{xCx+qJ$-JTd$40++rH_gO}lHMuNi zkai~&jPV57!W#+Rk(WPnp`3CvZo6t-;NA_R4J9zD4hw5@2-5+FQQ#n1RWIH^82^Yb zL0{I`&HSDygX nlbj)*DkXs`_&868w9*$yQ&*v5dxKaKg}8;4T`AQ`+y>v&T52x zc}BDWhBAM$?!r6tkyyfh)%+F8uI_C4BV*_ZU_*wpY>V@(_wXlTeL^2qeAv-7h+OR=X>{VS!z$^m?SNy zmup_yBo7Ix|5>2Z92q})6SzWXKT8Wwosdb36KZG}VW-7_4MlT)qceT?Z1wQjRlH4}puC=n5>YCq z4@F|vo2C$&WPr!Azwu!GfUd@dgYB1l8@KHisE+Sy#NTD~mIiOYc4R>&b-G(%Zn5C8 zaa;DQAYy|)%yk~y#%{M|O$kv@eQ}9$eN{4b`u!wZu|yxUmcwfPT;ZmJiFooplehsKL|b+Q(t=DlufdU&ju8dtG1gbe6ic__{G3IuXQWIi_%$glKyVA5wKX%Si3 z)oPV^44BaGlVwviPSK7Rv&;Oz7^ zTGa!i7^fPja(-Yu$AGUJ=hoK9y`Cf7{N}E_TEMDWM%mU z(c~MwdyzLi$X!GUBl+Na9_W>M+PYpR^ix~Sd*CbR`NdC8tUeUYjDLyd(Aw&>8)*7m+*1s)@or2!cnXhX49KLSm=~`Bq9|a{T*h0l!mM z4^h@D#)t~Wh*zc`yeclxz%|BG`O#H&yd!4_JDKq4iOVpRhpNQP5*^A*<0YqtC8loa zFYlLX9*8HwE+6D;h9-WVLrg?bN{A@~iFK25DsD%LUFv{uu<)=tc@Rwl<=e@jE6-jL zrknX`d0Z{QJ1x?cr9Y}o0apvpHo@CT1jjvXFQM>0lO81nyK4$hc-yMX?p6Uc$e2mL ze(eKTw7gp_$7Fc+o@<4Vf|2g!5`FrNH1*P$5WGELy$E!KX-3 z@WS&PDD;+sAPtJ|%7D`Q=fR7+3ZU$P94PaZ1Lb}fKxKdes0z3U^6x8y!iQHuNuUO( z3ef>&Ax5A))CeF0FM`j}5}^8#GN=nx2lcV002yr#s$(p`>o`l$7zdBzY{2VyYfztP z4c;W#g167?z`N8tpefB6v}QPg#&i$xF2fBB7Fq$3P7F8;LGmL8NJBXP2?H*C#(+!R z7@!P64T8!S47l2h0h(ViKo^2OJiZB!b^0;j`TzzP4q|}OHw-X?$EGkhAI1RdAq=n@ z!2mayJHgy$3JJwa`X7pP110yU|3L4CRp zc$47+nlrsYQ*Iz=&JPCf^L#*8Ng(*}G7NOSiUFU>Bf#gXI51xS1bnSe17GSgKzDsM z=x;~^gH73Bxb+1X>39W3JIf$cfV)sGe<(`;gu4?M;5Uf@fmryC0Z&FDK-oeegiT{W zB+L_LFyPq~2BgFKq*?eKLdF~h6hkP5-)m}WKtn?V=<4bM-QC@wudfdbcOt=9S1p+6 zt_Rf$u$hq%LQ7%&E5W*x!?1}rQr zfThJ*u)MqsR+r|$>dGQmM=gPkwG}W2>z6jrV0CpB9;3kK#yVKt!~irJjXg{L$0Ya@ zcmHW$aleQ65AgrQcZYZ@|5Md}Z~&=_g54BlB_(AQ@5Nzx{0BsTpg`)ova&ML(vr9& zeYfbJF~GdIEH8^=u+2fS=${CH!CaHSC=WTvU`3EmNK%x%_D=-ByimRf>9<9Ah{423 zO8*l9FbS8HaU8IHka5Fc{3Ip+A^kQ3oCvONPzx{qfdVjzS1(__3?;xRVQU=Mrutu?(aWwkE<~+s9x`Aw52p|Ea2%ix zOfkU^ymyj^Hg+=pP~+dyXB|1h%nVh4)!_-djMA4dm6es2zQiPYW9hfm__y>gS&lF> zKnA!`B;UISCL$sPOuG$B18@>xwXi*dey2Ycn6TtH9m0u(rN?q0LeS)T@2FAZZ`;T4 zLwYE}HUl^jaSX5$APiEr=kvw8e@}0IoP`CefvrKno(Ve)h=?#cTMRA-{XBne{FI(x zoFP5SkspKbGXq2h98ugrru-fKV@w&(ame8a3lxDCJCk7#_HL^HM-L~%Wt}bY!C&=P zih%+^2Dm}o8pRz3P=na^v2!VI`#Sg=ddR?$=jaZDt#k2*3b6E$L%??PziYn~GRVAR zCW1{uLIUu&j`-Mj27%~#z}@@z0}^(~e@_pm8ZMRPW@1xDR^(0(h@Rsr(y#9dvE;FRk=i&c@OBrsu?R>zC;8yyT{-;5QUw5$nKL6MB z*tz$w)35aZ8vC!c|E2%s{Qs+p{$c#xioo{nm#|G!84eJLH+K`Jf@2`)Mt8~AI@Tj}?he_#5)N>9(lMNdWd zhx|Ko{5Su9UIW<6G8%8|;yeq)abJ*t43~QX;y>l^<&C)Gf0fT}b%AU5mbpYhLrLyQr46K4Wy;%&i)EKAUkY!4cfZ9r|ZGxQTX zf#!7RD}L?@`g4tea0eRtiP6wcj0Tb)&_KEi4HO`p|AYn?AYAH30~H9Dzo4O?7!9;~ z&_EZ0=2tY(hHwjlZa*6OiqYWaAR3tC{KPOHMgv>uKeir416NpXGlqsfVl?o8kdTl7 zQd3hwc6K(%&(8;ym6f0=#}9NCJOm$${6X7`0PwLS7&PQO0&j93fw%dO!Mhia!H3dN z@S!Rhe5}Fxf^)#vcg3Lp&2!M-ln(})3&CJ(DHwsiV1MWf_L)Eff9MAe97lu4lV}hE zA@n;M#6jP0azkUVdpKHNb_Zu+v^&J@Rdk>}u+QG!oConeB2Nov!!0UMos9!{bw+k5Xb_oNT zm(ZXM!j}~^_=-Y<(a}*bF);z=CkDXc_d)3U9R=TKr@-?3G+0@j!TEl_&CP*{rDf0$ z@xQI2!Sp&BEWqQXr6sVsJO|dc{l2rXd>;CJm$&`Cn;UD;=ZpRy=ktZ9`9DtZa`LZf zws-#j8fm8%B1hl#aP^MNFD~9G`xkj}zK7D5^Hy3j`ri{2=c~)hK@T1DugS~tAN zATI|!Y?6}sKjHu4=EM)csohBpx`R}dLNj7wqSMp2Mq*1SJiV-+Q*rhUMzX!;t{Q5P zLPZ7J4SAdwPbqS%kw4=X7YjmjeYd%j7Q|PB`0`3PJwc(Q({Tj9;0NKXV{=z6EnEvf zx(x~Je}{jQi3Xa}X6{-V>Ka=zVI`8ox>sdz-To8*;^NaxOb}lv6!M1&%Cw~@?AS?1 zVH@}bp9v;%a+)Wu8d}&tY_GR9D|g=eulUJFAwHCd?NP*od-v{P0jt`r!SnbXK9&Hs zK+bauCKD556Z2F!*f@gU@GoY?;bRH*?%qvIOpG8#&_0FkL@WVrp8iSxtYUsvR%`=U zCE*C5=Z%;G>CuIenJb84d z3p*_kC#hpK>+}Qvj|o&|m(j#QC%Sv$6^btoWcvJAK%aC`n68 zOZ&I;4NFj5kX?`nQ%GVW+m@1&;kuXQ_uKiLm7NX$i$!6Vv3=g^LUM6df!?-Zh}GvG z`q|b~vFHgdAvkPI`}Se`kX(?J^)vn-`q|b~vDneX;@h}!CWi!&|DW*x(9ia_;+rQz zu=v<&x657!!xdmkZulZ*e+XPP5|^G1pM3d179~lU;iKABRJ0dM~Q8F`@a9*r9-?2d3kvc ziNn__VG|CW`d<_MjK4+oKjahcf#C1D0swO)Vk`H=+sa`fuKcgL$96f)`>}c=-p=8B zG;qgo;`}LxD7fQ)n*YjY=Xj@`op%3Um~WY?I6dLEnSXbTwNsfPNI>{ur~dT5lArBV zY&_Giu}nYPr#taW&wq(s%5XV{vqh7kEt=vgkF!N_cBn4{=mmZAM>k>2(N3(94J@;RW!QKlXISn8 zV|lRgM)1ZZF1F}x)&tO(s0D9}|A1G?)nK~H@a=zWt7I$O%YP;)*QYJUla zVZ4wJj9K!8yzWCje$Y;Q4vU`$XRgkos>Wz0fb5JEn*`;bT^Xzi#2?On~Fr>AGz z_NxOEJ&j=E%Ukdr+I`=Ly1={95zsX-1Zt-jAS{BKxix@Vt7W zSi5g=Y6!wGK*9K)VHnFZ4r6<^Y`S?|EYBK@<(Y-H+#wj(8;!%p%#PqtfEN>mtPoW?f7eibXj zk9sc!l0C3qNfepSu`lotU5)u+cDI5Znf)jQ`5;FLM{tzu0$%$(_2oQtg^w0Iq zw6wG&B(lb4X1C35Uy~BR_Vnj^FJ>G9v@{3^2q^U=AcDZ3>W?uq&{C0*KwF0ZAD>bi zB4CvW+lTQhFj>pNdTbNK#DoyRR6;`J+RySk*d1qvO~6j<#X12cmru{$R{O_sP*OAe; z*8k-nYwnnA@z>YU`L$Nx8fOmS>i7LN?cYyBbKn40zrU@9g*)|Fod0tPgXxEt0Z(!0 zvSQi+B)nk(0dE@s%zuTQIxOBl2H4<_gx#lL-w}xQsqgGlBz}J199D-oJ;L{w!g%W# z^V7IkYpm})#qN)|>Yw)}>CTe4cxr4c^&5X~(Dqai`o-lyffqK8`p>b{r4KHEl7~v5 z{NV*q5p)@pKGFl_PqaaPfIcXCWB^K^-UQ|0rr=YQ1o#lI1X^QNz=s4C@FnFk_>`s# zzGmuyy2u-#>6ta?&oSEacYoaScVqV`@}Hrv8^VsSTMhcUuWkFbZ$RI+(GVK$Nw)mj z)+1=R7lHn5xDSbrjs_Je_i(=Ks+UP1FE0z@^Z3k z>tGklKc(CJyu94JTxwf|qGGsYcuD@2AU~hRHH~Z9+E`YGj@aZTPfVyHB*>2?VP_MD zjc=D9BqmmdA!q#jr+K+K*&)GJxho|lF_W%_s;a6WA0)B(QNABmkTWteFr2*#dEv^f zU~*)oq}&TvT?7J895#>TV+-xFo3@Iyl$4}!!AIbo6B5+;A&;Y@v7$Wm{gMzM>o6 z-@a?;h~B9wE4??2m-2ivzhC+MJ1^!7XDI3~DG z-!V0{cXQk>$H{XOTfUQi;j>e`g>T?!`|BT09!aqqSYhDn?O-y(?4DT8T+x7 z4znCPf-PtMH61;999#a+5@v%5U}njF01_@LNXX)^fGx)Y;y(hokm2^x*maB?0yBi2 zbqs#_BmK0FMcwAbJvS6>E`YlSoO(wXq&kS=?)g4()8k zvp>bYir@u&#s_<^_T>`;P!?_gDx)lM>rZ{GKJK3E>qK}@HWl87&GG=B3S7Z?Xe(o% z&yjj}K~ z32opkcu%wl+QTnrSK)es!L1+P;j=Cs(4OstYsJXO2pAt92XhmHaD5mDD@zMo&!eE0 z;ktmq*{&$mf7gXSCe?qx{eMXV*lWd)bpEV_;*SFW&M_T2Cj8U!S=OT*94fHj6b!z< z$WJ76lJy7^1Ct`|ScQ!E4BJW8<4jBvTlM=$$ho;W1zDNI!6`W@DcSw|NQj_`D8hPv zt6rLyj+T-D|C}h~2kT+tql1f$!l`Zk7cUCX?<1yG!5(Alv29+ESGf2`J+|Z`_LxUX z?vDg_?G(_E*-i&fQ~uP0-+#qCfa^K*t74$9)f1xp3E(x-^KSsFIxPIJzwgs2LPw@| zw93BZYsZDOj@<+=6nKt5dUW2a-@E*rqp@SVI`zY~(tva_;h}O=<$`a4Xm0Snb-D4BsJ6Qi_jLCQO7*Xm2Z2>rSZL|S zJKZk@3rD9nn&y;y6riYkYc2*2z3p)bC-8vvK$#K~S~7Ddmi`I}9gyTBf4&>|Ufck6 zU{_MgVFa@;QO$0YP%YZ!P8>(N3O$ zzY+N- zHQbLUI%>oekpHG>Bt~I;!Z=By_8_vqU%w)n{A9rrJ*cO>k&peSHF&Rdb|5C)eSXz- zJngEfBO)RjKhpfn4H}s~U*F?L8MT5azS+DCz2r;Ub>nud>LXNExzaj$QjdUiRZ?fzP_D&2Q+F)tt1R31@*z=3vC z(%?%&C`Wo$*3-1nan;hoT2^?ogSj_?oBZReV?D?ZAgkL$<&)A_yuP*wyqmd@nEUDw z!d954D(z6(vi(5es?OM?MQ-V40OWu2n~l)BckixfE3&}LfeBQFT*~GB=1oEkUk7%V z+c}bQGtt$>u?#s*eIlq&HTH83yT?wVtF2Z?rZne+pcGx8|J>C zsc7Th;`jG^+c;?sDEg^w+zS<+YdYW0Ce@jAexo1Rd6DSVzQFzzA66^Oas}`twC%Q@ z(^RnfEToWchK#4+6PSY262O(=!bORgeUtDt1oG^+*{?!ll34ufC1IBOpCp`Ej|x-EM> z8VKHx+jT?%I-pV`)KK)e*?MCl5>Yz&(Cy5rQ$F(v+6-Z}%!-$0a;U`B@3L>UrX4iHTOEY?`d2YsX zFkES>0kgWvWoYY^B6vTQn3KcBzmHilp2Fkm#)OrgDB&r;zBA4zJLmkfU(LQ`67{~= z;u<%j&DVJm&f*l2mGV!OD+HAb{T3Bx2v3=^pv!c7in6Gx;(a|dH*8)r4SIBU?Cl+^ zGt>{B{uGQ^PHxCz!Ha$@0NcMi$5u6dabF**xuu4)P%+6-MRCsILxhl zQ!ni>)5RO7^B%;x?G@Z~7P)w4MV^lYQs%E<;1Xo*dgDBcqD*I9pVQX_?Z#T9PbIz)kUhd!TW5KO(DK@c;JO9j z$D<7E_gQDh{AFj`NFMlmhoumYwKOi-@1OUZeA|=Gvd1(bCqOsBjHVN5vGG~WOv6b? zxM#7}t)3QM+El-smLO^yjBv&rB32yyq)~=?7*41{>EX0$??2MN#{TiTisgeV_3zOZ z<*V=Rl}>C7qXv6>tY=?86J5+1wu`SrzApQwO7i(=P{75(WnzbZgYdZQ)sK7l{PEgO zO86T@t@NQM9u7WnZ2A7ocW|a!J@@MvWz`!$FGklPsnP2RB~p}ClQG)ka|#uO;V7Sr zD|Dn6+0-ejp5QScgPGj%I_g9Y*z+}+0XoQx9`Cy_FOlZP#4MfMYtPACjR(cgHa%yi zE)J|Y9B^r-zqkT_3;u&{E{|AjHNxZb?Js>sJb1jG2O9YBKY6%bW_LfOe`l^+HSlcJ z+o(F*Q>96I!mKob2^v0W*p^?Or#Y;bJNqiFnMj|v>wMyzmYlR-Be*Y{)^vmot(H6- z-J(HW+Crkn&2b>{pl;?M_ti9Cz3KPa6qsE(>W&k`wQuOT_T9QKoB9}!{MzyNn%`p6 zD^B23hx;=r#u`^?o*!OZ)gdR^yfzm;@Ip+6Mfv;gx))!PN&HbwC$G(k+{_qON;&;W zkZlBL95Tffb}cY2{fUe|f$2ud<8pn*UIN)g7f zJl%q!mwa3C%7l8tO8nX6{*aWe`{(m-v}^Zp333Elsz@8c*GKo+>IgsWig`*SPEtD} z#iHspdG^~y!snyCisnyHZ=33EZG6w!NBf0)HKrZ-a?GmLKh#eqSTSXQFczPDZ}Xcs zzN5mUi7~|{tHoz)y(ZmmtSDy$P%3gy9YeQS%zE8sN(dRYKlNDK{koGY+mJ`YL2_Pj z&R^tADp|y)^SXP0l1uA@Oa{it*HW!aZN44wtr_FhxA}TUL%4%AzV!Lf1d8o}n;_9y z8lHpEQPqMoE?-1T*ua_ySG%72(kO~_$cdja~NODMt zBr_W>2<_r!SAON>A1L$Ds78zXrz_f&kkdd#pa zLW?eq#J=%t7Khx0+Z2~p2tAlhZQ+)Lb~h!@LHgMGOI5vI9+eoUqc=#MS{}FB%5=Z5 zdR|$b);%tkZ(dJFn9nJUxUES46%Y{Y4xx-Y$ zn`Z>~Z*44looao<(YJa-&H~kjF{7{T;kQUMuu&d)TL5SbilWrjrWhIU)&1RrA8~nA7vHk6agG5@{o@FTVfA2j3K;a`uCE@bpPV zsY30~X9i)lki{H3oi|;C`Qjjzc%MgwE{8l(+qW~pO9wneh_(4^W+oK}HfeG~sC3R2 zRI=OY9aC4!&g=?vx9&PV7^OojJ3AJHkY7#p^|(oN;F~ky!KtaKkD_crbXG0aOCQt? z`YPQ%72T!@VmwP<%5l&TT=HEw(yGC6;Ipdnh<(w3kEQPZ3!g)6`kv+vwjWw|^Q$`F z#V+k>(odsfr*aZH25EbW&1;8(#e-@ekUh9eLnlG?SnlW}xuf*x107@O--(ziP>K6J z>blrFJ<(`)v#;fJ(Snxs*x$i}zX?||!FzJor+%LLM;DL7+X-HVyq{~}+QfA0bg#Ou zWtnawW0qFQzAinFvu8&8hGJIKukE9gKs=Q@3O5HIugpaG$Bm_}V;6lNauH>}=TuBY zvmB!voS|kHWz`Thv{G!Ld+glBAGZvyB3Sd+-_R}}ibl3SRXrmVDS14+!LZxuMlhU3 zB61@uF`Cmdp&}T&(RaEXZuf6*#1;lDKIdE!OTU~uzO*MLFwHBGd;Ft@zC_j`eRBy{ zMsg-_nccJV`MIb_8Nk>d4mBjetJDQ8efZ+c5i#w6OmJ2gW)dk>LJ&2-c>O zueZp|#PJIB2g4_4MS9hn_lg-IsKQg+%Za+!eQ$ay-G1-(h+Ryd--Q-Qg8U{06!51e zy;@4}9^OmM9s(94F|F4FddEuSc|D1aJeFgQ?5wg@`}X=Z>GaoS`e~05=2TuGIpX5r z$sr%vro$u+N8F1__#Wzs9HNoin7)&_-p{5tKIcOhabbf3Y3!N7>e(och@}B%G4%r2 zcgnloJ#{BDeh_xxt|71K*{;@MA@|iz_YIVi%c;4R&I28G%b zRVUtzkzV9RE0c0uE>%`%jBq88n*k#_1_$?kc`f8|@6@u0)?R7?GqB-{X?sI0<}liU z`daHkJ-7Z+tkM-3l{B2F%hWpTdTX`2T_%($m8R;2X#~-MliF)y^5UNl>!T(m>QTBi z1fERRE!i{XEQs{ebB=7Z`uPZftAnnM+jVS(WTpiNBA}s!cmpQnI1UsLZ4^(7-N(R} zxALgDF1t&e-KRkPATN+j?xh1+J5u!ZIImy^=YD#P?ANXKgI%sIN}vHl80I;&KW3qd z|0Xjcokd_yyugw`uX5DMaA897gm2kVcQR|XifiNQNKZ|T_Ic;>N_J|5Kefu(pz&Bo z%<%W?{oi_vYpUJ~t%$ZkDeg`^uk>M2Ma@^-oO?jUnJcP)JapigyFy{PZtl#U4rEQ* z30Luo$`CcPuGh&DYsXXx+3~a|i=L1s?1R?Ckdp^j>s+YIoe;g3SFaZ`3>&@~T%qFW zc-Y}l_~in7$zf8&)0K*kLQC%Piiiq_{NC5>g2Vra=A0N%E!gHuS+Qo4brfqdqd(QyF4?DFYf0e zvI@13snsLSv!DFvEO__|yg&zrqZq}60$-I(vAgbK;N*7W@Rwyl%cZX0eNVrzq!Y;7 z+mN#9(8U^o$6-1sU{HlG{4tuXav#$C){#JPOHN6NOjtxD(5VvhhH+pxQih}5#<%Ic z*P%_jcxRySVz-(8joYDaf!#>aw`63pujy5y@!eVkifJX+_Uju3XW&f=jZSt-^Lo<1 zaGbkgFyk@%nwrtYbeE@M%+2A9vaF-}2U>>mI4C?)+_@12LAtM_qy+N1FRrXo=c^|u zO)c4*0v@z)_F<+gRBym70s~SvH@A9GjO9A|#)AYuRq85N0(E+xr%hcUiD7!(S=#p( zRoJ?6y~bZ_vLIBKWjMt}3B1Z)lMNR%lJdoWD9m65areA9V{A<)9+D=UUtCY&Ea;Nd`>?Kxtb?+ zmb^UNbN==+H}#$8Zj*8_pN)OHC>(!k*Od#lyLG6=69f@YuY(9aMPhtIP{ew`Uz3S! z^IK*E3CRbdccQOP`Z2w=Ie~XN_KbNlP5yA=!H65zF2538PQ-T>4slsnFm)v9JZ@() zzsoe`kU)gwvhURKM3OV3y)6&!SMAfcvda5}Djxi+}d9(YafpS&m3yFI-d)F>UeNil- z(40 zWX(4~0bVp-xz+5mSIJj{`ty>9k3EZ1WpP(Pnh9v|Jq^^H*3CidMCbakzDyvc%jd2lT6m&6ra zyf9EFvS63Qxkn&CLhmFQ-!OQ?a6*(D87(N(g?NP537+B^+Bkg|<2}A9S%i0b)$sv` zyLh`zNbr6iRJ2@T*D`v~^_V9U z=f^~bo4>N+k~ro0CconC&nHAF#xZb;4ML5*G7o5e*M#c~hPN}_6_Girp- zX=6@a>a9O!W_(bAepJFa-dyk_!16ta_x)hpEL=O_*ek?%md2(A+=wzpW*t>bbWJ|f zG_|i68L}pIDvw;F(u6T*Gun1oT5N9shW)Mg5~aXh(J;QMb2O6_3x@mfMO7UO9>oJB_zq zFLT}dMTdO&knWqmhiFy%{JAp44R?H_oAy@(ds)*$Z)LtkE)J5_BA=&Z zp1tQ$cIR}9roCVJ5%Jv&n0;V0yY6{jtlPlIl6%KRDR-T??|J53VNda-eWy0CXKW7Q z;9E((Yga?g6XF&4B@c&6Z*cCc>1xMvMT*Gu)=|eac-z=>`#*c5Y-^*OuX^n<)z+M$ zEG`H<)~v)(Z2=VCfFrMO0fUZZla~efekeD>ciQ*Zy;a}NQdb=x%%!UOWJ9*KwCAkY z>9Nr@$Z~)74Aw4V%(&|;zK8g{1$%jVhq~p|V>R=H+z?sKnP;E(_Fv)k+?7vJhT-G`V&-L+XxdFcg^`Y7sjbOBHGeX%LIwXuVcn$S&E^jFI`T_H#rGmgF zz@K`#yCv_^^j-56CAisP>4=OuzY$9O?ip|SYs-gW>IHDseGfrg?2=`EqO^!=^;k`UyIk5 z0P|cT?C$4yG`EMqycTbtF}H$ z4lejJ6;}K?Wmf!UBJV7PEac~(B2ftBYs9^qx8WEauuo_W35zeBx=BVSamZ9bxZ-9Y zcAxM(a{ARqAiLGn&B;@;Zp=mnwZ?l^7L>&BE?UYC(5<`QomNdyAz0I1@}G=lY7Kfb z>v!#l&EgGvD zqBly2)lnC?}jhMRY>8$EZ%i z&Qu_Iu97010CsO&uCAhvuHH`Xk*~O+>OhT$rEUQ&#&Lk z>w`<5&ZhU-JSR7)JGb)Lh-v;f!k4^fm%fE@v~J9P#g)ceWX?XpC(!frsa@Rl9vI|3 z-#R|2#>IkryPVuROXJ%wXSZ?o@H;28UQztA!LAQQ!{!=^?@%c(sM_{CLY6)6J*(Hn7YAQmKq~}U5 zg|0u&Bf6~wFJ`_=)CuhO&LCdgoDx3hcaOR&gZR94q<_!u^ZL}{cMYD$=mnrK;VW?u z&_eQLPvQv_zi9hLbp@sqOoUKL2bA$ew^dBc%Vi!9dbH>&@~C!})%;<-bvni<#KH6=;w3G`PW%s{R7TOE zh0CY)2M7$znBYQLe`gPQ@Tn}}6m@p@MCz*ryKa}YQivNM59*c3S!gfI?Hyf@_0h7; zYps`vrw&%0yu8w@9HjnP=WS-w7c<0I9W#Hmz#hk1(|g9vU4~`3F)H*rS+o)UUvmUr zULPL~oZ1)6bN5&n!Xc`F;kj>OuHJ1n_sRF6EEcTO#NS+7DhsIFioPzVi0^Bw0Q`sJ zTMzb;7aGlpUWmGBePB3~p{+dT1gHN?yIMCc3~RQY{qy-85oGH@BPj`6eZ-oNPLI|R zjcYQ)j^=4vGlHCQ(VEQZ8tU}xZpZMmHO6$8*iCy!tIyFR4L~e@CqXpcyBX7l zq_2wUgW(?-?aGum&Qps!JY@1*7xNHPEu9vp^dl~gPdw%N?JcW4DEP*EdJm2y+sRjV{wqoD+S#QJF1=uG?e z)U(ykWUY?@>F}osw)eJ&$!GF6RosubL(Ngd*k>ut|2m~*^ev1sZe09I)zFVckj@Rr=rnr#?2 z@(DWb#hGK0F1~#f_9wZ+gGlDe;}wV>g&dY9;n~&MRjr%tTW8a`d?M*%l>D(HAHP2+ zi?3|OY!=HVn!k+q_bB$O_3$K3Nc}|Wd8*%yCWrF%4Ckj8>G#Z@pek6+^X@jg4NoF#Tk#W zTb8rd{(Yil=?u+YQ^&d!Dzd^&0`c#)+LU)E-!6zq?P+Bu8aQmGE~Grs^=J$+qB~Mi zi9F*ef-|@cPJ22A3_K0bA?!cqZc^8JFEj~t*o?(r&yC)C*6pO_*kNV$TqEJUv#(Pv zMvWKyPl{QeB^@T9$Tt!fmBr@?G01F^zz};yEWPg&p*1kLbp)EKjl(v1I@E>Z?^I_; z_|w9u9DU(^qP6EPXh8ge`?};)Svl1%_0FbS1mB;NoD)i~ILVK!D}U`r5UD0f5`-|2NR*Y6gXtf zgOA+G&bV^qMzeeR`uO@rpQVed)r2_w-4&tM89D={Ni}F`;fW`E!n?4pa}x`DxXB5X zDJ?EsNs7~X`@pnJ>23D1tD5(oE8(&n#M6bBUD)=gbCGf27ZrV0NI0GdFX2M*Ma^On z7)J4xO$0K$9LsMv2ui63?>lI=1&b*Us?lC(zZQ;tnS=ZsH_J+kKZ=C_SQ2Hz!fLk)rbk?gg3CN zj!f(KaMh>kzPy`kZas3ED!hqUyOA=hAyzUWN4MEd-^KS*Z%gY~wW=%jMA(h(yJHZ6 z{)q;)aHVcFpkT4Mu-qr=>A{0@cST;T?^<1f_jK-RGfSfqwO2T`_85POE2j0UQKu_?|Yux)HNpa^mtJ_vCb%HvcwZXU!pj1*xqRv|)mMTdWG~pp z;*WKwu{XR3ENULS6UJvAeQABb$B~<7g)#xNDUsASqoxV8XbnC-5PpQm2O=*L1)Lh1 zsyR{-YmRE`>FSrV)bmjfj(NST9&}?Rk>WcOW9`^C(ictx6hldZ6llW@$#Z#U{hohSZ!?Y}_m#2Crdqa5l(u`$RiwO$$5n1Ux z+WQ93`$$qKET`McWmjvXm`^=dB1 zp@Jk@z?`>I<0vKXx>sT@@`ILED~8{+tX(SM%(+u%PXRj%>SBuG2W44d291+@j!eA0 z946!`M1vpuk=R3oYTC}H2`>trG5~ZXf*~%75ltQJ2_DxdJMk=MWXK5ixv`YvjlnO-&HQzb+y~`s+ z%lGg9egE-0?z`{ZJ9EyNGiT1soHN4_Ya$f)r?14;SE&_yrD^qhI-uxP(B z*&r3|9==N95pclDozQd1^wh#xldSFLJe1#1pb$&>uG_k`St^_lga`86OG;Y1vxok? zFCSjb2(xHbT2^*HCB^I0rzQ0C;ytt7eZ}=IXvcCJFTb|ssOuc-C$lxDi9~x{kDxNF zDCa%n*X}qo#5Dosib{UlCUroc<^~nbU^K)NXxnUoZEF znUC_kV8KdMK44mpDQW$68a>)P$nsgv9Y3>Hum4`+v z7`Nq54*4Z_TP_Bf?=_Pw`l7mXMq4^RZB3Fz;G`ZQaop{R)U6ebyhns|TlNW-x>}1X z#i)-O&^Xl9Te#fnP+Nt=yQsi)s?+4HPTQ5;LN=~Busu?w$?`T)-mks(^aEtt2{*Ow zBV798qq{OWTOijI?I<*(-vBlsWcC0)y{;`; z`K`?3)#uI%(?{y42U4rsJ(*LI=IuVb-^n~f@NEeHXr=U|Nmk(9FY%Le@2bTd^_XTj z3*4*x9vzKYmKuKIK)~fkdCRO`2JYTHT;uFUAJKgKDEF-E8R?C@S}3Y7Xg~Z`*mRQC zzv+DHW_#=I6FKX@h!54fP@E7mkeg)n@*#b7jI_LZ#Pvx&vs_mC(`Pg87RGfCQGlm= z>|gk7`lyzQaR-z`zqAN4EuwNqzZ-BbXPUl?ZGo-w0MYrI_k6s0BTFP;I5 zhvr>6>KZQH?8b1tQ=|P8AL2VbxY&e-_bDMbkw{Ji&; zT)Ccx-SZa4<||K$mcOc*XW6}-^HpzA->`C7x?F>#iyz>4M%X3}_&jyirV(FGg$;+- zqz@Hz?>68>PjoK6{RRqq$R+{b;m$!yBgRxIXg?p7hONN&75Z9cJ=sEZ2yDwb2S zYICE!M&N>QqxFy`8Jt9^@ZGJT2vK1qboD`w}7b&ueyNhWm8xxp3|0po}mW`|W6{S~$n( zb&}N!F}G9wR+VtTzi;%w90h6#XU5xoJ*4Honj5{9PMH2_tJ^!Z+13VI9!iG#iH|Sh zOpI(2b}H=EP~i-zm>E&dw@TGJQe0}vRkN@8@t5XBMFqM?^cp4IWa;M*=iBX*?AXZE zaf*(A?+$|#dPFgT^-C-^L`k<9EZs}b5 zd4Bh;3fwX8Ig_4C&)>J{v;^0+=bWa?)6-k-mu&5=L+z$x&X2iwCKm7<+RZmAoGM*q z?ZfH3UpS_nXpEwey{>rYB7>q*RsV%TbWR7Ogjw#ZBd=|`-qh_*Ym>>IsTY008?JSx z-vLgBJ~e&XbagqOr%kkmif9cN(TeoAEK<77%kBM0e+Qv^Ut=bW&Oa>^^~yVRx5k3m zv%$gQgsjl2bWXwhV97h}#5!LP((TRF9Rh0r(RXY$-WQv^Q%`B+@7m(trStbvj&Bw^ z<)=uM==IV5>>BjOM{nd_XH z?3>_FGEZU6ttHB3?wTtzGY=e#7P%kTvZKcx!%f^0DU-Lij9VG@1`jiJyM)P{g2q(- zNvBy0#x;qGq)LXGSRH=8vHiNsHwKN^?eI-(_?6oZ3AQi&^ji`OF35wPNKQGIA`(&Q zMxW#-zob@(XRPcKv*ghgRUNfi-;6Z(W%~6NE6|}7MU9qEH4{49ILe7rzD2eF^!%7d z;NI6kZ(xopwU;uK$k<1DC*BR|BOfJ0t!R`H=pE|1*kml+w zv$Z9_B~O28=EzRwoPk1XjyK*dG-LJkRpVW}MqF-HpzUAq=A@2nyX%XD*WB`bCt9H9 zX5PkR>>-<#XFn27r!ERDw6+`2!VhQ}0T2$*kn|NEz5p=jNBRG)zXR^LVeBpdCc(Kp z1kMa1aQ+Z6P9sF?DIsw75*hKB_t^}-gENQ->0gur=N1kM;^cmn5# zu_?T!vi`>J0O2Aymy5vpXk=D8Av1sn5T{9W0ZVJ7eaWkHWG3#boZzbB?Wpe&3AK5PX2 z$0j&)t)fk2m$Kgy$(qXh+rC3=6G4XOgY3?GLC9R-0m_0wI!_j`J?LV4;L8HG2Ua)2 z8Fd8Crz3C{A7OQ)0R0%2{MRR>{~pk9kwu6p@W2FkV1%;3Zx1L7)A_PcAKmz?^h0bq z`Q2b{Zcg9~L-O?LQvz|!NOG0*0O(%`b%{JM10J9(81rQT+XKo1wuiZJHH51H$b>$? zbdU*MXdAE(8kq#`0__Ai+pnesx$ri8fh)Hzq4?dj!+Dtm&OEFMr;6{8ep`@ZE8xKb z0CT=9V0%DW!1iDY*WZ*bLq3ga;{i)QoQFt$2Ymhdl|dWMRwQsPC4sX#$x){v1kMK~ z2ki$CILDH}d5#43pd+@R)2x9H$OBduust+XH)21DwgUDCs23)IT%aupvGi;@_P;@Y zX(>+_;rvMgXOj}x^uyja1Yr^Iz=kgiuxB5EvqFDL zH`Zh~&WAQ5U@woYi3h*4{^6WVhTm|8DuI0+$Z?n9z=NR#&V(hf_XB}_jJ~6v z_$l28^#J-ZBF8)dSSv^FAfN~Iw zasWKIyu*|fLQTMVzqRr}P&W$7!q4hPIIovYC;k-uY}<$Pmpy&!O2aIN&S^6d=rqn-0KNbMz1(OSF#*lNXMgtEt7#^JF%Yh&d;0$U~ zT>h18epf#p{Hku$2b+nX%KilXpFe{^0}0MtCKo-&@_C@i;{oad37kt!7C~Rh^pkbijn#D{j-}Z2C+Yu`pF`lhay}16gB)m* zvnU6A9)vJFsO%Hq408f!a+8AG=j6+$4?l*_MFf>NoP|x0A2r#H6}l1ZX2CHvzYh@D zn1#oQ-=Y86`Y$amAXnCp=ks6;fpgq>JV1TO^a<7aMSh=fbn#$v7;J+>4g(16cS!v0 z`Vly1p1>Z6WbZ;XvS)!Rfjto!fHUU_oPkc@3~zEczkYV(+;q0~$@@Q1|7bU3LLC_4 zHId=LrL|*04tP8WLpiA6!T0@QAlgR^4|p~*^5B4NB@bX9E#LuzZ6yH;yno0DXvZfPF$;{UY)JZREp_JRbP-d9V-V zz^V`NU05jtEDxd%xe+)MzRDP)CcAM5=na0_TVML&oOsd@VC|oz3mX|3xVm9{1rM-K zV0ln$zX)xC9Vf73C4W1f9PGn(V5RmQ5BzMwWuvT=xIq7oV+gbrYSNA8aRr5!n4NG1 zc~D#XkBp2Y4S|<0c|w-+=n9GS)&d?(Ah6dcxr}m9(I?d1FIFEb;dl{wu-~>XVR;~^ z3s4S<@^gtd^c{8Cjp-mG{M1vBcKrOi=!gA6nIg(cib?cNec-`F5-z}l`u2;0Vk z^owktP!s*g2W$`i&_D9){s9Q5=>G=&$OCpPR8shwWZViQ4^FQlcLSYB{Lv*O?ua9a zJM2he4?2)r2kl9W{~~hp0Kk4*a($l-x#nj>qV`&ot2@m|ZT+HPpMdlq1O2uOY)BRk z!q_4KOj17WFl$IU)I|I5mVd!EgYyB{C$QrpzW!k@<)tO$Q$a2dK!3scbyeYg4#~^7 z&x{xA?ibYv(qB`01#u#0&YZ!Yn$$-7pQK-q7wl)&PJHt$hOrHPN5A;t9glv@8-Xp0 z)$4W9UKjlh>H8b2FBi-;ifn`dQl`dfx()n{imFgNVUfF3*%1U|jPT1G}Tj)nU#o7dK({7W*W6sQYiPeWSjg{EBWSm1h zvw9+Vbj6RL4S@;yS)F#g|6A)HaYG)kb~4gX4)s`&^_b*53MbEF0--P1Po7-fO&(v` z$@B}U(Z|TEM^PmIRWkYZl{e3hJcRR|YNY*l(BF_gUGUkO>Y}#qSQ}B07s!v=64H#% zVx3p-@2Z#atM%WIK3(ux8~x{f6Mp((a-bi z`PuQ$zonjQ!}GuT|F8a02L6-(x;enM6ZBb2Pf!0p11w#2Q(rm%&(iPf>q`Uy&Mo~{ z^5kdfKX~vU5rqG5^#5OJ1NE){co&NNn;>C@I7!~CPM+==%HW;o(UiHz@9=Z{G7d>_ zlVkwt`ceD;H_?u`R;M57ei3HJ0DewbDM4PxY-0dF|6ilOdVT$Wr~g;w|3~ui-|zo% z;6D!h$ASMi@PC5?IJaCvtz@Q{Gblyo>PCrGxx!J`%>DOQ4*&bgYXOffV*IO6wJV2z z&t571{hzwB6FW-kBOKR~|&z+!;2 z0O-(B3V;bbv;1&zeDcW$ZV` zJhO4%xEBP*HBN-cZ-Fc-7s7a-Bh%q(&5-n|Leu3bxriHW&`fDGIM__J~37(0yn3Csdqu`X~g0d_wH zc3%yQ5yiHh!_%&AkOc!Q9e`tv2ixLY(t-sG2*x%y6kJ?f2U$P?)METo=#F%Ui|LB6vmo!S^b*wzZXNkr-$-{vFvkz29zguUx%97Hr55olmWwg-x*NTb7#rQ)e#sGZilCJacXMLtI#>`3}wu;@Gfoa=7M@?;;jXB2tK^-6i z>IM=>Vby;6XYohgzfQT$#8L9%iFq-UNJG-~Acp@e{;bb4#zC+#_4R4nsAn-|80*0k zVrclON+10*__OiAiJ|M6*e8qyJ-M70`xONB@bJn$;s>^ZApZE7_2I|80UFx2#{n&0 zcx_{cpbY&C{^(nS>Dumjm2o=|zsAP0UfX9+ZWMoyKT8kBGS}9&XQuP?Y)$?4J;)Q% zqhH0Jk^Qe_Oe`J~hX?Uj7>9^4cx)_cZu*1oWQfHduRqhaPeGp!spxm$|D`Cu!cQ7w z$S`(@M*}aOHWYlpvQy$o+$TbU!LA9c1rC8f{ARH67Jz)Co~^5GABN{J{T}?^@nWDL z{zowWiJ@URj|Pm5$C&82lN-pL)0@d{@M(+<@g}!UdXt#rUL-nr1Br&~!-%8g<%bVs zE!Z3w_gGuoKF;I+=ih-p#`7|Mx)8&J@jDeX@Z;NgI%zo1PoKZPfndxM#_RYB#4ZLb z8AYjTczg@1N-HnT?xuDR9*&!2-41L?`R4ZL_dfw)qPug19A zN*XHlD(*8;5km;^G8ij@v2%hkQ&~mDHMVVx9pvlJ<#plz?AbFS=<`GD`Z{+b=Pd*JipY`fARM)FW1H0b|8_UYX??D_Z#_S2=&+1v+^C6Yjg8i8)}y#IIE9q)HliI*HY* z{RqaaApR^*wr$&%(-8dYtAA?KOHol#h(7q9yD+hth1to>{ljxxczU&B&kEkYB^Z}0 zs8@>%-ux2&EZx6yMTDP(@%n~>S75+HdT`deGJb@==LBo(v3fPwbqwP}F6cKO7Z;a^ z{I5xN{)GG^-8f!-ofOIF)u=7HB=*3<@A?KoTaVdG3iK+DdoZ!Gk9qwQ__Ov!_WkoD zcJKU3y~@OTf3H{1uANNMZih0s3-bP-!XL{;8c?TVD*2E{-en|0EY4MudFM1qzkQOt zNW4IDo<@U?O#_+v$~=qj;Jbp*Q2sYW|G;soRmu`9m;H?W1M(DgN=<;j)r2?uenatZ zi2nK2cmNj1x~>hyzplLgiQoRiziNB>->!rI5BxuT`0$PQ@88G%jd1MPvDhE=ziZd7 zjZIHaC-7_qq^714{O+HI4I4K6(0*X?4-E|^Ec{#W-(Wp5Hpq3@4LEBz_HTrs6~ki? z$J*?->OO=2#QlQ}?MV6wBXWOjYvzid5gu*oLS9{2P9AOUTC4r}PvBcunJn%Nz~2q> z`|F`L`T6hr|2XjfjRP?+Q1}Jw>go{hEP{f?Z~rD|qWLR}TLQKQZ^e z`^x6eUfFVMyNdDg_y?~z=EPN&+OFuQr39c3P~oRlXb!Lh;1&RH1&$D$ z%e)ET4AATsi>UQ=$h&trEc2elwNO|$*Mg}iT#H4Y9qV*(2!r(;@OQyYPE=~mSp+4o~+)PSz5VJ2fuDRiyB-T7J~i@ zSRc5)iM~|^={3vd6jT#qYm-eqs1ryP>%2cI zAM3sh{CIGG-V1AZ>xVoXhQprpZshjs*Ce8#{-P+GZcsmv zD%R=*`Cr?*1LBf=X)CiQBJOvCYwGBmf%_xl{?K?{0JC-oYtXp%iR)D?4p=vWvU!px z|7&ZazcxL9GVtZ&TN1b5l)(Y_-@-LihTtI>94JP{GM6MEB!*=J-)5z%hwHyDVICOQ81KN+S!ymUI9Br`7A#+|&g=S&bITuL|1I3S`&@mlrJo9zH5i=te{ykKjqUQ(DsAXDD)-p>o#o@Y?#s9nV=W-Si)e?tET zwq4>mB5yMvG4uN@JwGbHt~zJ)5WHf)R1W=O(c4T|14$sSlcUMojC*kZlA*i$+QE;? zuc@Bd?+`b^va5ea8DpXPZ|wb#%4eVZQ`i5>uetr>+W4hQml#M(OC#y&e`apBHvVJz zxVDY(zg>P^^JTyC+ry2W$OA8>iWv8#UHwVYu72O?-(M-CKJQ|jH9~FWv;Dw-*Z*A( zfF(8ptWZThNW)bq3Z@JIsCocChtD?%(D+~z&Qo9@4aStQ^AtuBaPx}^@)rd-U06;& zKZF^HM2H7?154cST_OM$`%4L8Qc`w-8Knc`2pnr;ywEThXWPTL?_C)ae6N& z4aaXdhQu*F&MWMP@&aKz>&M%&)vkK}sMmf3us2QIsZ*z-Z$th#Ho~zgj!AILt_S5z zhH|!pjS30J$Ovw1IhZ%BJr#qm*T?FRn3!0U_3{Nti#tOeT=pY3^70uUNgM~Fy}u1` zM}BPu+;;;6z?l3f(2`Za1THZ9>SO-7xw$1Z^}A?8Jig+~jQMb^b2T%gV!VfAUi9h3 zvA;n&@7xlMy}@}HC-@H1J*1(o{LzjI-#U{S+u~T}+S9~}{LyAde{`Ha@O0BoZc{#ob;SQt_H3pyWf^qsrx4|Ca9i2?*AKtI{Y>!+*KJ)F;6Qayjxo@1}?-n}E4v4M;&jpHgD zPvH0#{q1oqf#XUXPoW=ZRLItfy4eOigLI>M{x!=`33-zgMN%X8lB7%9$^A1MNaCq= zB>v=Da(tOOQwENgZl2mgPQ&cwB@oTWFS5!Zf9A|^LHQBnP4&;{pM&RETwVwMy6d%> zu_4Y?pxolP@OH>X#-AoSI=U3|MBFh6=Fjq_wk!I6JvqOT6z2R5R&FnCna!M;fzLv`)Ti3=ug(*^7t9}R zbR0K){_qxjPLoM~RuU z@~Y`w!TjrE=l#qxJn5&XpLw@F@38s*o3Ermnj!^a47h=%;M!Rk_GgAuGqg~zXx_z0>lQMgFHk8^FW!b z1zJI0?T`I5*a8J`E_ejk0pVbqRk6kJ-Rf;RF>D*tm+jAb&-5*5Q=r{~_5`l$fGzQ6 z=p!PBc+~X%jDQzJfSf%bMOV`dG-!VKMPRo?7I>MSl`{ zC5W89bd(%Re#WdTpq&Q1brpP{ZLb*_8Q?=ZkLjCnE)wTLaUK-sK>eUk-t?xNnUe?J zGO?jG;r}Kz4$fIwP3|0Zg7Z}D$mOkbm^no34^QP46UUry`++9r3>fx(wtT_sqcAUW z3w+tpKEQZIv<(X1zae|}?74}!V`AU0UI%#pG9irIIc(4LIXH(EzT1MSD}0CdcIEqm zz-LV1 z!uj728&SZySV*)rdmX|2in!yiRZ~;oAqVnvr0gk6%7!wB+$FCF zpP?)M`cm_lvGR0qlHgDp@QgKOM;XKO&VY?E+?g_kOo4kx$^w430iNi>)eP>P;0b$p zLJ3N;r53|)^WhsuC>5W>)E{`qslY=Mo^_y182s$2JSUhxzSk2duY7Mhyk`$@R_5D> zQh~e?D9Bv~o<$lRndfW(2P*;W1@l&-Mgo0y@Vh18Q59F3;|cj_K_2Ez4#*8Vpc}bq z4zxQ$S>J!BL>&YA)fkSdQoWc@s(_agRkhsu@k|BYtGf&uo)`rL=jX;8F|NOdoGX0g%;j)YrRm0^5=NfmIHp3vT#g7u z8;UmSA<7Zvcnsijg#9PcT68OcZ=`7nAr9p)e30u#(W=$n6;>MY)yern($Icef@t-C z(ixBE9Ffvakp1K`z}>fl)Y}DO{vNXaw1?1p0DXTUE{Dr)x?+1?+47i4Gv7?~b$TRP zJ_PgRW6BW$eB8ZMC20v!p=rXRGF*d^sx4?4yb+g?(l>Q*G_|);(lE9&Rh6ZiWvGL18_9_3Sr|JxnyM<$ZSgTl8Cl*JN*bp2j+SPYCdQ7Iwl=DY zv;zJtB-4`rv!10jlwxdcXK7=uq%o3i*Q&9qnyQ+bD$OK=R*ltYRkc2}TAzM{`VBIm z=LjG>O_wdMk&LXav$e5}qp69KhONDwtv#I z*CSP?7?jCgU$RMqqpT4Y@M3gP?uBJH9OFAAh3%lYpS9mbhF#F?wD9iS(L?TQCTKKw zXyxH$8P?;@o^~hf+jiDoq!_B2R;FXj)jb+qJie#M($PnHuTRL?lk?5{h5m?PG22on zlq~C$<=m*OVDY+`{$3#)-W<&i?$XlL__NQVW>;TK37Gh5cIm4ofjtidn<_ngx+^z! z`H@NEG)bEmnqu1|lPp%d&0er{{^+|#V^-*0lUW|^TzLE1A}&ZL=a73T?f#jmN`)rE zErn(0`WD+5#>YGQK1y@VACdA_%S|PXRudHmK^GAb<8XvK)1BxJ>^=1CEiD`!?FRSm zZENCSr{c(nj*5w`H6vpRG8_&O7N7_>Z9oUO$lLGBW$laY1lGwZ1Ie+C$Iym3rT*g)5UiL}w3}dvxl7mK)#5 zZ%y+fVzXoa`w*A=-v` z4%M9|-6BDFM31k>cI`@zFm{%lbz94G$*T;Fi5+&nzurUR+JUDQVVl$^zh5)(QnToe zALh>}XrX31Nk1TD-C=H0_jY$DW~P}uZna)**6BHW41)G`ozkS$`&}uMUL+8GdZ?9`VekUG0PK^4hTnM;|z)OG}~fGtG_*gOQea zr;JUbjwU1KMmw<02^zRLZAy1%@1cRWqhh9t@cXCj1;A?26p%18dmh0K0@>yd` zW0h);_I7k|=w)Ku%Un&x#MGW1ipVJn_oMsJs{XzGdkMac3Zag-K^4@um8%ITw=pr6 zhnh@~ZTDE~*;JEOBj)tK+Bln5L^L`Ix29XV)vW!h_Oj54aHyq2!nSs&v}=8}Yy5oc#@RQ_ zn|u~I+|O$H`j#=T&!nGuou(ACNc!$h$JFzN&%*~OYAnrOdhTvlVWmUCg%fYC>$bIt z+x=$cX@*N|CeLXyddx_h#;4y5^bH;SOkz>fa(U-4w`C_Ri@y4umulIgaOEtCVS8u2 zXc;Ht4kMR=jf1*v?wNU}$lw^~R13eJy~npr>2T%7x1~FDZg_@zteaghEKDcBxla$3 zWtUQwBxDxlEod_H{87Z+Bve@2KNz>BY($UyT!190&A5;Ta7^>aqF8HvJ44MGEOsW_t zN+TCLTG-lKIyy6!NI$Se`hyup)BV5_0g0=;r5D!^J${LjKQ2+VBi){doLnVxR>lqv zN_~_j&s$(>;)n*)j|`NjR?7Wl=NmfTHTK~i5ZS47HCEj$PG4VbyQ%-QE7x7pPknne zt*e@Own^{n`KD3VvYp;(A3hTPTuc1L^kPdbrB3rthebXs9b{WzHCU}@mb6KM-pTu) zj=xx_c|X}Ed;Wm3pjihN8f~;a`ubSUprJ=kb19DPU0MGVai?DeJ@mcYFKdOlrS-c` z&b}L#(*_5tF=p}Qp^+sg$93JBYJ29; zgSf_iEm{D+t%B1Go|e0lEf-DGvL&`?|ONr*(zhRW%ZAcP=)n9jKitX z0KxtTR1OFl-Nj$ozoTb+0RzMV<;cOo3bk5q2Qvo~W5(t%WAg{yXh6@PJF)km8(Z^V zXB4C0`!rqg6xXv8|0z_7f)DiuE$Habn<>XpKuwvs?7!>h;JLukKcv+AO6$$yZyyU+ zQB#v7^W_e!&pOh|axER#*Fxjo$dC^_<4TEVT!{)#Q&6Jlo|TH6%W26fawjLJs%Y5R zT3MPnS8KFF9$>LaDmoP$KA*i!q>Maq85L z`1XTzAM5y7aH29k=|;?G<`bSA(k$md{=<&i@#a02&Y87y?}S5FwEB+C?B+aX?Ct1> zT|*YPy>1fzbi4W_E~=U)>oxS&dW-26tzCHOYfjHjdI?t>0ER%_F;(o z?n4854t$leTUR+`OUr<^=J#4eU%tKfl=q^{_kmGfMjs*#2e)`JNB$uRE19vFd)d1A zsy^hVl;Lg@657nnT~qx=$EZ*8J8iqfIZ~ce7CgKw+I|`5>E`h}N1BN1i$J^w zW_M28TYGYPEN*PvQP_Lx1C^`Gbf#=Oc;Mht$DOP8f4s13W?V?Kr~CI_oFH{QcToSX zX0MMfd3KYizBn^`qh+TJvu3z@oqFJXb*ieg!j|5&n*?oT6at) z-rm|J_LGzI#R-XP+O?ZdqB2&+pnsl9E0VG}%5{f@R-eU7G&y#`+h30%KCG)VgEhtB&7KC3Gf9lqUEi%y+?@7&a818$ekn$|gDeYi>bDB(pe zlf6D9oVf8RCBwH=#m-|?e-BT$=nz+~OOa8NI0brFifmD?)}Enfgf{h<@_CPm+v+pL zZ6hv8jp!Sfn)LP1Cc`FnD|X0CR%=TRZ#G<9?00y^ZQ4V$E$Dh7zMi)XY&3G6^ukDs z;RDQ`1ZEdi6PbTXk)oB_pH_oW1+ChzFY0&IK?1k*asmAgBTXE~L(d^DB|6#O)EtJg z&FQB2g_xAYC{yDl&?ezKz6Nh3B{#(x`Vku?U0X9pCu8W8#@H^lna>-PvTDArhiDJ( z_v275jzhUH4uv*$_^eOtanT)`Gh|x2X*@i#Dqhli!TXg@)7wOhIj`2DooDvkt)nFd zT}Ya4cJbEIdEASJ+H0=MabHhz_Ol$W<9N-$Tr_LHYyS-jv(mSn_8+7lnDAjuFOv@g z^k2E!9Gdi1e7bem+2bxV@4Qq$()YmCjncGInDFq5k4x}cqu^MBpyfTD z_V_k^YQ{+aLArT)YcCu~H=NnQ)c zI2>)fa%8h30}nR$dQ9u7N)Jg7+$YknYk+0@&1XB`F|?jW7icv%i_X&1v+umkuyg!w zpAIFFp_iW|d6-$v4(obUymv_tosAD42w6Oll?Zp*t$E?3 z>YBY5Z}?3d_R6CD)0_d1ZzWCJ=w|iOTt4FcmhE`4?+SXkM|sfCBoN4GwP$y-{_ zelzHrq?pZNnVajfMr4?cv*ldlS{ALpa>`+7(e{oHI<)K5K3GIbb^DO0{TYh7kH$wU zHqTDUF?@7Kt;6`6TQ?sqx_IwXyVUtx&mFq`W`(twyfz)dVY|8g(9QW)?dHHT|6w&G zzu$Ff^b~wZNq9UxmKGNkHFuYSc{+NCs3bFC=YDPghb#Px-6ISGZo5hEni6dL=FGsS z@)-j^6=>ToTdKTvu+XCr-DXa*Tcr%XHScyW0A=bUJH zy=LQY&X|+DTT?yZH>;ED3&uv;$w+kMEx2c#Zl@L;us<0Db-jDt)d zv!@?$*7`!->LLFuzO$*Br?k-fruTPD^Lx8uf0qaLd6WHgWk0L9e9^h|adz^Rp6iuI zDU?j}8Nah&{lZl}_AMw79j!ZW(NvY4HzQ;fKPi^^_Lm_1!t~+`Z+DDoes8MG_H*l#_sz{be0ams@~hgDX9h`% zP2Yce&;TDN{l2>k+ov`^m}hkCW@byfOTjh)9e0@}Pa0;hSz^PmGil8-7j7OIt~aH; zopTH2cUuOQXev3}>RdSB;A7*s=_fzUSzt5pQuu~ZOm+Q(m}>yEIM;m;Ec7U_5OmJAQNUGzjRFXipihYNznMcf!yHt1R_yOyFeR(5<7 zut)Y))3H4^$-SE?s^6w*=l()E)ay1EFUgkP==&uwUQ(lQv}j?bdc^&6Y0pJo&&|tR z{=9f+(MEadT728R2XkJxZ#{Z|w&IiP#|CY%J(5AmP3qCS)we_EZ3>QVS+wwwe}d%Q z-Z3Y>_1&ucdRCy0S=N{2C8u^T)e67wXrY!^+0Dbq!XB6)n$vYcQ6p@oIO7-=N2? zF@^gbPJMWi&S|p5_hgxczQ5;S#Yxg{bGxO9b&30?BI(&}Xo}H5o6~znC43P{>+I#> Tt~IX9KK%lVw_o+$I-C6uA_ SOCKS5 etc. + -Improved exception handling and output + -Removed irritating use of sequence indexes, replaced with tuple unpacked + variables + -Fixed up Python 3 bytestring handling - chr(0x03).encode() -> b"\x03" + -Other general fixes +-Added clarification that the HTTP proxy connection method only supports + CONNECT-style tunneling HTTP proxies +-Various small bug fixes +""" + +from base64 import b64encode +from collections import Callable +from errno import EOPNOTSUPP, EINVAL, EAGAIN +import functools +from io import BytesIO +import logging +import os +from os import SEEK_CUR +import socket +import struct +import sys + +__version__ = "1.6.7" + + +if os.name == "nt" and sys.version_info < (3, 0): + try: + import win_inet_pton + except ImportError: + raise ImportError( + "To run PySocks on Windows you must install win_inet_pton") + +log = logging.getLogger(__name__) + +PROXY_TYPE_SOCKS4 = SOCKS4 = 1 +PROXY_TYPE_SOCKS5 = SOCKS5 = 2 +PROXY_TYPE_HTTP = HTTP = 3 + +PROXY_TYPES = {"SOCKS4": SOCKS4, "SOCKS5": SOCKS5, "HTTP": HTTP} +PRINTABLE_PROXY_TYPES = dict(zip(PROXY_TYPES.values(), PROXY_TYPES.keys())) + +_orgsocket = _orig_socket = socket.socket + + +def set_self_blocking(function): + + @functools.wraps(function) + def wrapper(*args, **kwargs): + self = args[0] + try: + _is_blocking = self.gettimeout() + if _is_blocking == 0: + self.setblocking(True) + return function(*args, **kwargs) + except Exception as e: + raise + finally: + # set orgin blocking + if _is_blocking == 0: + self.setblocking(False) + return wrapper + + +class ProxyError(IOError): + """Socket_err contains original socket.error exception.""" + def __init__(self, msg, socket_err=None): + self.msg = msg + self.socket_err = socket_err + + if socket_err: + self.msg += ": {0}".format(socket_err) + + def __str__(self): + return self.msg + + +class GeneralProxyError(ProxyError): + pass + + +class ProxyConnectionError(ProxyError): + pass + + +class SOCKS5AuthError(ProxyError): + pass + + +class SOCKS5Error(ProxyError): + pass + + +class SOCKS4Error(ProxyError): + pass + + +class HTTPError(ProxyError): + pass + +SOCKS4_ERRORS = { + 0x5B: "Request rejected or failed", + 0x5C: ("Request rejected because SOCKS server cannot connect to identd on" + " the client"), + 0x5D: ("Request rejected because the client program and identd report" + " different user-ids") +} + +SOCKS5_ERRORS = { + 0x01: "General SOCKS server failure", + 0x02: "Connection not allowed by ruleset", + 0x03: "Network unreachable", + 0x04: "Host unreachable", + 0x05: "Connection refused", + 0x06: "TTL expired", + 0x07: "Command not supported, or protocol error", + 0x08: "Address type not supported" +} + +DEFAULT_PORTS = {SOCKS4: 1080, SOCKS5: 1080, HTTP: 8080} + + +def set_default_proxy(proxy_type=None, addr=None, port=None, rdns=True, + username=None, password=None): + """Sets a default proxy. + + All further socksocket objects will use the default unless explicitly + changed. All parameters are as for socket.set_proxy().""" + socksocket.default_proxy = (proxy_type, addr, port, rdns, + username.encode() if username else None, + password.encode() if password else None) + + +def setdefaultproxy(*args, **kwargs): + if "proxytype" in kwargs: + kwargs["proxy_type"] = kwargs.pop("proxytype") + return set_default_proxy(*args, **kwargs) + + +def get_default_proxy(): + """Returns the default proxy, set by set_default_proxy.""" + return socksocket.default_proxy + +getdefaultproxy = get_default_proxy + + +def wrap_module(module): + """Attempts to replace a module's socket library with a SOCKS socket. + + Must set a default proxy using set_default_proxy(...) first. This will + only work on modules that import socket directly into the namespace; + most of the Python Standard Library falls into this category.""" + if socksocket.default_proxy: + module.socket.socket = socksocket + else: + raise GeneralProxyError("No default proxy specified") + +wrapmodule = wrap_module + + +def create_connection(dest_pair, + timeout=None, source_address=None, + proxy_type=None, proxy_addr=None, + proxy_port=None, proxy_rdns=True, + proxy_username=None, proxy_password=None, + socket_options=None): + """create_connection(dest_pair, *[, timeout], **proxy_args) -> socket object + + Like socket.create_connection(), but connects to proxy + before returning the socket object. + + dest_pair - 2-tuple of (IP/hostname, port). + **proxy_args - Same args passed to socksocket.set_proxy() if present. + timeout - Optional socket timeout value, in seconds. + source_address - tuple (host, port) for the socket to bind to as its source + address before connecting (only for compatibility) + """ + # Remove IPv6 brackets on the remote address and proxy address. + remote_host, remote_port = dest_pair + if remote_host.startswith("["): + remote_host = remote_host.strip("[]") + if proxy_addr and proxy_addr.startswith("["): + proxy_addr = proxy_addr.strip("[]") + + err = None + + # Allow the SOCKS proxy to be on IPv4 or IPv6 addresses. + for r in socket.getaddrinfo(proxy_addr, proxy_port, 0, socket.SOCK_STREAM): + family, socket_type, proto, canonname, sa = r + sock = None + try: + sock = socksocket(family, socket_type, proto) + + if socket_options: + for opt in socket_options: + sock.setsockopt(*opt) + + if isinstance(timeout, (int, float)): + sock.settimeout(timeout) + + if proxy_type: + sock.set_proxy(proxy_type, proxy_addr, proxy_port, proxy_rdns, + proxy_username, proxy_password) + if source_address: + sock.bind(source_address) + + sock.connect((remote_host, remote_port)) + return sock + + except (socket.error, ProxyConnectionError) as e: + err = e + if sock: + sock.close() + sock = None + + if err: + raise err + + raise socket.error("gai returned empty list.") + + +class _BaseSocket(socket.socket): + """Allows Python 2 delegated methods such as send() to be overridden.""" + def __init__(self, *pos, **kw): + _orig_socket.__init__(self, *pos, **kw) + + self._savedmethods = dict() + for name in self._savenames: + self._savedmethods[name] = getattr(self, name) + delattr(self, name) # Allows normal overriding mechanism to work + + _savenames = list() + + +def _makemethod(name): + return lambda self, *pos, **kw: self._savedmethods[name](*pos, **kw) +for name in ("sendto", "send", "recvfrom", "recv"): + method = getattr(_BaseSocket, name, None) + + # Determine if the method is not defined the usual way + # as a function in the class. + # Python 2 uses __slots__, so there are descriptors for each method, + # but they are not functions. + if not isinstance(method, Callable): + _BaseSocket._savenames.append(name) + setattr(_BaseSocket, name, _makemethod(name)) + + +class socksocket(_BaseSocket): + """socksocket([family[, type[, proto]]]) -> socket object + + Open a SOCKS enabled socket. The parameters are the same as + those of the standard socket init. In order for SOCKS to work, + you must specify family=AF_INET and proto=0. + The "type" argument must be either SOCK_STREAM or SOCK_DGRAM. + """ + + default_proxy = None + + def __init__(self, family=socket.AF_INET, type=socket.SOCK_STREAM, + proto=0, *args, **kwargs): + if type not in (socket.SOCK_STREAM, socket.SOCK_DGRAM): + msg = "Socket type must be stream or datagram, not {!r}" + raise ValueError(msg.format(type)) + + super(socksocket, self).__init__(family, type, proto, *args, **kwargs) + self._proxyconn = None # TCP connection to keep UDP relay alive + + if self.default_proxy: + self.proxy = self.default_proxy + else: + self.proxy = (None, None, None, None, None, None) + self.proxy_sockname = None + self.proxy_peername = None + + self._timeout = None + + def _readall(self, file, count): + """Receive EXACTLY the number of bytes requested from the file object. + + Blocks until the required number of bytes have been received.""" + data = b"" + while len(data) < count: + d = file.read(count - len(data)) + if not d: + raise GeneralProxyError("Connection closed unexpectedly") + data += d + return data + + def settimeout(self, timeout): + self._timeout = timeout + try: + # test if we're connected, if so apply timeout + peer = self.get_proxy_peername() + super(socksocket, self).settimeout(self._timeout) + except socket.error: + pass + + def gettimeout(self): + return self._timeout + + def setblocking(self, v): + if v: + self.settimeout(None) + else: + self.settimeout(0.0) + + def set_proxy(self, proxy_type=None, addr=None, port=None, rdns=True, + username=None, password=None): + """ Sets the proxy to be used. + + proxy_type - The type of the proxy to be used. Three types + are supported: PROXY_TYPE_SOCKS4 (including socks4a), + PROXY_TYPE_SOCKS5 and PROXY_TYPE_HTTP + addr - The address of the server (IP or DNS). + port - The port of the server. Defaults to 1080 for SOCKS + servers and 8080 for HTTP proxy servers. + rdns - Should DNS queries be performed on the remote side + (rather than the local side). The default is True. + Note: This has no effect with SOCKS4 servers. + username - Username to authenticate with to the server. + The default is no authentication. + password - Password to authenticate with to the server. + Only relevant when username is also provided.""" + self.proxy = (proxy_type, addr, port, rdns, + username.encode() if username else None, + password.encode() if password else None) + + def setproxy(self, *args, **kwargs): + if "proxytype" in kwargs: + kwargs["proxy_type"] = kwargs.pop("proxytype") + return self.set_proxy(*args, **kwargs) + + def bind(self, *pos, **kw): + """Implements proxy connection for UDP sockets. + + Happens during the bind() phase.""" + (proxy_type, proxy_addr, proxy_port, rdns, username, + password) = self.proxy + if not proxy_type or self.type != socket.SOCK_DGRAM: + return _orig_socket.bind(self, *pos, **kw) + + if self._proxyconn: + raise socket.error(EINVAL, "Socket already bound to an address") + if proxy_type != SOCKS5: + msg = "UDP only supported by SOCKS5 proxy type" + raise socket.error(EOPNOTSUPP, msg) + super(socksocket, self).bind(*pos, **kw) + + # Need to specify actual local port because + # some relays drop packets if a port of zero is specified. + # Avoid specifying host address in case of NAT though. + _, port = self.getsockname() + dst = ("0", port) + + self._proxyconn = _orig_socket() + proxy = self._proxy_addr() + self._proxyconn.connect(proxy) + + UDP_ASSOCIATE = b"\x03" + _, relay = self._SOCKS5_request(self._proxyconn, UDP_ASSOCIATE, dst) + + # The relay is most likely on the same host as the SOCKS proxy, + # but some proxies return a private IP address (10.x.y.z) + host, _ = proxy + _, port = relay + super(socksocket, self).connect((host, port)) + super(socksocket, self).settimeout(self._timeout) + self.proxy_sockname = ("0.0.0.0", 0) # Unknown + + def sendto(self, bytes, *args, **kwargs): + if self.type != socket.SOCK_DGRAM: + return super(socksocket, self).sendto(bytes, *args, **kwargs) + if not self._proxyconn: + self.bind(("", 0)) + + address = args[-1] + flags = args[:-1] + + header = BytesIO() + RSV = b"\x00\x00" + header.write(RSV) + STANDALONE = b"\x00" + header.write(STANDALONE) + self._write_SOCKS5_address(address, header) + + sent = super(socksocket, self).send(header.getvalue() + bytes, *flags, + **kwargs) + return sent - header.tell() + + def send(self, bytes, flags=0, **kwargs): + if self.type == socket.SOCK_DGRAM: + return self.sendto(bytes, flags, self.proxy_peername, **kwargs) + else: + return super(socksocket, self).send(bytes, flags, **kwargs) + + def recvfrom(self, bufsize, flags=0): + if self.type != socket.SOCK_DGRAM: + return super(socksocket, self).recvfrom(bufsize, flags) + if not self._proxyconn: + self.bind(("", 0)) + + buf = BytesIO(super(socksocket, self).recv(bufsize + 1024, flags)) + buf.seek(2, SEEK_CUR) + frag = buf.read(1) + if ord(frag): + raise NotImplementedError("Received UDP packet fragment") + fromhost, fromport = self._read_SOCKS5_address(buf) + + if self.proxy_peername: + peerhost, peerport = self.proxy_peername + if fromhost != peerhost or peerport not in (0, fromport): + raise socket.error(EAGAIN, "Packet filtered") + + return (buf.read(bufsize), (fromhost, fromport)) + + def recv(self, *pos, **kw): + bytes, _ = self.recvfrom(*pos, **kw) + return bytes + + def close(self): + if self._proxyconn: + self._proxyconn.close() + return super(socksocket, self).close() + + def get_proxy_sockname(self): + """Returns the bound IP address and port number at the proxy.""" + return self.proxy_sockname + + getproxysockname = get_proxy_sockname + + def get_proxy_peername(self): + """ + Returns the IP and port number of the proxy. + """ + return self.getpeername() + + getproxypeername = get_proxy_peername + + def get_peername(self): + """Returns the IP address and port number of the destination machine. + + Note: get_proxy_peername returns the proxy.""" + return self.proxy_peername + + getpeername = get_peername + + def _negotiate_SOCKS5(self, *dest_addr): + """Negotiates a stream connection through a SOCKS5 server.""" + CONNECT = b"\x01" + self.proxy_peername, self.proxy_sockname = self._SOCKS5_request( + self, CONNECT, dest_addr) + + def _SOCKS5_request(self, conn, cmd, dst): + """ + Send SOCKS5 request with given command (CMD field) and + address (DST field). Returns resolved DST address that was used. + """ + proxy_type, addr, port, rdns, username, password = self.proxy + + writer = conn.makefile("wb") + reader = conn.makefile("rb", 0) # buffering=0 renamed in Python 3 + try: + # First we'll send the authentication packages we support. + if username and password: + # The username/password details were supplied to the + # set_proxy method so we support the USERNAME/PASSWORD + # authentication (in addition to the standard none). + writer.write(b"\x05\x02\x00\x02") + else: + # No username/password were entered, therefore we + # only support connections with no authentication. + writer.write(b"\x05\x01\x00") + + # We'll receive the server's response to determine which + # method was selected + writer.flush() + chosen_auth = self._readall(reader, 2) + + if chosen_auth[0:1] != b"\x05": + # Note: string[i:i+1] is used because indexing of a bytestring + # via bytestring[i] yields an integer in Python 3 + raise GeneralProxyError( + "SOCKS5 proxy server sent invalid data") + + # Check the chosen authentication method + + if chosen_auth[1:2] == b"\x02": + # Okay, we need to perform a basic username/password + # authentication. + writer.write(b"\x01" + chr(len(username)).encode() + + username + + chr(len(password)).encode() + + password) + writer.flush() + auth_status = self._readall(reader, 2) + if auth_status[0:1] != b"\x01": + # Bad response + raise GeneralProxyError( + "SOCKS5 proxy server sent invalid data") + if auth_status[1:2] != b"\x00": + # Authentication failed + raise SOCKS5AuthError("SOCKS5 authentication failed") + + # Otherwise, authentication succeeded + + # No authentication is required if 0x00 + elif chosen_auth[1:2] != b"\x00": + # Reaching here is always bad + if chosen_auth[1:2] == b"\xFF": + raise SOCKS5AuthError( + "All offered SOCKS5 authentication methods were" + " rejected") + else: + raise GeneralProxyError( + "SOCKS5 proxy server sent invalid data") + + # Now we can request the actual connection + writer.write(b"\x05" + cmd + b"\x00") + resolved = self._write_SOCKS5_address(dst, writer) + writer.flush() + + # Get the response + resp = self._readall(reader, 3) + if resp[0:1] != b"\x05": + raise GeneralProxyError( + "SOCKS5 proxy server sent invalid data") + + status = ord(resp[1:2]) + if status != 0x00: + # Connection failed: server returned an error + error = SOCKS5_ERRORS.get(status, "Unknown error") + raise SOCKS5Error("{0:#04x}: {1}".format(status, error)) + + # Get the bound address/port + bnd = self._read_SOCKS5_address(reader) + + super(socksocket, self).settimeout(self._timeout) + return (resolved, bnd) + finally: + reader.close() + writer.close() + + def _write_SOCKS5_address(self, addr, file): + """ + Return the host and port packed for the SOCKS5 protocol, + and the resolved address as a tuple object. + """ + host, port = addr + proxy_type, _, _, rdns, username, password = self.proxy + family_to_byte = {socket.AF_INET: b"\x01", socket.AF_INET6: b"\x04"} + + # If the given destination address is an IP address, we'll + # use the IP address request even if remote resolving was specified. + # Detect whether the address is IPv4/6 directly. + for family in (socket.AF_INET, socket.AF_INET6): + try: + addr_bytes = socket.inet_pton(family, host) + file.write(family_to_byte[family] + addr_bytes) + host = socket.inet_ntop(family, addr_bytes) + file.write(struct.pack(">H", port)) + return host, port + except socket.error: + continue + + # Well it's not an IP number, so it's probably a DNS name. + if rdns: + # Resolve remotely + host_bytes = host.encode("idna") + file.write(b"\x03" + chr(len(host_bytes)).encode() + host_bytes) + else: + # Resolve locally + addresses = socket.getaddrinfo(host, port, socket.AF_UNSPEC, + socket.SOCK_STREAM, + socket.IPPROTO_TCP, + socket.AI_ADDRCONFIG) + # We can't really work out what IP is reachable, so just pick the + # first. + target_addr = addresses[0] + family = target_addr[0] + host = target_addr[4][0] + + addr_bytes = socket.inet_pton(family, host) + file.write(family_to_byte[family] + addr_bytes) + host = socket.inet_ntop(family, addr_bytes) + file.write(struct.pack(">H", port)) + return host, port + + def _read_SOCKS5_address(self, file): + atyp = self._readall(file, 1) + if atyp == b"\x01": + addr = socket.inet_ntoa(self._readall(file, 4)) + elif atyp == b"\x03": + length = self._readall(file, 1) + addr = self._readall(file, ord(length)) + elif atyp == b"\x04": + addr = socket.inet_ntop(socket.AF_INET6, self._readall(file, 16)) + else: + raise GeneralProxyError("SOCKS5 proxy server sent invalid data") + + port = struct.unpack(">H", self._readall(file, 2))[0] + return addr, port + + def _negotiate_SOCKS4(self, dest_addr, dest_port): + """Negotiates a connection through a SOCKS4 server.""" + proxy_type, addr, port, rdns, username, password = self.proxy + + writer = self.makefile("wb") + reader = self.makefile("rb", 0) # buffering=0 renamed in Python 3 + try: + # Check if the destination address provided is an IP address + remote_resolve = False + try: + addr_bytes = socket.inet_aton(dest_addr) + except socket.error: + # It's a DNS name. Check where it should be resolved. + if rdns: + addr_bytes = b"\x00\x00\x00\x01" + remote_resolve = True + else: + addr_bytes = socket.inet_aton( + socket.gethostbyname(dest_addr)) + + # Construct the request packet + writer.write(struct.pack(">BBH", 0x04, 0x01, dest_port)) + writer.write(addr_bytes) + + # The username parameter is considered userid for SOCKS4 + if username: + writer.write(username) + writer.write(b"\x00") + + # DNS name if remote resolving is required + # NOTE: This is actually an extension to the SOCKS4 protocol + # called SOCKS4A and may not be supported in all cases. + if remote_resolve: + writer.write(dest_addr.encode("idna") + b"\x00") + writer.flush() + + # Get the response from the server + resp = self._readall(reader, 8) + if resp[0:1] != b"\x00": + # Bad data + raise GeneralProxyError( + "SOCKS4 proxy server sent invalid data") + + status = ord(resp[1:2]) + if status != 0x5A: + # Connection failed: server returned an error + error = SOCKS4_ERRORS.get(status, "Unknown error") + raise SOCKS4Error("{0:#04x}: {1}".format(status, error)) + + # Get the bound address/port + self.proxy_sockname = (socket.inet_ntoa(resp[4:]), + struct.unpack(">H", resp[2:4])[0]) + if remote_resolve: + self.proxy_peername = socket.inet_ntoa(addr_bytes), dest_port + else: + self.proxy_peername = dest_addr, dest_port + finally: + reader.close() + writer.close() + + def _negotiate_HTTP(self, dest_addr, dest_port): + """Negotiates a connection through an HTTP server. + + NOTE: This currently only supports HTTP CONNECT-style proxies.""" + proxy_type, addr, port, rdns, username, password = self.proxy + + # If we need to resolve locally, we do this now + addr = dest_addr if rdns else socket.gethostbyname(dest_addr) + + http_headers = [ + (b"CONNECT " + addr.encode("idna") + b":" + + str(dest_port).encode() + b" HTTP/1.1"), + b"Host: " + dest_addr.encode("idna") + ] + + if username and password: + http_headers.append(b"Proxy-Authorization: basic " + + b64encode(username + b":" + password)) + + http_headers.append(b"\r\n") + + self.sendall(b"\r\n".join(http_headers)) + + # We just need the first line to check if the connection was successful + fobj = self.makefile() + status_line = fobj.readline() + fobj.close() + + if not status_line: + raise GeneralProxyError("Connection closed unexpectedly") + + try: + proto, status_code, status_msg = status_line.split(" ", 2) + except ValueError: + raise GeneralProxyError("HTTP proxy server sent invalid response") + + if not proto.startswith("HTTP/"): + raise GeneralProxyError( + "Proxy server does not appear to be an HTTP proxy") + + try: + status_code = int(status_code) + except ValueError: + raise HTTPError( + "HTTP proxy server did not return a valid HTTP status") + + if status_code != 200: + error = "{0}: {1}".format(status_code, status_msg) + if status_code in (400, 403, 405): + # It's likely that the HTTP proxy server does not support the + # CONNECT tunneling method + error += ("\n[*] Note: The HTTP proxy server may not be" + " supported by PySocks (must be a CONNECT tunnel" + " proxy)") + raise HTTPError(error) + + self.proxy_sockname = (b"0.0.0.0", 0) + self.proxy_peername = addr, dest_port + + _proxy_negotiators = { + SOCKS4: _negotiate_SOCKS4, + SOCKS5: _negotiate_SOCKS5, + HTTP: _negotiate_HTTP + } + + @set_self_blocking + def connect(self, dest_pair): + """ + Connects to the specified destination through a proxy. + Uses the same API as socket's connect(). + To select the proxy server, use set_proxy(). + + dest_pair - 2-tuple of (IP/hostname, port). + """ + if len(dest_pair) != 2 or dest_pair[0].startswith("["): + # Probably IPv6, not supported -- raise an error, and hope + # Happy Eyeballs (RFC6555) makes sure at least the IPv4 + # connection works... + raise socket.error("PySocks doesn't support IPv6: %s" + % str(dest_pair)) + + dest_addr, dest_port = dest_pair + + if self.type == socket.SOCK_DGRAM: + if not self._proxyconn: + self.bind(("", 0)) + dest_addr = socket.gethostbyname(dest_addr) + + # If the host address is INADDR_ANY or similar, reset the peer + # address so that packets are received from any peer + if dest_addr == "0.0.0.0" and not dest_port: + self.proxy_peername = None + else: + self.proxy_peername = (dest_addr, dest_port) + return + + (proxy_type, proxy_addr, proxy_port, rdns, username, + password) = self.proxy + + # Do a minimal input check first + if (not isinstance(dest_pair, (list, tuple)) + or len(dest_pair) != 2 + or not dest_addr + or not isinstance(dest_port, int)): + # Inputs failed, raise an error + raise GeneralProxyError( + "Invalid destination-connection (host, port) pair") + + # We set the timeout here so that we don't hang in connection or during + # negotiation. + super(socksocket, self).settimeout(self._timeout) + + if proxy_type is None: + # Treat like regular socket object + self.proxy_peername = dest_pair + super(socksocket, self).settimeout(self._timeout) + super(socksocket, self).connect((dest_addr, dest_port)) + return + + proxy_addr = self._proxy_addr() + + try: + # Initial connection to proxy server. + super(socksocket, self).connect(proxy_addr) + + except socket.error as error: + # Error while connecting to proxy + self.close() + proxy_addr, proxy_port = proxy_addr + proxy_server = "{0}:{1}".format(proxy_addr, proxy_port) + printable_type = PRINTABLE_PROXY_TYPES[proxy_type] + + msg = "Error connecting to {0} proxy {1}".format(printable_type, + proxy_server) + log.debug("%s due to: %s", msg, error) + raise ProxyConnectionError(msg, error) + + else: + # Connected to proxy server, now negotiate + try: + # Calls negotiate_{SOCKS4, SOCKS5, HTTP} + negotiate = self._proxy_negotiators[proxy_type] + negotiate(self, dest_addr, dest_port) + except socket.error as error: + # Wrap socket errors + self.close() + raise GeneralProxyError("Socket error", error) + except ProxyError: + # Protocol error while negotiating with proxy + self.close() + raise + + def _proxy_addr(self): + """ + Return proxy address to connect to as tuple object + """ + (proxy_type, proxy_addr, proxy_port, rdns, username, + password) = self.proxy + proxy_port = proxy_port or DEFAULT_PORTS.get(proxy_type) + if not proxy_port: + raise GeneralProxyError("Invalid proxy type") + return proxy_addr, proxy_port diff --git a/python/sqlite3.dll b/python/sqlite3.dll new file mode 100644 index 0000000000000000000000000000000000000000..4db8b777b7be350ba75d70aabb72eda6058f1b2f GIT binary patch literal 1153176 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 z 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%0AQ5Np$4T4BUbhh(iG+ODzV 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

kX_GH=u6 zwrsGUL9zutk7*I(Tpd2WT|xr-;R0>exBMF#Qx5_E6pIGLS&`?d5V-2RB1Jk$-I&h$ z@K;hvoBr^*Yh-(N*xJTapWVF*ZDfR?M`|rJqzY@YuN=lJx7F@m5lw56KuSg@u54$? zu)iIhxUjv#sLkj^tUVYr_JHuyAzTOG_!WR7df01SKQkUV;2)_THD1?C4_|0n|856KULGOMC(;?$eos>clt(FVd4LgW1@PYT{W(b+s}ctswS#HeX%0 zi`Sn$tw>d!*)tk`u69oh+6A!c4x_r!@bk4}5pQPmh3B3O7;jFp{{ObFn}Zeo^$4F| z`Z%+$-`%-ip}kRy_aQ3n4W~QMBpr;?2$Y|_%yLg5>T%*9iF=GI@hLXrIE^XYJu@Ef4EP{Y7uVplrs5Y_A(V|Jl3Krd&w z2y{)fE@CO}p=GRZX3A^1EK`fKGGFlcCZl@r|5gy#mQ!|HkKze{RnNkb5bpTiw%dAk z-J9v)q{bW`2yFuU)4*?u%AL;wV+({M89#`lS{G7~t7DB5{;*&~$y7bjU*f%fcub!8 z6G4q?+Y_PRai1=0S&h0=9F(v!B2Wl;XP?812OEA8*HJg+s~JL z-PbpTTYu-8^z}2=BpUbD)dTaI5mTFPI~{tN+b(c-)*c~Qc4D8(JntuOh)l0zKO;?S zhc~g8+c_k=!!46lIe+!otm*okzFCMg=c`BwlWG>9nWGP;iXYJr4Fr3c%u?U+jR&!Q zV~bqY9tX#v(rRXtf;ww?HdaNY>PUBCwc*WTVVP<^Rdz_L@}J3QZPoC_tMg-vJJY(% zX@jrtI@|V;ql&cAb-J$Deu19r)+Z$7$ZDnZ?S9&-3q`E&-PZMvKiZhsz1&q*|qR+z7v;u486kfb$=n;9|_+y;JXcqas{g2j;?ozqRX-n1$ z4CJ1T85H11e~-=dKN+sQh*&L?%zk)=z8as|HxE-{T}sk>x-P_QuSzRSmTCYu#kR}T zv{#%)khV^n$4p^`D`Yyda3)CP?FR81SFF>MAHp~zWFixLHknV8aIp*mc5@l-%(!K zUW_$@2s>xiQJK}=IVvZ00X^)O$>8%1E)^E=Hv;&>2A}HS&j#>>!7Cj6{s4ZB!OIKCOQiF?2rTp6i_@51auFHRA0Dr*Xviu=`G=R@G_-QVGMF79d;Cs3JMFD)Q!FxKm z_fEF{RR(7+sQiuqeu%+`xbhzj;Jplfii1xN;Gbgs5t%>6!Osfd>kWRggC7yV+YNq_ zgBJ$y-x^%(0QK4QcD9~(8GNwI|7-xCX7H$kKN!F-G59D4j|K30gZFafpB2E5F?h(q zhXnBb3|{5RDGlKH2A3d&dVcX%ww|5+)DJ}t{`Ua>lEII6T5fWKvMxvKHqvjX^1gGXHcBLeuJ4Su!D-zR`SVDL!}{?W#4J!czS zdlAZC5x_4q_<;`ocmN-3@M#WydjPL8c&)3?gaCes!5bWWXaMhJaNAR+Lj3~xr~9iP zWU)kjzWGPCp6d;Mwkzk20N!r!n_T{91Nd(Zu1LU?^I!nK%isq%`1Ali&EWkV{K5c! ziNWjLcaIC;^#(uD!TSX8V+;;h-~H&#Z2k8$c%94tLIBS<_y`AoFo1XNr+zrc!KViB zmkd7Ll|L?k&o_7<2Oko^A2#?2uAI^Uo-p{qF8}5?vh}>i;Dz3@(Ek#&Ku>A8YWWgZB&IRR%xKmGcEE9lxH3 z7<@OE|L+03m%)8J|9AlZbYJyD29E{s^#=FH@xlP!Zg8I;I4*$y*5E!}>l485GI)in z=ez5(^_*sKf4)5%z%McQl`jA70lePe{=A(Kz>hKbnJ)j(0KT8W4|4F*0G@B~AN%!L zm#t6dKI#XbPk1(fzhrQq-rXC(=NsH#Usne3hYfzZE59~?Ck%dugZB&I*BIQVcVE1g zt8KYtz#-~$bQpeuiR0N>N#B@TX80N+ZG=E!`XPdFlgzh&_KT>ioU zzSQ9UdVJ&6Y(4*Ma3A0PHGn^0aG#I5J%GxX;g&2Jqh++~=1* z`g^uMcNyHrOD_cQX$H^mKLPv_gZp$R7QpKb?$d>a0Dg?Yeg3n50N>Bx-*ffY=icfEAHO{sz+W=BPj{vV@c9P!`Hiyz_`?SG>GBZ)JYn$59A5h73_c@Snu8^+&Hk&Q0fNH4U7r-{%VlwdVc%t5zXe8v#gDsOF*+by2J z6aPdPZ}pe<)|kv&`)A*}$$#tT{#$uGNj2`{4P-55%#C!Mj{C+4Kljys?w5HI9mq)x zTOQKxzbx!O-%vqNq(o>OVoR&#@02ee9p~{s22`Kiz9baoLVw9GQ5inX^Ccs@b#LMx zntq>NLGPLhEj%BQLbx_`H@(9F8U^*s_}BZ) z{Kzbn(q*qbtIBsv&WqQYP8%bhw!xNk1@e_$$+RkwU^R|MxQy(&6Dcr~*zUUI7m+01 zXQv?<9p2QC9NQ#!g~HR5#}SBs8S#35foLjq*vR~CV5v##<4E74WCt}1m^lQC<#{t>lgc-E}tQtml27V8xG>-f1^XQ;iYQ2n{) z%M)%rgj^W)Rh?fFzWvA6Sp+$HfeTZYc;A)?S4c6z;WJ=l481{%-9_QKUoe{*Qj^lS zeN4TvJ~gs0hcrAU3G|R;p2?v(w@C7)a^sAbdwb_#owdTT$o6-4sJ_f5=0?uiR8Lu$ zrM&=|4Sy@8G*6Abgw*F&^sM*VQc@#4K z&31J(S6l3hH0@ivK-Rj4(HEwC;}`|_xc_1XboL7xS0|(-&c{WlI88}%E>t^%G556s zvUPvN=1*?jTjYD!`7^<@Iud7EDN|q$y`cbwH;>UX#F(4wR;Se!HCSw4o)v^!y2<5q zT9p!aH+VItncf^v&a=ph zrQJAh;4k=6I`r9D;PcdhUHSpju#oKRMx(D-NTIdp@U-a@GB|)a)q0|OGadTyA(bC` zM?WIEP-w;W+oc?Tco7rDa6;9*$0#eDI#-3DK>-8APWKj?-%syG&}gwf zvrC_J7vT+`^c{JWhD1}jkG;@7p&Ky7^Oj6d7+y{sm%ZEEN7Ne{l0{sws5z*B6+&Zy z&Ha-WOFFdonHt_uAN}m8rBPh5acZzzJQ~2q0-p(c9sC$gjzN|7GWt5g^MJQ|YOtf} zP5S9PXQUaZizdK(3GYhtrwY6bA4fd}vOk{pwdcE>A6c`%9-QmVL~)o8-EDHXj|EXs zrbFkRVQm?spPeY8tv3(@EafQ7kES zXWq{Ks1oi4dNF($nME&J`j-PC0xZgh?+bBb5nAqzK%wxzGR>Fbt~|LCt}tD;{g1Ms z#ZoSQyP+&}eGkF%$pGL{0E!Fr7{4y0QSrx`lbFWWf=E%SxBk`MVJ_WnUlgkQ!}*eO zJlJ1#`c4EI@xmNbc9(3-HAH3crqa#vXzAp5v?LvG>c?blDkl+VjJ?{~Q8V_R9F6~I zGqrB4;KHNy;(5JfQ~je&e4#D=BOHs+AFV3ow4>1-ipfP>Ng3hD&_C7a$-$w23nk%njvP1aT5FSV&5S?A#|wOI!AApdgjPfyX>_zROQ#LpJ_K7?CrK`}8< zxaKO|9Q8K4it|_lFx=CI2#K6oW4c{w7BoS!CTxYV>lm-MVW1jP^QY1o4apk#jV1{C zq;U<2D7Gt6{WjrfhpjYbht+Eo_Noc%p*6Ktqp{N%U|l~N3^^jIGa?$2__AwZ9nJ%B zC#{EYA>WuLoFf$rZf}lL(qx1W$H*VS(>P?Hb4~lU5oP3<$^+96$EcjR}b4M z?QH+HYlCz%BmSj;>*Y^)J$~`wt8k4H2hcjclCs?qHJf@QYzc(tZoSIwVX=bb z5Bh$!mJz*mH}Ny(_^vR})+^Dk)_1K^h7DaCd>mVn>(2~hz8=Q>Atu*gqI+*{uwIHL zE?Uk1nfzZ8tvZh=>t@Qm91wfi(Cnq`T2ghqTMM3<5^;7U zuNjtTT&;D`@>{#fv3jNON)=vp(adn`NFnvAi)@i@94EGm-P;j!*O|q{x+|^ng`!+hQ(ee9x>LI4hJ7VsdbHwCduL*r_^_4%4#1FUuQY^F&(R zCNEJ>wVM6HL;Pfw?Sw#6rLaSyLb2Ca15cjVKd$?JmrD4!D<+994UIWG(3w8VzU-CX7(JFtMUk*viuP-1b;o|Tu=ktlr!X;&I z6Ih;25zeQFFNbnXEBq`xZW+5J0T#pX8(`sQ;qyXIkaJ@AXim7U=Uq2tQ%CHV6PBym zyZ$u8o~IgKJDuvh;??QHrizap!^zutOL6*k;$mjs)qNKi9+YLJ1MV(o+w1+$m9V6A z023?sLu;-tC8mOLd&Tp{GDp$_mhxjxZ(0+w>J87`i)uJTCZhNq+7BKQkEI>#`9;JU z!Cs$1HK))#-elwdBX&yV_tStn)&*`O(iZN-UaW7*>TJ8R|NnQH@5mwXFT zX)Q2VrkT;?;e$8G3rR&)~X+WCwW5=lPGzs zG42aC9T2|x5k3)Ku&G}-u8!O?T*26W15D8j@NdAMbOdlbB5}cZs~-}GaI4l0{*ePf z4e~Y1Ihv9~zPwSmz&no4;f*9dW5fgf7xTK(%*ky1#9wqjJ_F;h)-Ub(Y4psgQD>&ec*(rS9*6<>h#Xq3 zI~qDMBgI0?YSHH*eOowjv^)5ahSXDd>xEm?XE33M|CrcAb-mT_ZV(598E-0KzABbd z-|srV{Zlpc5BPa{f*7^YCEKD2C(Kw#@ zY45_ZR0#?ciWZ20Q*e1n8k*P^XL$L{-YxtTHg3ls@b1xh$*-dXQq@Y^X9owMEE&&+ z$G^z}60Fg<96~$?W^O;t+?~VYM-!#n@h+Ta0rDXP#B>R_o=1Dl%D+>#CO+L`e0C)- zE7z2$^%;?)crke@6ZonU#Vj1Ao=u%rsZ(7mxV9kKUqtu8ia#yOKQP4JoRJnDK5J-2 zUW}u-2!-)2aZ{6T))5_}AJNe{A9LgM67uwRc|x2yiWr?!{KQU}cgUlhMXgC4-~@GM z4o68?d^>pTRGAfiHz#Glxm22j^I+|H9~!1j2_Wt@{V3-b0d==ab^O6i0w z56l5y;(;UHe>!7o*Gw|ahM&DwU6cGbwqM!4X8zEjl16$H~dX{ z8xO=J7I_m?2~P8UkZ0k!>d(RHnjtqf#RlTrP!2zH2m)akPe_0Ibx_4s|DzpbTWpGC z78t1Uf)h0_<*9h;MrANIE!=VvPffPbAY9KfjwxY_kt#ch?7Zk5WZ7BNV7X(J-LaTM z^g@kZh-xAjga3hdSHah5ypoZS=;W^7v&M{;GTrYuoOfNr2U;m*`)$-NqP|=hrE@ap zDY>!ty zfIL`Kuc<9ShwmDVQ;^vD@a079?j?3;VOKQ1I$bks`=oHo0^0*L z$W#=&z-vmp$uBxI{I(wCS3|A1s1;*NRGr8Z6Od>s3a>0IzPnUyrz!WZTs|X5$AvIE zqJK*xb69e(ds?J&2pEIcZbPbc|Ay+$(^3wk6YF|yngi2TIIBkv(9z~T{XM4|jGTO{gETtRb3 zR4S8n6#q2X6c)<}Tw`=F7M&_FdnN|!24%4Gu#&|^7l~Y-E^>_&P2?J*a1O#^!6jsc zy`yf&7M*K{&r2*retZ8}LS80xyoaKh4*PIGoZ8}+tv{JFcs5x)xhwep8_!|w^ zep#onyI&%G#fplidq$IcL@{!vb-2h>#n49*-)$pLn}4Y>nAE^@o~)CaCD_5voj6tM zot!OM=l32^pF20fHovcT#A~f1O}TK_6Kaxn*(ch4eP2%oMm`>6PJ0Ji1}c6z8D(Ztm)KQ_`1lAhWmvImZ-p zj2MHw#$<=3uZakCA~}@jD|L`$10vRMfs@=g$>ACvN@Ca{dQ~>q?a(z7G}67J@f%Be zgy-J(bH>cDX{zkJC(x|^{qJswZ|8x9($>=&V+52}s)e(lR`TumrS6w{Pwt+<&@qnb zQSAEEm~t?x>8g?|O`jn~V48gj3D zbnQFQ-d$Zg?RQ}5kfts3YUiuxB`d+=kc zNIX?o1Vo`6IOflEqMgbA-V-4LIro+8kuT$VIktbgY~^Q6Kd@tTNxLb~{lvJwAbdUbyb!imu-Yy%iae!Jn-27yBX7 z^YKW=w&hpjaD%vJvLhbCocCJminj^=BCd2=7_$URhu#OqBHqXkHGSwQ;oarlyB7*S z7cV`B7w)werXq<5&F7xXPx3?N@qXr~UFIXsC-bE)^Y_Tyk9#tg@k8eC`I+Y^Gi^2W zCedv`2f;@Q(0Bwn@mBSwf4fZ*kgF{SF#DmIm$}2oq(vE5$HbBlkdi<8o2&ECW>ZU? zLJ@nap)0=5bUEq0mpScm6ci7WN_fP zmpC;kK3>DU9z<6zWSAJeiDuqHErb_Qqd1AL`7)Ot9wmcJbcSy8^{}qB(dUtI>Eo?E3ME>-cc+V#ebcZ1_=e@pCO;~&*GEBD8)U`Fa z^gdPG;|_+PDvEOTI?KW**dRkNIgMis*L+(KzzSMW(wERVXGvE>3_Dp_ICauE#Kfu4 zn}0io;pvvT2$2@TTd4sf6&QZN@zfCqp{7Z6%vHC_m#MbccgtQX6!~A~&1SDbW(K_5 ziB|W}bIr=Vbx}Q|B%IpUUTGYn>b2~zo7CBkrZOoo3Oak;oVtqJ3iq{Ik2AXf2@5&H z&dE12vH@Eu$FUDJPXKEn_QH96#|ve`t#?(-|Sr@QhYhf zavRe0HeW?&(dH+;PrhV2q>87U3WGc+&9(pf1Mbs|SG2G3xtbBlkrm7g^tky_s{s)I zs{1_exle4?F!F89w{`wdZ|~S=$*oe-;!iblU>>`ngZP$|7aG>{ToV#gOOvl6#ez$f zIms|g8fJ!X9l^thPCkkxBK;J#(Qtpzl`BBg99Yn^x?_4jE~b@Mcg!dm)Dih=9g3d8 zFGs%GoNi+QE*jLH?&$ib@PB5{6U3WtOzsDsuxQioeA8IKgxhL*g-;3p9F7lB4Qv>5 zV@?0%XF%s~qN0)NrBlYaaMRZwT|ek$3@>_wZ||YE!cU!%pBg^PLQU@nfWXbQshel5 zPN!=N+7)+Ntto0yTxsSOBHhNsJ__|lM8AWz-RisOnazBmdU-hBi`QM@1>xKOppUC? zg_Z7+`NGqJRx`C1aWQ-A$GjPCc|pKTxa$L59U`;aW^Md5U9e2`v5FLQD$sC%HyLZJ zFVL>AD3>)P?{u!IFH2)48701zOCxDkD}sQw*oh3J8A}i^X{i^j7cK7=ZwB>sduR@$ z08eqCqIgGbTzuMXbHv}TthXYHr>$oP5?_|~CV!*Zcw>>#&agK8$>Iz3P^`GO`yVh) zRM;c#*mjH`!b`c^4tIipJ*xT6qiE)>=yx7D)HQ=n)Ak{gk3HQ^rI+gw)^NhxJPNm5 z>RzeHz(J1&ztF+QWr`a2ouVrB2sTzxRe42QjM3mb*RH0WvuArx3f5AFIGUVU)XCn5 z?#OI0a>h|??)s`>udUFI=}p6bz9-~1yGhPc5qzvPns~;pcWh|#PWL?A`ks4v44K2N zTilIW6>cqbO;nx3t$VqfNh))9=po7i+H^f_nrzRD-Seq-bAY?4Azvl`hZyh>2h<>i zTaUJzq=~|Gf0DcJD6(1;dD7jl$=sh~_c@*9`ec^l`#j9FHIHsz>E;nJCI`&qdZ$iy zdsg;aT@VGVgA<`@y`cWRv&PND!(9o@8;!nYc+gA!&vMGXv@R#^MBH4OnZO@+KB=w+ zclt4*B=$5@ts0+Ifq;rdnf3>Syt~5pkXIzwi#TW6+yYma!+q@&*hP_?qRNfXJE8|Cvu^da&TI5OAM=|@0E zPHeFgZ@b&C$a~+9vaH=fk$LiOrIU|)T#f1Q){S*6oxR`Ho#6*|kQYfo#g z$ta8WqX;k7Q(oBJM(s|Z>dp{*pNAcn`Tnu)^jXPwz5AVfw}f1b-ApbqL-TktfAem;6?lC+6Ii<$@ zQm6B)FCMGT0kiY=j`0P2SoRjyH4>CNO zO!|;RCXqS4mi~#`0&EsJuF>}nl9)IJ?>2}@#Bu&^wK9iI?)qfc{F)0$X9D(Z(eb1D)+hJ%R=%xb ztpm;+yrJsizB7&@UUgA)JZEC|nPn_&sUoMV;Gp)Sd*n$kBs_w)NS@oim>$q@t4I_R=*{C=VKr*Ezhp-aA09qD(|-k2MQ z|I|@1s+2>8hL?1{O~erw|5tK#CjU(aUYW;kWsf&gpv9R>;q}@)lm=$OxN+;=Q&E z%JaVbP^1-ItDZjYu_Duz*StqBRk2sny4m zp|=L@W3#kIbv;h(fsd=tx94kwh=0shT}Zt`AeusWCa!dLX7R7|db04-u4i_!u6&${ zrCAM`);EJm{)Hi6xkmf{W=dE*^C(DmU?+Gdx84=R0^;Nnn>W4%W60YgM<(O3jBjE$ zFroiA4C=T3`XuN8;mpWRd->&Cx!yG z#d7ay6Vlj9;rJs=sEchskAb@Qn=do!$PZbIIdK?+c-BoUKq@ntgR-cJZ>`!!C4N99 ztYVFdWj#+aN~~MClqsuBTg{X;hHhNr*uxmbM$bFA%1Cd^)Ay*RjhmPye;q(Wt2@Fi zj~h%|sxeKreAWpNUmyi%9syeHaoH=MGwB}sOqkynZnWq@>iF9Eg*Higay{k)WyGBvtn z67NK!(Zn@lh{BzSOeM=^mj#Y7(gZ!*=~#FdrP>jHcs8~*IShc1r|Q<>g@#gN9`7Og zA=Tz;?~ku&HDr1Ce}OY|?0j{W#fR`;*1T;ryCFFQ<9A8TKjN-FSyv>1MXbBX+vgua z2Yq2V>nhp4`p0mrv|~6H+~za~ZFg%d6hi7kuCPg#3E|em2IlRM`*uI~Z~W30Txl13 zM3XA5!dvl}8-5ucbLa<09Ky#OprVrpaX#}=Oj((QX~2nkUE+Q5+iw*d)r45BA@W5m zLZ9``O7C}QyNR3{-;O|eHy*ZbiJ@LxQeT}8-;NGDofS9zOLT80)Nkg{vT~EN89fWE zpRiuraF^;hDmNrolIY-rIOuduc<$?ZTCmI;cFWg@S)3>*c3CY4vn3TD3(lkJ+>#ml zHw;2nP`G=2x-DQq8mdQ@Ovg&@^pbk)`x^*n-HGPoMAH-5&FQ#WOj7hF#*7 z8i!XVJ)VnK(58p>c_J`SU-zf%Kp(GWx{;nuZwa}x{? zGvPIE%-_r&eWFJKZ{fmeHuXlDJG5M-8(0B~nJ-*$i?V7ZYf>IY+f&he@3Yq}hXGr@ zCI@A;9AzET;SG3XyN+NAx8?)TgED*2NO>m3_>q&u#D?z*^>piV2?TG7U z+~ihFH7d;wj|=k-mw|0qtVn<{i!92IaLYF&h@6G!_Q$aihnwaoHE&?cHC>}?CKhEb0;nwgH*6h@S zWWsb4RgUznPes$Cl7(&21gpc|#vC+0ssyU`LnkVV$@TbyOang8${cfezAXO2ZnKW{ zE=?F13>NC`xf+xl7lrb0%RdB5l^ynmX5nh@up1m2OC5jN!9c1Z`DG(F*t7a@?MAPF z=XE-HTwE4rjzu=kBZ?aG2W6$!GU-*Rj9VRNXR~iemEA}g-X~WJ|90C1IgZh-ON~TO zxyESgg6-*sfk$hndNc2eXWEM#;g%Mwvjhvws>k_SB>8P!^_StfPjC%tH%*0iCCZ0} zfruoCcKDg9#7=MbhN_z|sQ%n)`0qJYPQ%&pj}D%s0pQ0Tap6QAk(x{_P|X-zC$z>- zHIbgK4(F=eU^1J62L*NvtNYmeu(X8>&sKA8S)jZ7{e_;=2eI%!gmOT_tOevN2B4WHncm;ThZCU z{>;VLi`PVLS|)OVF4Ox1x^tTmZA7NdIG2eL?bzcIJx&$>v^R6=Zj46Vocd2D ztDkBn`6jD{C&>op|7^0lQ#}@cp)JvJ?^mD+hPlSRpTo|MEi#ex=%|)}??Q8n&EwJI z1lpPJ&B{u5elWUeSJ^YRSI*!t%g`R4?oGWPY#NGHw zgf8yM>%04}|J=Pknn%1|s~j9#eZPBspk7ahRvm&XHSrVq;o)Qc!#-Aa@x!X*vlwPW zDx}xGi+eK9;fKsu_?b5jQ$>mkdy{#t%PhV27rR^LkNF|<_x#LHDsx6^MaSgowQXmD zKd$y8+9Sa(z?`-`X*E3F3RvTHhK=yuD9!IU?|Paj72=gt;7m>c^R~aC@`dLmOOgsZ zb+KdnO`VNl+71V)q;C%v<`pOWr-i8j^;O@Q@q~JNS6$?I>laj5azx;Uw_CXN31GHW zbGBvLF67uL1?Rh8TOonnhsb}DUpJ(#gZW>C;Y6&Ufshj8VTIdn+P6Nrk3>CVV)|OF z)_FU0AxV*cA-N&@4avL(IMc8@SnajkWVOniAPAcNX+R+{F@r4b=<7tsijV{4UmTRX2wo>4?nPtFtGa(s><87Pn;O zEIZmU;pmu}R!&s<59{WD5va+FL?xv^(VwQvhFmYMc9ZJX`j{#LCN8H`t@|-KvM8;4 zIyiEX0-tKHM?7%4P%M}oQ}cJdn}(Ai7H9?^Dh`bEhs0Bji60s?hn0%m2E4U*qj)1m z_&||3cpQ5_6xm0sHguAHMDn~ZUfo8tSH73g2j}o+7D~B3NhO$N%mRz|y}rKveU8iI zP{*yKQl%YH+3Ru;Ud<^+U5dcx;nq59sJ5>GcaCunVm;LL3@L0s>-Y% zj@6I)foaVdbvaw}&}+|##=tfqU5?L`jp0jk7y_}8uj+zvY#=m@7>kv5e>xa^t+(lZ zP5EHg?zc6VJI-FJ-0c0ReUpQByZ(<$4DgY zGpoD<72w1dlU)x?4o@6YI>mpy-Oi+SeCwYC)5AY1ADZfw>HADZu4=dIq5NgE6+!;0 zYS-*)&FA*ZR%$i9C-Z9w%2r>1%|=035*wfn(=}i&%JI8i{r^*rTrCBWy#M7qlkuf? zuIL^S^%s$LT@p^g}oUEPP8bH{L<- zxK3pa{2&^SVi$+Oazg@PxI1}$aqWn=IYtCESbf?{y`~hIxfv4S1wsd>hXfT*0OH!u3}204u49 z_C%b_dzXVMMBa7piul&u_$qmk*moi%G}H56a-WJ6EHaVHqIn8;Dx8$j?@nu?UhA9p z@E&PkgcBp0glG1Ijy2gXgdeck1&h!S`tLL$$vyGg@4HX{>^{?FW3K@%Vs18MK{`K7 zX&vdZ=YFhU8P1>uDZIzyL~X3(xI{L;VAd;ojV-odbNA_!ccqjfBE6fr~HR! zxQ8d6Y!55>;o)rm;qiKyVLk&qXo}mi>FwabbW?zh-@jEWw(N*E2U(rI*Z>A{8e+~- z)iWeTx4mwed?m5*F&X)t+oRLnP8c_eDb!cJ?{2YqGy3P>V&t&vU z{o(#Y=Hf4zi}{-GJJaKBW~5fua;VA2{X)`VNfxH=USYjT9X z>7#zxaYfre26an@e)<>qhg8|r+cgEFpe&3U<$L2(?$%2w(z|Y@W=Pf_A!8Q+8H}AE zi}2y^XC_zdNRvIS_I^K|8JU?>S6Pd4=aToqM}6|TKI!^MZ8JOuZJ#6>Z*djm;~-f| zonB0hDe~HUeG2&X8jEU{Zkt$j#K`8a%ubetj+4LTjpRoc`0M|aX!XMDPmZRJYcw>= z1i1V&Y38&ojd92T8f2zLhj#>I(PseQjdt{m^A3ZovgY3o#vtGaKSc~EWHREtZ1X9$ z&5B*+J$$rnQ(FIQ6L3d#BH<10Vy2%ZWC1y3s#l+^nJf;x<(Kvf;yHEz_vjkl4;3wS z$o*q&xOhC0J8bJ2o|_VJTRLBXtETHEJ{;f`;oMZ&gEr^u72he`+Nx@%ipO05COmVM zu#s(5|HFQ2iZ#w1_xa-Y|BL-p78iNf*->g88dFRQQ6TQI<7qG%4Wc{mBX^H#>pj^n zqdVK4Oxq2$wGi33WbJLG@$T{|3Rbn9sMxsImP8A>qw{LrA4eW{gy(kLLX)pp${EP* zZ*yv@*F8hc-o<(&bmDI9-fmrwBh?$RXnVSAeW1$>{A?yilh5{lh|X5;Vnkru7@WAi zpO>8N`{m<}e;7R$2`?DfyFPU$4DE97+H!qW?I)awYLskorC^qcVrJIRJ@Z&4D1lmS zCOOUD!^aE8}uW!Gl@Nm7xSDgHMH0MW7q{ zr8TBpJ#uqp&w5IRzW*nM?h#9b$^^Q2oAA!KzIc4sq`evWPInTg1emBAOohvAD|0b` zX!3%-=?*xk8f5i`;swN)K1261^UpLi9Ev&J2DOY+b?X?w!N3bv%;0LP#zso-~9B2vju zQzC-VjIR_6wws2J!7pZWC43McHsKGLI1(2t6}sTsV{GX!@;?6Ix9P5rvtyLuJLbTw zdI^cN98x=p75Eb!T9-TaE&!$X$G5&lQ`ttJKYoj2H}VGQMc>W}E;v4{y%1aOaI2am zJ3dEmcj%k=u;xdoUh_m)#uAB6W97cc}f;kE(#3W&3F`tuo|XSZ5QywlpZp=#qW zTDI;(nRI=A8!3)i<-U4E4)E_d<9@dY_{49(X~we{$_0?K*_x(1IWnCSP=nh%L&fL#CN?H z-~cdC@$}yx&93Gbq=R3s+B;>d!9f;I? zlP{f%^G%#SN}ZGMUCN|D;CrAUjgc@L{WgDB3S*=>iwoC#N4=q$l*{2B%58bT@N!P! zccK(z*j8+q+y+MRRt!JU^P#n$WcQdA$q&Exk|C!nl zu8U6PVlo%78dcFrAdElU3_1wcjhWQ>`M6wOGsEXtK+*C*q#V5K{qFVb7=&9B8qOU? zVDEo30`KO`Y43-w92hHSum7Ejd}kmtGzGDxXjZE1*4Y+ob6i|g38fPwQR5wcrt>+^ zAk*A6@Y&6(ZrRg6-*F8Lx?-m_;OCpUQ@(;AUoFSCMNFIj6S@FRcX=fId=ZQtVOBI} zI`<|NFl^o-^W=v-s3W$gp0&19fmEc2(3XFS;}<3>f!`B?%Q-`3-w!m*HeC4G;4iUt8Rcm|U!o<<2 zRzshR`sGC)4Ep0Zu6NxZ?%SzfyS&IC(q&UGU@^uAOa;cTbz7#618g`<(K($J7NJcx?PoweY*D=I-;g)Vj&f&Tmp?-8v*b{Wd?$70usN*_S`D;3}QNF7xXfA2xf{ z;d!jWMSf+hUqdfm1Ch#bYL%Ve&+FWHoVA^z?N9w@-$^d(eD(k^Tskz(eeYWTd+vEQ zzpq#Mm-l#Ky7ACzTd^WtKg52s`Tg%@@6)06-&p%z=4VN$ZJQi!oD5ZYsLy=&{7HNM z5YNTrWeQE#S7t7)NZJEa!_stNV0qu^fwJGT`4Y`mit-at`~J=R(7)+Wz5Cv9e(b)= z-5;B|AL#B6wfiNij2Kn_1OMqBbz4w*-r4y+D9IK0-`?+{KT6=1v_`CowC{nD*514M zvG$$!wcVe=k88iXA8z+cBIPEyfZq`~9U5fdOn0sbp6}(J_ulb215xS5!;KU7L)^U^ zf}PtJP0k)ems%FP%5<#%#c1NL4k(84ih8urxZ`YfR&b8$Wh|joD89|AJDs20B51*7 zdXft5wgfDf2#r6|xVe_`c6X7xJ2m@Odca;_!}NecOShb_>#3GrZfU8(ceAwHAa9?i zJb$-zv8D4Y{hg%`T6%}2vn;*V(g~KHV`cK2ITIrY60P702DfJZ5veQ9ETW>7$qsAh6@1>iStuD`1+_mz?V_ECiL9M(tA5E) zwZMtc<8#!uyGdQ!Zs*Fi?I-?Krn+j|9l$U%sf;E{F^wobMKwN6j>+PTR#*%Og@EuY z>5oOPpprFyB^OhU_on*HAB;b!QaOV$%vJIy`bmU(l6^_&<3y&CA8@5gB4Lc?U55<= zVapIJpd5_?HSiwS?M~5X?b!h9BT*ckLQ8lrw>i&qPjeXK(tKIy>*X%JS59tHy;sHW zltTq$*H)fx$4ZX#UU<=Ljj?=hizW(}bs?85u1wG!r+jPOp#jwX!jJfzT%Rs`K+`n& zOgA5quyhO}7IbatvT1@dipNTigl)Aus(}nLxu+}fURWYvlWr=|9jn-M*-2KMLTF|7 zRW%B_VdoL^wL$jyFZ!AS$F}K{O-Oz4-}S#&6?|`!jE9jxII z{A}OM8wB@h9>kb@pJy&|_Cq|&-i+t{>)Jb-IY|*L z+0LJE4sXNw$k0gm>Dr>w##A4uP+Q-If(`@hCJ)@kRN>Ob>WH2mk{8nATpC&xOR z^F+Rmp>gkC?B4C^-NNMW+Rq!wJuC7_1fvvLcx+o&Pw)5KJV9JM(3QRi@`->)T0mB= zyi8fA(=nhVy|kA%+}-r_hH=sL(f>!7T|q}R{)CdmzcpZkyK9uz2{!=D zm2s`j*C9NXrU$!Qn|tGzx;Gb{lXYL|XIOj&u>>;{O`*AjyKN=WDV%V_urm?wOm$+y zgK%Jf=*mAWlL|69UqgYpxB&5^`CKr(wZuObZ`@(h)E!O}BQwS*eD( z;mO#IUTon%1n&95hWc8REqg2*}tPC{`6abp2?jCwLgU zI6y-8F{Do~g#+>5|9O=D0ownVC7r#cWt)<>4agR3z@~L6i+BFBHIgX@Avg*XEJjLn_Px|RFJ6i<4J#dJEigU zSdSm1B|I`#4XsMeI*SYiKNSOzc0fM~Y5LkXX%*YA^YvIl8PJ#-*v%^136e+@;6nkC zgnW22*HIjA9H`b1Wxnq#Dt%ke~>n8wn;kEOdxl%Af<~ zTo%7c7NBA8T@1QkK2 zhFlVJW#NsF8s!D_2B>x_bP5#;IyNhk+yqWw(&ncRU0vKYVUdp(^*>T~Qhyh0qTXWN zEA$*ygKC9(+e1Sqi-}YX@P>$dsVaYO+DIWrl36RF1}JI=^UQ+-DN}u?Y|8)x~|j}x@M^kYvC2JuKE87E7Idv z7aB$|K|aDDT5J*f9umMC8O3D@HM_1g5LvCPuxlk{3E#p?Q=s72i8i<0u5GhxyKM!( zKJo5UGBX@m2c#2Y+a2T!G+jtL*tp967gdFpBv`y~Cx;3;pHPH%ziamcA4rvsbZ zRSeJt5J~?*19>V8C$t(R3p5VHTGQaKB25T-i#r} zBhPx|fp*W)cGI5#KYpj)S7iz7;KImr)Ya2RQ;JU0T>usbOR&c*Y6~ExvEVg3l2V%t zYT~_7OIU&&zVgJfgxPRl;u}soge92Zh0oL0S8gdwcmPhU7QBI*2N%tZftY2n%U!gH zVvOF5;>?6xq@kB~H`4sm%*{s7dQAQWxD1(~|3#1RMtaj& z$lsy-?Zpr}18?9xEDo8*5H|65FMrGVyNg~#9_wD>0!{0mjJC4828QK_zzn9&M zxF&>GB0b*WZ+i~^h}~y6*AnjMNt|*ehd;vZdpZ2?>`vrdyE*+A{QZ!>J30J$PBTY` z!(Y80R&e+U{=UxNmHhpHzj{B6zsc@LIOQPz>TvXaJ~fomn>b|?j$O&_V;p{hzfCygBaYS6>*0Gj zwvNBExSsmB9AL-qE&)-D;p5eCW^M9}2F8=<9zwhw(@BGc@ z?+X5o;cpIqbNSnmp_#bOdb{*-)aS`6u5&An)#st!|9b!AaBWjKwj+PfF|=R!`%xD4 z*b4r>z~5*1yPv=7_`8a~uk*K%zfa>^S@{v(0l55+PK+!k1PKC!r6xvAs~ZeS-grdD z_{G;mK*)w6n%CY0jzSKIv*}d_TTR4AuW6`3A4NoVM>O{OJ}0liTSa6U(WKaeQeryY zxa@{~UxoY@y8fUpGJb~5`Yb4oWI;LD29+rh8lFVAExn02f5>jwpa>5ZLx3c#o^GUZFi-Yz#4~hm%yEW zmojWKSZtoQi{o&ccM)##I^&_?iF5k2pY;l~qY7O5^itS_DxkXASy_vE#rY;$e(;U3 zP*@hSsKF6Q1(5~lxasYDxSPU*c7SffUA%Bap_a+3|fENVW<1 zA`o2ZN3)~^1oRfV3o5f{u?|{|b;+eQqPk29_CmjBXQ4h})F+YeW1%D}M!pJYuqB$M z!ay(o>!PO9tvpyue|8CRs6#E+gZeax%<(^!IkfM#OzF1aL_r&v@P9ayCsjPTvDyX zBbVCLJoPfw%3~JNk0QNx+@Qp4b%lCIzJa}PyiV$Wo@Or?X7|#Rgz5e>dU4<<(6x~uq!fkmCU zOuPVbJsd7=UJ9)Hcsi_uDm`7`jU;y*4Dtap+2ji4gX&L?=k`^JZoNs>h7`wPu8YB5 zj35;Mbrcp#&YnQsQ7$r`p$pvJ>+PW|2w=DkzjxAGwvYxsWd5U`3~TKXGdVclgP^7J zx>FF<$Vj(|$Lmpd;ZmK);k5n?%NpGDCm!i;5H>w>kS)r)MH$;gAqUP(5flCq>!;;^ zM?baG6GsosPkuya}Z9*d^M7OY3k)0v9(fH5Uo71xoBkMex1ftkL=-k5RMwc&a1GhIc1? zvsz+=>vSeR_~D`CrkFvP{wr6)DAtHK&qO30`Fyhy4bZL%C0~Wua5WU$Oi*ka?4_U_ z3fhiaX6T+X;Pa~1J@cVfHqQd;UJ!gRHQ$@y4xI2LSoicAri3)B}b^*3tR>3lkJ{@ z+8lID(}!8WG$l3m-JT@7wwV^%ONR5TD(oW5B2&@tcHD*6cDRBMqL$n8+rUIPsjhi? zf$i++1W8gF83Z9yjkwUPY6=acMGVIMT4%`ANsSw3fmIq@q71iS`-9MRJ56I4vlxi$ zNG#t8*^WRJ)K@qDDKoBtm!Pk2e*t~n949fj=fRDEioBO@kOzaLY?U<@Sgjwu(gO5< zAO5_+_H!}y654FSi6LV%ST4x&D+^{L$;q^+>4u~qj*LTEUFJ2j?zsW#yKAYOa1(qi-RK>N{EkmX-K{qSKG6 zp*g7*WrHbWQqVMkEPYxJ&Zxm+dHK^+RB!i9R0klct>g%qKjhFa;E5#PWF^{${xMFl z?gS?;XzquD8}aIBA8?bNjke9H?GoS-N5wuq;%pHw&!Is~bkOEIUgv^3?P-I_rS0;x zwP{(2?uogk+Wju$E_GtLtNSkJ#M0qfyCiIrNuZNdcebqJK*Sj)M z$ku!0^lFwBP@OK3&-;GDMdEg;E?W2Qj6*Jn4O3j{JKf6AJrB9GPCX##!h0cmPEGGH z$yRX8P~#50YCwP4w$L*odro;zx-{g*x(B~!k;U$Tdfe|n#^Nvs zaaB1E##)Iz1u?Y+<}?N$Cn=F*sy22q4EN=UDIyXnq*Z{kEFf}@jI9L&ap)~pUMSH@ z=#0B=F;5qB8Z1(YLlX!=fC4=8GU3KMfq-|w=uDy9M3@wo8hvHpqx_*P*>ls`h)lYf zZ+*!%1Lzkl{0gzL@LW{uG;jlwP*4ZlJtgsS7OnMMIiG?V!((6xyEn#xOq8uS8Wzd} zJvcurj~B|6SS}^dp2K5%L!oTKQGJjjfn#EONum4$^@1L)^+=ZT!WO{(0scxga|)io zt{;CkB7$!8kNgEr5L83N6QilZHMAeJb8DNO+E=tYo*3W8P$*YWBG{>&10$^%u9KLP z{RpS#s(AASmvmsNpjZtWox$-y{n;?<)g+92*3jy{M9o`&_PIhNp zX35=2hQSLkFO;V#FHH!_0qh|U;Mb*%ROMH25bzWDb!)0Bk8nViDu09n*8bx_nNP9> z~xL~9@D%9>RkPHec7maco z%flur#ckYy7&Bs!LyicU(!wTO8dQgeIt|25WW>#o3TOIO;JR~8<5m}*I_L(?|7=`e zOUw?Mo~Dz8ug)~*7fA3-c+emTDW)CP^SG=PsxoXFE8VUDks57+-U3ss1yVjkalZO^ zB~XPP(%Z5LuK&N=GAh(^<|U13$&FD}G^-126oxw4oOr0K;ot<3qzy-%>9~Ed4T4IO z(-t%>CR;^#dzM?2NG+nn&|$nWO1*%%UDAC~yS6Q%cCDqMX>1oPJnxz&<%fs^ZIF-s z>LY9+dJ_-nO~kZ=z23-QHnHnp4A=i`A{_)_7pSp;c!keKL)MqN-nJ+nKel)qj)>$i z!NDOUeNBYNh}Poer>)a=5eZU$QG3f9#_=E?PLGY_BASVD7{_RPH&7fu+Y1tv<|G>V z)&CmD|Ix_L{&F1A$bx7iOX?u+7iiSA{RH1 zd>GG-u*bD^+V+NV{F4?YaSM6o64WSC;U)_C8>qFFS)N3jPPumTRd>QF_rlMlYa3r( zB1|G+PJ@6=GT0%}%GmA31XL{xEQ2)2pP_Jfcde{}}6~bIFIE}x! z(!*}!FPJHD-WJ0{rW=PUYg!HrgV?W+_cl@1w(J`=4b@uqvEkz9!rf;uleCSnKj&!$ zagN6nY!x<73M%155M~{RE^2AP%2Rz?OxQ@{oz^{bR?3@E1w4kU%8f5!OIic!1DLxP zjG2M2?lFUB?^YatfXcmz_!v3h0qj)#0!cxsuK$|O@B8p|Wc=(3J~0q~{bUs)qqp9w z#F=C|eif_QVO((9FY{j}>7?KP#I-=6e-T^-%l-#@rHplJHpP|lu>q{&Melo$P30bj$8+Y_= zPS=sry{o62iFAN)Ctwrc=J1O4sBWR00H-74gc>mqe*~h=6D6GR!X7Y$v^|t|3qoLJ z5ypx`$z7HaDQ#Zx3eJDNxx6u#R?@Vq6oWSK1^Gqq!7uFl?6`3HdQjUrOK?Bp0*w!sKM6;AbyGOHzwaEn>y+i5c7& zZHHQxl}nYy@3`o19{*}M{>9W0Be_X*=7~N%Stq{ei5p2UwGo`TL$8I2Y5|f7&$pmx zVtRr=ER_4nLk7bG`#3npLnxGG97AN$7LI8o{?@?X$SpvpjQRtYZ%!i=Hi-`DHXpv( z#>)8HGw3}p+?r3QK!CF>Cy{FI47LX?;JKPfxa4SEAgz7_sWGf?Qc~ZR6qmJT4w-me z5XQa#@ceU_9vitT(Yn{Or$Us!c2UQw+t9Jyv@=LNhK7t@6UA8_RQ>o7EIOy|Hf&81dUg}@K>9>ma{pY}|QUb5Af4iu~=>+Ry@=NJB2p6+yW!O5@ zuvmz7f%Q*|XI9j25$Y_OA`v+W;OTcf6%#VQH6F*7F~FLI@&g9!K*i`-Q7CO(5x&sK z{^9JuOO;oL&qZw3^WLV)8duvmpmOV3xYxQy$A?XtYne$@pX93g2RA0PUzE_!3GK^F z!5kC8X#(=HZMYSI!G>TO9X4vFWkI}o@U_#pCp>_{n_;6EEh9hTbkuU0ti|tNXUs9t zCV?|uu0z`{_jB49gkw<%2mcoYr}67xPD_R$H#BB9jh5w<-Ly;=;}@yy!6$%ZQIIUU zBw1NB*_ZU2W5T1HpAE*`DQnV?W{|xESvecpFW*5L@!PaExP~O}L4QG~mRf5XAvZG= zO|Hi;N=k7Wx65^KH>RM>h-rmsueEU1!%>->YkCc(*% z7;ry74W`fwbg?y8-ggPaN1_lPpx=>czWN8A>g!>fx16rNhvFYY8S3rIGkC8Cj$z6( zLpfxer-#H7uLycjdAfof4=c~~_ua^JrN~=7IV%C#~48I3TIJj}je++-6xS#j{a_nNtVqUae-_BaYD~55*O>ly5 z^Eq4b_x7Z1V8vS6nP%etC(eGo`9a|9d=L_JEZreHa=;GJ@1L!3Hf{x9bg#=`BRb|6 zmSK!unsFATj(P`ZFVy3h1&q&iaMwQ5u&3dMZI#H>3o?s#&(NM0kypWBx2i3rt&0W= zeB!O1ALI+jO0iSlrPvBF3)cHwV6*ZzwF{BrtAL(=BvO!!Yaoqs7OA_aqJL+~H4How zed}_AnH$@abfz!wOq7XOx0DZquZm7&S%mhd+uqlU{}m`NT6tV;%&Is{x z(d6wIa>zBiqXuCZYb_I3fhOYa)r1nbi<07nhS)CSBw(634n>J2n1d|2(ZgOV1WgIq zOY$@-BaJgQPJphQsBx|KfWPvTs$9SEl+xOsnkdiqK7+$VWhA-xwJcN$)b+(8I)RTb z0{%(wevok7dK9=-tD!=VP;3eUBgtcWv;zknmOsBnetXw`k>qXwp-vQ$6ih#o@~Y?nQ~u6)284t=qu&2#rGK zt@+o``4>`Q-yFnvnk}{miXkAT)0T{zd7K~Dcn#$^(^*RPp_j0|5?su!*Z~Vjy!vLd zH@YaFfJa$Va#2-&l~b`xP!p$$-|aL(A0Uvm2V?*>*KH@sh2+%C#Y?$kW>%wP#sIfr z57W^F_2$n=quCd?8=7ff+D`FJ;dYDbU&&p9$BSwVp=O7O3Y?Zn@K;by- z>6x*ykYI(@_ubS;SX~M)SGA_9FCXF_e;tEWBzxw}PN?#77LuAzElD@P#w+X$&hBmqw?Z-1 z2!Y>L0GM<1VuCkfCBAvfdDQ(sR3cE@wjIq$+54FM5&^EviMdMP2wZXt$3yKRGkct} zG!Yr)*;op{0xu$R72J1*E0~=t&vE(+u@sN;z+w~U)5yrlVk z#Iy6L`bc3U5IISz)?O$-5S zusqyPBpjx$A4%Eq_;2EQV2n+Q ze={ZZ)m`vh?K0M=>2;$15R?0hR#Aj?cK-a*Fa(p?`A%!yJXmjpKIw>o1R;T1iEuQG zI!&dz!;Usq3y-iL2GXPB7YCQD0}Uqz&%I=Lz~#qL5|8Gh+jO8GeTVGES{{TTdN4RU zi~A&rV8YCQ=Iq?LCWPiviShy?>d|PXdBT^pY0t#BP=1M;S4PU0+iL4-cgln0!vQJ@ z6J(|ly5(psXp=Y$K*k}$yJqn^HB~p6bv-EpVC_SGQzahA#_|Rkd<_X+A$HK;!;NiH zgt}S+iZj@h*a`j%fZ_~xmZu4tZ+?!1rJKBlM3Yz@K^d~ zjsx0!n+gpjPd^3?g!Z&%LdiSG-CTE{B{%gV#`FC}j95~R1F_umC{YZ*>Jd-q5ifm< zvT$rHq)M55~~s`vk0Lx&9AQo0_M(LOixcEjelu>2IDRqLO+Y=Gl^$n1MB2)D$Lh zAE#MAp8E{qc}ZKwaP8hmio72#Cy0O=R<)@R@7zk2@(zjJI*7~%uptEOZUUy6A6>|O z;d(!cbbY$N6a1nn5O<;Mg<9hMDezU3x4cLCEaomq1H#^ohj7Hzk5K;+dc~oEjYa>1 z0nbT=Z2Ehe@U0sRv57v%FtWzqoY)tEF{+#_@+}n|qQMa?RW!%x+m!3Fo(Hc7nkN19 zR$s*R$k8jl?Q>#8?u{fLg`-f8Lulo?@47PyyupW^Y35KqDgO%*;;#KT?m^4pq+ATI zu5RJE>T*2`U)_A=883sc5U-~u0qo=C3yq8uufBdRa^qIW7&7?avU6YyPv6DHK@+@* z3uM0q_07UbOam>bN62DhuYQA?J!MLfXla#&*zS}xL z##v3}z@oT+A2~wFW~9X0CP2F%CO{i0TvxA3_=Lp4iGW;b56+$J3fb_e`G!QPA;fJg zYj8v66K)y}aNxC~-&Jd^w>hppc@rENyTe8YT?{R!OXgW>dbt~n=+^)N?0zM%l|TXg zLYjQF4fT}?0}!B9XPgE+8w&H)r+e_}?QL$;YNKIpt&X40vRSLV&0KoA@F_RmUeoqN zbtVkUr>?s3%iGsC|MZE8C1>eMxxpJ2CcongfN0azKV zJrX!=Q|$FF+&Jpsw$|FX93?Q6s;O;~x8PR~lYO}fuwp+74*3K{`0A3B&^EYWdD3b9 zdX7mA4UHSBY-q`KiB&|tj1-}qTIJ4SsD9YAl2giE{VV7&RD4Pqhs$oQ@yNXV2#I`= z_Vcd#OaTdGORoyq+FR@9U!zVeNw23IrFc(+f8}N>oA35z?ACUqR|UuB+Kg3Tb@jJl z6SJ)|7;=pub(az?rIq-q6;BJ!sFwsy8O1*l2j_zN{`e}-{sEPVl6olXnd{%{hDYlw z=2>w2)8?=6G)K06dM=xB&#rp9_JjEO$LXHFMJ*8)Tlz+fa%$9W-NcQjY|33GG!SPz zOGBa_21Ct!@Yvp*qbyv6!r&~NGouZd6seKO$@z9bu*hAgtUYc_YN{-QO9__XTYI3P z`s4eT>J>pviHu)?XkR^4#pv?*>5`hynkarZDrOIQQhV8PSEirMcOgw#`Z@|)M^^RlHXl|9Zp66L zOKs_U+*W90;NG3PgeZlq1%nd%d7A`w&p#A4+O%Ev^i$eKoAH8c;wiiJj7=F?=9*aN zJJW3L?O;S;{?nzwd0ida4$Qpf!$PU=I6@Dm3b1E$LaFyNK&N%zoMY~ZC1I?&4X(tv zhD2^-X+t8nb<3P;PRNU z3AE#o$b;tQN^+D06oIvyW!T&mZ?D8ff0jiH`&ug!Nsjx#l$c5;g z`7Onc%|jLNKJgB*9=T)vypf{74%Xwgi?=vV?=8rz0C0;vHOD8i~Mq=m4#> zq%OLm9J#phHm5srOK{}kfYo=U^B8oF5QNhP>ww8 z?F4gNjkd>zM;~kE+q&;6IAbtW&&P|8n9(|7EGWhO+;c!Blj-TWR9p802uB|jgbju) zBV)^PhQ`jI)KD5yD&667OVaw~UK;dASc1 z-+bH#gS$g~#lPD{C4T7yw26O-`@0UVNOB^Yp<}qYlj+5ZRBD1==Q2Y#)L-#G1V){5 zXF}DFsRnr$+%V;AiGX*VD$gRmfb-;{4TSr&`*LLgLh*|&{x<4}H=8`=q!IXGT2JhF zy~=pqDtFS*+Dm8;q|w0eaocyK#T-4qA8Et)vCJTK5vDblOj$CX{5b-Z zz^C{EjVViCqyB~%LZ?&ThY#f`0ot+~*5E&>y-I+zO7$w(x^Kdw{HV!{S+>xuI7jAf zDc&Zw%$e=xJwhb#R?!y<&N{!6aM&s6VgaX;LiFt$sMF_VQ>Q6@VyS4QF<{EVUr`Of zooallTWl)Nzs83(iYLQI&3M4VfpFr5m*VA2WkoN!t=hexxPw>A~nm zUo2V<+S6&>qC8Eik~5M~{{asirRATLu+84VAm0PLjGswl6Nt8a3w(8Z6Ri`zC+SA?MYFpjD$iu^X27yOwgqco4{u z!a4E*4LN|M!Tl5842hNFx#hAPh=#NydO+J`C&^`gd%R#`{sT(-A#+dqQS4GB0S}J; zN;G?ni$bg}gmJZFr%z^YJ(q?PPFznVum}#Pb_ZlWRjdu24?m5DJsZRwMx*iw=1>X( z!BBpAB~Hqrgy--hMv-fdia1JYrgnj}VIV0-S;CJZ|AEu!9P2iZQ*^gc$9c0@U^Dh3V)mcw#e5ow!p9av zqx>VfV=b&RXi3l<^R|Fpgpb6JKy_h_Ug467R4jqV>HsflR2oU{&HwHRDJG0lNQnkE za{i#zP02HdCBlR-tus7FrX7*n$(fmhzy~=Ha1P6l;S|fak{tUzIH4s>jkiBf`~(_D zb5}2QfHQ?Vq0=}zwa=yO4Z@8=xd8Qy-qd)s1#!g70ix?{h!;BjE0NR}-bMo9uSPDy z_0Pixz~vrhZCpp`mOMtRrFtC_YreS_lS<|Vo^4IU$|eY%y^5N!DbE*d~yb&Ly%X^OA~`go*g(Z_k+|KSwyu?ilguJ|1jgzk<6 z?^72W3ojq1&($1ou`!RPQwCn(xroWBl{TmE8T+X!JvdiOf z+#)?QvHhHKG6RHZ-GqI&b|CU9VF)UtEPNc>-zk^UOVEMJFpikyIu5>{+KPt)q4D;3 zq&_l2TT)G>4%3#rNp(?!ZWXo|#yPD=ruBDe$6eaoT)6=g7zKMI#$vZM`evsS2c~4<|u1EF;FY))@}3B0UiTvo#4Us zCL?a>Dyx4-Gna4zm+@ERw^?`1IRK=B6IBV^o@BSS2|C#G%%R~CB;Q2qz$vTx`d+5eQca7w~=>1~Ib!-rSm;BPX2WmV7 z3Z+o@cUiYh`A&r8RF~Hec>PW-7 zaXOxf<_B{S+zyXuqeoUg9D6Ma3<(BoKKdl%glQ!WIArzhIu20+-!poTZJ~v7FZ`9Z z1!pEG0V1%VRSaoS9JmQ`B4f-E@HPvd1ZL87s9zO>zklt+w32%ozL*`VhUxDA{ts$D0j0=E7rn7nRkhdt57~d{^%wZOGS5;|F0K? z>GtrS3i?JcU=sA%E-Uf|`01utqT+vwqv$cJy}~e%^|b>NISeF-_O5A-T7EN)El$2QBPopb4bOZ! zai#uEr}s%H1^It5OMkYD>$(#enBUXWhHu}pH21b6Od8_BF`$=CK?~iJsbh5q=7?oF%0EQ$$v`z%ZmPUlu3vEeVm#UEw?kA z*vJ&h_2kD9IdB4wsGYZ?Ktb#7=gM+=7K2g?NZkkb3GlsiWxq!Pu-M9`m)xjBVs+&e z1A6~1x;H!udTGS})y&sD0(=a@pJ-n?MO#D{H=h8$V_<|&vRHZ*)t1SC2R7GwAN?5p zl=%c^>s=fT_H(xZ`s`Mt0W`Z?MZ@}2SR~=|S9z*_f**MkL%OV%zDS*QnLhLLh0@R&nAe;)w?0njE?Gh(h@`dt#$iC|ASptlckLKoUh7Vpri;yDJ4- zPj|Qihh{ddJp_9J;lvDha22zxfS83@(|hPg@7}OPt(#a;{N0cNk}WkjG%0v@3X3(h zQXE>FMYfcP&e-^B)rnQ&th+Hs4GLFQUvPzR14YjmZlhHc9K}K#VhbkHK3Wp)494G& zax>N2H!I07x2foLGnQI{*nTrH26R66E^bzIpR^^(67ok9{ptvk zZ6}~&)3A0xzs=)^D??*(k$baC+u=&zj$`>y%@m&zKQw5<-KE=2?({#rKND-pUka#B zyfhsmhfAx1k;*2n^c^4~UxKaxY|Gd*Q|kfLEkV$GlykH9C;4}(OZw+mVx=ogQvfFm zB(5Zq;;Ng_HMK`%XZ$*~Eo2SCrGbL2f#4hmTOe9oV@8tDa8QkV)%3kktAMV{SvBN5 z=S)A6f2|gmX=?8IS+l>MV#~y5y7@9NN8~<;fr|KGO$-$;v&S)wLonrvFun(W(%+md?RAM{}ATV$f{_uv~@Jl)%db{NlNv zaY#NuVRZD)90kNNBbMSKEQMLwMF)Ma4qDbz@jJxPT*7(TlqHhjc?q*e+bsLTD{3vY z{+3fr$h^B3Mmw;9&iT=hG#dZu9P$YlI58`#aeN(SYXhCsi9Ei%selV)L*ma495PXV z;YtZ4UYznbXN)(|1_3eg&T;4moci;#)_Qk~SnW+(ab^T7yOMuk8hsw0$J z@N#y-)>VA=KlWI!G#JRIxkeS@6WnVolpgk(uYHi$&E%J`{T#Z7 zdcAHSN$UAB8oet44Eo!|bOT*bH~$E@m;i6%Ap#dL>hT=htGEN>K<`qB`&YEaeDUVU zuK^h(cc^8S{0UB(41iRDKxa6@MOSQ~n)!Jh?!TgNU$Q{!<+MD>HEg5=n-iSSY=I63 zg;sq5x(DY-vB+EjE~A+D1uejblW=+)m2?I+R^R>4bvVCv&@TznU}dU7yz+z{Qwe;@ zpkq7?pkMgGF|#E$aCJ>E#)I+@mgEji!B*o>tp=u%7OI3ctj=w$<%eIuy}$%3OOmHJ z;tp&-I@fO@{Oe|dO@Ruoz?&%I-<`p^CU%b_lR%6`%I!>5lv=5rMjdhTUrh0C+OxqO7V)i%cihl`zWt4Zdx~?tcYS`&9Zs8H6sZuWPc{!14^%J~e81NRN zQ|0Z0pn4d}xghW$CwrF|+H9%2L4&lc$%jKEcz$SKmxoTEams zm8F$%$p7M_KQSLNwc!JQ`c7?Qsjq&}{K1|9zWN&#|2v!^L-BtF;J*6)iob##Hz`ZK z9F?goHL$}fDQywB@8A;E4~7a4F%p)J;>e-O(u15YTk-E=haCcu`gwTP8u9X0PL!kg zKjk=8@vmZsQ}K64RLJ%z?)}QMluCk&ujmd>XZGE~NikPWzyZcfv8|*o(Pk_zg#~xi z^5UQh<8O+1rUE`32b#;J(9wg9COipj^d{w}sa9{&+-_>- zeM!XFoy&~f!Cxi8y3LxFH;X4n(0+7=A)9}hz?CSQgG$_uN)*bWfJKIA&2yTxGsr4R z78?8#GRw7aM^V#Sq(>9RA-A|^DD4R?kPQ^F*+Dd0D7iBMY{me8pvpBIA;p6K68>9H zfxbKoVVYOi4b`#Z;e9A~c26wVK8z(hK#o8rk@~r{DmqjU&8!RgGa};bcAZ@RI}(v* zd`!m^+x%;gSX@kHmJl4x{Lk@Rw~f70!G10iD{MfZyI9R}ulV^r+Gpv=<;jyjQu;qR z3eolu!-ya+RqcX&l|eUZt{#K`;=7o$$lv!Ax_Ze3auF&qMdHe>;>$jpDSIxJb;M z46H@C*!3}Mt)A84z4Sa01N$P$AHq>6sj=wSyHJW4bi01k%R}Fb-$v0?8Ve`p1VqF* z7tn6qg69G6*3ggrjz{Uw?veYt8RT;|te!8)Tq1P3*1{u}en>NC6`ZQJ@J)n6x4T9S zzClj;B7!Rk8{EWeubOhh*Nr|M=+lNiX2uH5!L$z9nv@oiOuDqF8Glpg>ywJ&e?iX+ z+A9jgfvk#uZYA@AB2ttBTC&Z*Q}JhU znlAHOEB*nT`6|WV3y$z>K50?>T{#Serok2qJH=SH72damVWoB(R`$yPAH zi;io>U9by5vM0eM0YGU{C;nRadmViXB#9Lj|NRWksQA^G^Dr7-QX%ByDg|E_NeoiY(>Nkfwz_7HzBq_7Q-KIQXseBSMk>%2}An< zj_~^havujD;b3(2ZCqq`Pn&{zGk9@|{|t7vqV`BsT7X zDOP~e#`>DU;#r4?We6Y0AmFIxtl};VDUpcfT&T{Yq+=|z0f=V#7!l&7&8QL)a!rw3K8oh!a51Sl z7`j2Ii&MmIg#GDVfIsDupq2lo3`~-}Nv;MYT__95A4_VZc;_xN}QTsYj#i!##R9i56oZLxynU8u4 zg~o{d-tbhe`xu2{JD~T(#L0G~iOqsE)T;ISz(SceNF8aZ^23c~vJ6f!Jyz7Lp(yGP zd@gR(X8383dTShG#aDWQ0(%H&9rQ#RMosK`jhf{7mNZImSODu)jQ@#bxXmecb$9)& zmIn`r{d=zkfvca@%whekmP0XoR%>ygE$xB>In54Hh=|x(Et}jIA1!cJGjn|GtkyM} zLJ4GWcq5;pJNY9CM}zv2td80v=9eN6GY$_$KjO)I1XOMTsNoONt0=h zC(A48W|Ve3|oI z$`R$5aI#qT!JqIY{&cs$OzMMHZlJoY%Y|4KtKh>CSOu~*$qd@!VrHcXmY}w@sQmDv zGq#V#9$YkBMR+yq0j%Fjt8duT%Rfkho5b>rA9f?6^c{*e-w(Bp9A3j9vsI zonibzEes_*vJe9Y9^qALTo)x!O@R&6P@&ujKgsuP4TrcmFX%Qt$!1Mqa`8HX-)kVo zg#c7s2Hw!5fQ1eQKzVF-;R9Z?6^0icu(`x}}`h92vt?APMlro||bzy&SPc z+VKniiiL?iSIp!f!N^IuC_%yf7HcpLpu4*aegp22|l4<51Q z%V=YA;VVlhLljUR&e9WLaI?qflu{0$gzl9@>D5UZ5|niJ)hNmQZ)(kGguogARwD>~ zlI0Nl=5`azf#51??41(X1f%GLluk#r!C^FTQ5N$Yc${FJ5FWT2>I&g|)btCut^%u7 zKR_9&WjW;GxMKYEn^f8Y${8{r?1=J1t0-h)Ec>6$>2;$a`$hU$WPi7}(gr5}BXSmU zpvJ`O{sh%(sL1>90Mo>JmsHfUT;SJ6N8`dmoJ3HWqd!RC0 zjEjJY;q92JZ`7knnL`sjZP)z`COVRgla|ju%C4E00x+h; z5u~E4Bn$N-zC@%5KiJX`?hviVt&eg&CQv;dKq6u(==vSv=6CppkPJ& ziH7^{8$m_62g+Bm#8BA5z952oaNuo;%!}B92-s^{;7y|O`2KCa_q?bTCovzlkR9PY zqB}(2I*IPZa94;oQgOR9s!(v8AZz9#BxRA%9?>jM7ZhwoOxTEx*BP9UlyS%zoNr;N z)PBr3suXnBN&O{Bq~1ddL}w_!z~I~iouDwZ+bq!Xx4~Q&4%sGex6>QRfYe4dAZ24a zR5rFlWmBO%Fs5H5JPhd)|985zW2RmRcljTXv@y^#K69@p$5sS|O&Z7beY!)@Y?pXz zuA<+mtwAR{A(Egv@;=f&I;X;BzFKF883B%?Mv{a#Mp$7ARnbVrmcpkzY{Z}Xgo9&K z5%zT8C%WOeT%IKVdA1woGv+HGT&s`GQ+kYLI3`(J#L!G%f+$FD%q?i)n(r`F2VM#2t^rRP5BBBnm%=k5J%rAd7H9^w|GY z613>7PbJMwf}NaOEn=~i4*649W@v7vm-qa_Zn|#JTcfxgui$M6@esjqsfLIP}SSTwHB|2j55Xu}%5VXCZl>2cn(!9oNLXb?PI74?> zRO7zI*x$ciWWUPdG#-Iea1K-)N+f}guK2G!yy71pi4{Nf2F5&X5L+qs?U(<8 z4`wa%7@ZIoN!1Ez9HHg{t}px%Y`^7 zUfP{JxAOk;ha2VA^#i84&Pw}XY*sQaGl0A#OawVPS5Mv^)dW>4CM6R)Sn;<)itwgr zQzY9wHm@L%?*b&SC(k?0{49b{W)`gAvi8`Qx_^H*dNrGNRLDnU7GQx}VuyG(uzO}x zn{O*bCGIO~~r&9X2zynbCmw9;z8>8l9JDHF&psC38@1croQ)sK62x47rBtp$pp7}Y4iI074(+IXgM&!x zL%sl~=!Nb1a{7dY{R^TLn*1A1zH0EPEHyYPO@53#ja3Bc20uvwXU^r*!!-PqR$e?O zZ-~yxtXFs~+&=;n=)pcZO{4^F_2-m;B7{NT_+z64ZdvH^{b+8ZIVOxllK7P|1rb;e4%*-WypeghtTMLD=ps3p?3OI0aPA6 zye{%52}UJSvG)Rss%;l>(U$p%tt1P$pC+nu4?Dc7lyKnY9woiSr(nc%tr)V`plUCq zF2JbEDx{&-U(XD;-{DhnQ4zPttH|=1MYj)4E%w`}XqxVSk>F$(O0b#|Xyy;F4j}xE zB$vPeOGF6O7y7&3QoK$g(aWdA7@~s?H2AQ0JdJdOFD9ytFa80XDk4BxvKcl77fkyt zLY+S&)+6p5w47^l(&g~m86@*v{YMc+I_-SD(xoj)T|fcaX53my1LqR+aF5FON+6MP zMykXyKTR%y9VY(~HGRJ`)Do!nADl}y>bZ$-oIaLnO&gJCno1>O)j^XZX!^C`HHG~1 zq<-ejz5Q^lTrn6L>junim8J8#o*-jV3-&pP{bvJ3xoKVZYHeR_~*= zL<+!E!4{|t#+>wkQO=yVsWAUl0OCsjZFs0tsjdMfNaS6in9pc`z z)c*iO{r_@!$ra-e*(^)ZccSl0jH^7;_{&fP!;0T^dwz z&skr9_ZJ{L=G|n~SV~Dr7YGvT1(Y-$?PE<1UU=TWnB0+ip4>TCbSfT;WH4BO#&3A- zJ$ljFOCxpHE7soQS3tRP?e#}Dxzf)@8z$~-tm5v!sN%hP72m!BIITY{K3a2!X+?)d z#7P3*$Q;73xOj9&sPa>e;ThFjhuD!IDuIn05nI);&P4vp*E%)i*h}TQ`M6chn%S!RVAH_!{uquP8ear@I z^<64a2k)S+m16y}D0Q$$XJ)^H(QKdwPW~S^_iwUk>zjhC|Hll|yHSRLG;{uZqrb5U zCFsCYYr9B^R?>eDA*Vs8sY}B~zmy%==&32ujsCXTjT?P$n(ncUK8Q4p8~tkd{$d}0 zbO;r#{dIy?ohiX1lt43=;4H=){eC!LCk~H`C!b)L%05{n~{hP`lciFQ)5O=Ir%4P7v$TJ;ti{TW$lJlerf=vy#!*^iE z7Nl_k@bwG-cNUCFR1BtO0X{jl~3Y_j}G!-xWJ7_ z9-G8-Xv+}Hp()V2Ax=dqM7Ox^z3mmNt%$E{fK+-sk1llPSIfP~sAfW0U4 zriimH>(2SDy`AXnyIjrKsHSgR39&PEQ39^$z&Ki@9C4*|L%TVJwvwFymz3aw=*Ys1+ge_&34b52=Lje&<_cQ&8NilhNhq6oAI5tv+W4Z`Gqr;C2p^Zq@&n9c_II><#b1Rxmaax_JBfyj%h zk2$CW?&MC5?G&(2$kj{U^JO1{&@YteXOkZ2U33dcUCM>IXRKrP)1k1jW1yl=?IV`8 zi(bB~N3j>lPCS`ZsW$|buiIg>G-|Yj+cmm%>l1BG(KV(rxdu?8%qY)THM59_2ak(D z^&?R(gJQW#j0r;Hm`cj!p3XQVV%a5p4*5-tzac8i)*i)rng;3`UO<$ zdEb%zwHgSN@5ADive8gaA7PO`N&tIepM%klE3x;Bq$Yg4A4d}sm#EQO6+--4k7=R= znEL^tF8Jl3+(Zw?r$mq`{`Gv2%mq-@Vq>)i(VY5H?{uhdAYLxzL?{_I*C1#ap=?UN^oCX~wZ8>V>igEp^)w)D!>#FZEg_Z-DjF7=Cr+1G@P;t(TV#43yOm*^==IMoT5~7%GTike zjqQSZdfCINDr^9K)S$;$o zNRyT;vmi3AMW)VFl@Z`*Yz7?;^>C-J*hp1St=nV8JH9l)28eB4RvNyaM^H&EZZOqh zMoNijJ_+WYCPA0nw=td{K88VC#H$9&vDKRG!A%DRQ>`7unqKr zfxcP0LJq-U%$_+5Dl)VsIkBO+g0oWW!D*@X;4F)5i)h`hrYm!x5*Up%as)njg9KL+ z;lK>)J5<-?ej|-pwy`_^t z#;`)MOG%j)-Lmd9h@WzlWY5&K`4m5?bZOb`uz)(*GqaOC&2W+V5R!$v zBZxc~$O98E*{EuQjk+w9+=hM>`_7DF+QiY%coogX&vl{8Gr^)7mWWPnfxA`UhwArt z24W1355O3JPu9<+D>fw%9A=#9EZeKkClPTKn9oRXhgki7OWNLuE}-D;2&T7LV19yT zo*5P6G1klv5MUnF%!c9oE;^i8v7%cFjp!=wLYa!}VAjK2^dx(xX*g~ZTg&m%8n|EF z!@&_yni`!_mTf`LU=H8pZFA9pLkp5d${w7aDu2g$iHy0V;Zy<^%MKB_kVy3wTZb(_JKW06(|`S5n9}_{DBAc84hFr{n5QG=a6b zJ7hZ@iysjWM`PkS#(P9IMNE{p_1jMD2rZ)9b?05YCB2`4E$M^yL`v;IO5qFWyqfm% z9DxLv{BL@Q68HlFbU65c5E@WRu$EF7_d6B!une=i4(1P~TjZ6E%6&h-CmYj%pg@(twjb~ix$K1wa zs#SVh;C&`5MAV&>M|a{b6@e;Y;a5c@SIiP_%1{+1TiSfbAYMO%=dkRMEIK&kOd@u!ND_82+PEBw{h%bYi;KkdV;f~7M&2$$j8%gbON8>&=(i7JE zxdzms%@B7ZAJFXDjWUlCXTk>4^lNQoJ!Y#I`zW3Lt9k!7(RKw4P=`9Au31!975lvGoXnRq37H!t60V8IjZ#*IX zXf3t90F+CB#1c-THzbUZSOY+Y=Fw)mie9ipHO55|slOPBPG?#0Fgw1aR^clqwF+M` z^Gvf;2dpG$AgorG(cuJJPYo4wjYjBqFL>LzcZB$; zC(&sDMO~(>2J;!+=Qg4{={oBEj(Xpb?xz15%mo+n5J1w1RFMV6;3&96FM7pdO1&hN zh22QFh=517szzwUMnkc)KIuFf!*NCMF3;G7cW8>Yawbv z`gxtObFtB{D)AP@!fcE24`*bP%lLD66TMu;n=4+jqJ7(i?R^1$r3HnkA=0Q#g$$02 zgpWfzaPbJ+zFf~NSo19p(1@VBZiAyRDy253awt}yl|%m@%FYBn%9;uIEp4G3%a)@E zqEZ#5QdAVtVnJKz!Y*zFQ4|jpMetVCR!}*r+hW&crM}*;_kG_lh^Sb~(Q+105kvtM zF>yulf&#*R|C#66w&3x7A3yCrNhZl8nM@{=$>e#3g&OIkmc+y}kJR{wh?m~Q`IRW4 zBc2~Gb;mbF(_horW#-}WHOh63ALweGlcIJ_vCMCaSNV+>nLzc@N7BD71oEtDG_$2ADO|!X_EPG z68}ghaXpDNYf+9;?mnIyFqa+)_S@_SR5KTjiA?Hw<5pfsyJ|tgrAYDS24r;S67_uc zD`zehtal9wEwz2lk*s%iE7Rg2VGs4zYW!aNHNQ?zEYO%?emjp3R$H&xfL}a;m9@)( zX~CCl!oB6)6*{3;sI(mk|6S{beJ5jR?C(nHt7)UXMCc=Bj8M}KjZJ$(ZqK4|I7BB- z_L(|y!fvE=>`H-))Av~HSFwY8UpmBGvP!j*WAyH=am*J*VeOB&mU|CLAe#A*5nfVf zdUTaES%gZCbnOj3?4;y$R8LnA(%mD{?>gI;hKj0ag}M4BGRez8OhwtcBEwVa^z=(Lc=W^e6p7FcSJZP5+UL-oWHxcHE$smJ!#{l5 z#bP$k3oJD4p>ExYEX3D+IUO9t#U=Z-9t<(bcv#H>`n7jE$u6tPe8N=_TY)fAaK~iv zL>-?-shtkS$$B)chx~X8tL%7?4d(soozX|J@;ybt#fV2tms+zVM=VQ)5tSTovhM>+ z+2CEE@{PQ&7Dr6Q15`i`go|D>cVp7)fERD_$LsuK7Y7gkqeh_+g9+$&}IfzOUCHTD~6C##x$4zMD?GUU8v zY%RBWs-(LyVUViCX4#$$wmP5%dB08>Qb1~VI&^VoXfAJ+FS4}IJ8TvI*ZT6#5j4}D zBPHl9s-ornj@FjHau_kN<1Ev=CC&d1{OCoucQPHA!BDVPu(;iCcqlq8XIGIr&MYSkBW4!yAHf-Xj%_+GW z^XAwH^dc`|9|c)qX7aJl!ciEnKJ@mQ!q0=_xcr(^5caI98$&LNcaq+8N(s+*`Kb(fhtw(c*J`||F? z&E82mxswx56{7x4hA{MCti8G&sgSscD|`5sg4|1ZdiWz>q;3 z>_mAbDwQZ$(UmSMiexGm?|!6q#{-0P&qe`ZpoKg6kcd3e+&bY95zj71Mj0xFz2`)2 zb)s5G)N@2J0#ErIKC|oy#pZt`nVK|85ys5zyV8P&$-No6pW}4IS*@Ad1NSc>?3D0~ zlu#}u96`F0f$$H;W>rUR!le$}8kj0uXMEi;|JOM@U?Uvh8K4{v;Hz{h%ay`DqYFW& zf(B2Z2HMw!#>j%!MUrQeOkA4Nz&9wH?vOQY57#-Y2-T&#Sk)ePrqM>k2nsrdf@DHZ z^w;=AgGdQQtKbz?u!*M{pG}O8tTkVL>M)COTELX24w&jev3c1t^-x|^*;IOJ5}q9p zV}6XO<-{v$I`rk_Z^3We;ac%=T5*lJ802IM%f#E4D)anVl@vS!9JsBt!z6cc=D7f^ zSD>j1q_^xmgU*$CKAOLk_EO@Pm-D(rve&mbUK80KiXY~k@wSj#)N@38%F4V=4C(J9 zhD%Gl73e9H*!ZmyJB8SIoxM}Q!=p=!B464MoUEq{&=&v&nbb0p`(ED_w=YQI*p>V7 zh>3l5z5glKUGF*I6|T@Nk#P|jop&19M~kQZ%k5-}F)y>tMWVTp*{Ld>vHGzA1ZO^i z>Obl^wnlY>vcT_pwUZ3>!CBgs3)*oV-RoOm+NUtkCoySwP=tKvIr;v8Z?L{gzWGkR zZ@Ou|R}=ZZz$>@?6H=AuI)vb03!)5Yy0WSgRaaDj6PCk@>Qd*OY2pX}y2@A!9+xf* zUsoy1e%VOjGw?Mi>3$K!u2hvUD{o-z3ey1|Yr|3$qRuFJ@(T&pbL%-WlK1hq(vFqB zjd)JZR$P04s}%(cQAavag%VXDQNq>_lmz|_-!+hspjiHjlCmQL*k=d`^7ej>9a$=m z?kM84fR^f!;3{)|3ox(K*_7=q`=7#kDiKl8nJ}SF1}hUzrbA!V+2kwLnr2EMZx_Qj zeo=>{$YKWL&#DgS+k)t1R`X(4A=)dR>j1{*4X#D!BzGRu9?n3F%_NfV`}ro@~7#Zb4@Dw3$-=WGS>t61pw4rPS^sXSc`GNbI;>^~w9v}w9Je^5j zyX)w!$ubFlka^^fG#8C}s4CshLxqtE^`ev*kU}RFg`Kg6s^@w2g#zGJGO9ii1=7kCeuhN2wQ|#9|QcW79S>M&H$f&F_ zlKoruX_~!wi?2NxH^kTQrG`G-$8*o}` z+B-NEbE1ppV!s|%gpP3YE+JJA+PJ`N56_`9q0E}Qv`yZ!C4}s=3f1VVx>7jFn=VLs zIjQz8XCD33RlD=NmRQEW=G5F|V8yjWgV=@(YpMBiY7RHIFGC5eI-{Vm9pAu77zQ!; zygEt9)v!atR(eA`Vc(lGvk~gEb8I;J=MXDmpZElu-XiIwW!P2+?o5|H5 zW_?K;v=@W3Dw^AYv&BPf_uV-6}~bw0LLPBlki$3#X%eU5vZiNqURWqQHc`y1 zG`~D8FX{Ql1jcf8i>-3X8U!M&vCCH}xWW>MK-ed(LiAsiZu=^F>LIFOR%R3r zWzUvtZoHJ2Eg?ksEpEefUf$$!2ElwrL5x2-NK$eekW!2k9fU7-6Y;lt%o;g&_=aY?oeiYg2r9h>HQwQ17MGqs)JF`_XOn!o@o;#(&} zkLL?YC>g@}H^c6o*%Ag5ZXU~X`{C*~jl{Tgk95T^a+!;^%7xEDVq`6@=s;#c94)q&`0JKg?)E7HXGqX6UjxKjd7L%R=l#aOz6O`c{Dim+7Nvz5GtUb&&oN zeA9yA!($iv!dbC%_v4Rj)CbWddTpJ|=(6LWZD|>8ExWVcX)AV5++NjgOpYByV4XX6 zyfYUv^GR9dOs%-7co;7fO}!iBif+Q{7gH9Tka(?Yed{i)zTQUNySVvDUa$m#K-$WLZkdr^fUaQy&p^3p~lh-w+OYlfPA{ai}c_$uQoP>KiGmzc1y>_3x?Y`JWVK!-d?9l z@wVp0>!p8mI=iMbks_q{WUZbXE?k&yM7q*;C+tjtNUK;%(O9@0ZESj17uv5GMg2JB5K3Q&hy{S z0#TUT{X|_LiVyv}4%(GY2W^&RB6?%fk;wby7G5$RxvD69gxj!fyia2{@<*11r9EX? z7`ci*31CGAr&|vvW0eTFtAutZt|_CQD|SeCCI`c*K;y@ZRYH0*5NTyD;w4tQ&>?#! zZ5p_c;k5P8nzyjl1{5vN)E1yPK)yrG5oE;Fsci$#74P!QKs%Sa+~mD;U56yw&RzBJ z7x^Eijl-iAWDk{t^*7AZ=CPR;0AS*mVrXV#@?P2UONwE(^|Nc!@b zG?{=U*tM=SgKMzAjC#Hm2pka5$4!^sMjGAy`vL3jM}xKKYRTA+jOusf*Ixdm=iljd2#ttbG+lTG;0S#a1w=q7v zv)h_Zd(4GG+oOro zL%W+#WIGa0`;^4QZO~Sv$!T{p`9-hhRq5}tSsYQ8Hy5R;6%P)MIa?A~R@x^(C>TlW zR+uTf)ZrdIn+vyvt6)TGDt?hn6M=E>`_`EyyCvJDL?I4b+npD_c}R@c7)7x^Ml|!; zMbR5Mmqdvhh+dCH4vye57{#LKt?^*W9yvKbu_(gq-^+T#uAx;?bVRZ|2imQ``|83$ zr?zPx@D~0Yh}Q)|+mcH*y4eO{iUhCz+yz5v;H?lkhgMj%*o{zO-xCL@--#n5up8f#oZ?qk0?r68#@7@ z;6a?*EDC)MYR@hYcn8f7rmTv!m)r*>D<;n_yeXw9WwldYfG0!pKJnhek|2(5^bkjk z#Xl4hMsYg9zQY&T*;n`lvEGQOk;N3`eYHj~KLTs4HqHF;rP>`ta%m+0RBTOrn8>ku zubH-yBd0*lDoCUt_oS{Rrx!)mO2&h*9&YZPot&H63bU^GQjAZEfZoQR;!EhOscosP zuxnhZdbZ}~uECtI{5hY+x=2#Trb#z7FUnaT$XN{zflw?N-vn5`1u;_KcwL5<=l4d5 zH;myy&SSFdZ@RoKh<)W6*WJpl9I_kQhEvX>pE>0`%=Eli_GMTK+^8g3XS!&FH(V-Y zTxGvQ?sVqJIwFE%EB6T>PSjS-1AFext z`NQrZ-RYmN6cS4c={w;(k11%q9R#QY(o-|hh3a2N?Fb~X@qR+3?L+t<8vfV<$CSX~ zUt&t|#Ob2ioWtKr+g=MwJNt{KrUYM!>ws|DX>O#L68s=&iYY;@N=<7WQ-Y3fsVPCG z07BjB38_jOSNwE=u^^IJ$A_(PyH zur_y4IR064r4U4pesf-;WN$Q2!yGHFG>>wqfZ4_|5);il=1>SVpWc+aglfc93wlJ#v^_YmPe@Crh)`&4{e|QXS>%edqNOj(V0KiH+6mL-bOQ zhjS9V$n{xcTS@6+rYe*_e;01A1Gcx;=y_B!4Al(YvPy|dKFnJlJ)ra{8cui_!+Q*X zrdKi0h$GK441)BW?}YhZ28alGuYqiw!Qmwum>C38S_L*DZ7 zOg&S15eEYs>^8p1H+whvW(}5B-~o*|TdWCbAN7&VS{1K$bC&`0M!Efgeb9xn5ZwYu zQRJ;s%7^Wh9O}}+P|9MoK54<&ul+#)hf7)F?V`^7vQK7@?0vjt{WL$bo-top5a))y z8ky*Yq=b_v+j3rG!z;%^Enf!!-TCOdLya93M-5VR2>2!Ppw_NlQk z(g7uh!0KCnJ&Oh@x77yn*zwui%ZJqQYR#~DFssgW~-2LK8XoZ&XCo4!N)Sn z#}I8gj*@lO*g2rUds&Ab&!*YOYJcqUd^#2xQBP~k6wExh6tmXYs{wV%xfw;U$!C04 z*mpkjzu_PiFiTG_opP!f=L7sc-7EjR{v4jSuoLs)2HEPJdQ?|YUNo3)3mq;qW8aku zB!9`_RP_5P?(A!wE3)*;5od29GRus{ewlu?aexmCzaFWn>pQrHwn^X)qbpC zOSMQ$f9)*sj2rQslfds9J}T||607pb!J6J^=h%v{^v@0J=pSL@b&Nq#WU#2B>UdXx zveqSwwO^81w?#%}I~m;cIO)O23etdj2PiX3K~^+^{I3Bdwn3^%cd99Q+*VRgf}-Z_ zVZ3hqNGR%F@|xt6qMo_6Y$EQD1{uJ^4@ZjzK@GSYX2Wj-m_!|6{^2q|?`2$%*d>XgG%z=i# zfZ3^97OoKc)6L(iFnt-A`9nSR38sON>r!=u>6yEK)@72lm5h2c^Lxqt2F*eg?@n&1 zDI(y}%-1#`HVi{cKvEk>)b17vT6&J4{jpGxbBS?UE9YMQa8}E?LahaJgoUG733$(} zvi*pbVJ!ijWoGysX|Ct|z9O^4GjHU#(%vM6srdJd06T67{gL~-zePF0=ybW7Veis% z#9QXw(#V9b!YKq2L)2BK)XEQJh`I@?-9VL<-zI~6Jng$KGDN78!^fV=r+r6ije0s^ zjbN6*9xCnZ20W6;;Z`A5y{j7WNT6lE0yq%)iA~v5^wAxSY!2qJS2ChQzu;^=vV;M6XDU-1Ob+6X_L_9?|qq z8`I~KPUdSQ@p?^skHjMU+(p*Nn&DiKs54ieDP!;`Y5sV%O}Rv2V48??rsq&elZC~> z^Ml5&#=)@$mYK6sSdw6G`Sgf$+B#eY^o8xhAf4tX+Rd)s&m{}#UHcF~!kYa4s9bS| zWeqn!Rmd*Gmn94=SIqV(Q$$&{A=K9cm5Z(u`;FdeC}}p_Eqj9vlkT@28YrTdd?koZ zs7pNeMDG#Oq+tOBZ!Z%>(R8`nwSYZrCk z_9=eBnilji;_rcvCE(%0j?qybl7(U(vy@@I?M?xV4C!r~OA30-g^>3T@TyANju@tL zH_B!17u2YJ0{o@+h2IMsU14fR?v4Axv#O*wcL)<>&Mr)Dcwf(3zJ$RvhyA=OZqlyW zOF1Ht79SRjrVTz$R-0PNn(;JMPVA#j(Zkc2wp4l?*<@sLWn@^!6=^K8ky{LHCWN~u*mA}fr_x_jf;S6FiA+6-YlQO{4+6!)|;zdpn)59ZZ- zL*>*LhFPL|`|E90)rNA^$&b3Vg*EJ1X-!yPF0WL`occ#cyO_MHi zl14d67dA~g(@7fRBo#GH%6F2kbdpYQnslNDmYH$;gzB77LKLmEy+|$W_q;4z-kGNm zFztduOcLL)Zpq^lk3R*7%_Lghj)n}5outg-wB0a^g0GYc(k??QArxot1C9qE8<1#8&*#G*VJ%f_pJ^@B z9ZsyPoU$Y(5#)?5Db@yg{C(Ne5e5uqTC zf`$pnZK4|}gCl%2T<#4ed2zsTOLCz1jpAdavw4KFxWn;Wt(3J}u2~{=mLIMinHYmg zyKjtea)^U_2{()PVV|?P_1stw4})K$Qp2&uC9`D5BYxoJe1>BWq!8)&6p&hOx(sy> zQ+CoKX5clKCsb8Ad{OlB>7sM0GpW~#H?*KcMm#%rDwmwF2$|#q*bf;~#xailCaOwD zE=*<>=qwglnC<$DRG;tM89YJ zc4ChTCVyuK3QQz3W7Tn-vF@;a45?WYTjuI1wt z+FesdDX2V5c%FPU^e}E%G=roJ)(nlBqmw0^w~w0gz4tG&Cup+g*|_%UNx#9_uJ}p& zw39R|>bd)ICRsG|f?t@zsE~UV<*~?$=2XTQ`#>!Gcn&^uDCv$oF=_|Bdf|E+doHj@ z1RQSWiGBA{B@5@sa*z}k@$?ed;{~>7W4Wkf8_WH5d!pPVflUFH@xD#4h7muexE<%> z_Hb;N zvf?af<+}1w?wf?~ssx%g4PGd>k#C$u$O2@Hf5r5ELWKbd3E{jUQCBhNXvMOEX_r~?4Ok!P`> z;=90GE`+cHXXv~QBV7=>J>zok%$|HoyEgt;sMA|^FyVs8%u;HPoZZ>qXZ0Q5#J$p@ z)DgjG>LTfjf^eH`3F9hk5pN`6s~XHs4}>quPIt)cbDa$?naR{>+KD}+vVzXqiCxVh z-|rHi4s0H!uYSMft!>I?UGntCLk`fs* zNs29>rGaH;b-Fk|evQ!bB6;$oOAyz0^2#>{z;)*H=N&&ZyROiz+0M2hApSNaU1rM| zGaKh#!VL-|MtJCX@X$Kk;$sftomoXjZ-rV*Ak2>O=MBlm{uk7O{qlHwM7lh39@1`F z<}eY+FjuyJf=iJ&M{J793KMiux&8oDgpk2yh2S#5^i*6>lL}^Hx;GMR2pv298NG+;UkMAv&SbXw@FIW)9QV4e#H8OLu_L9zY~aH(fKNwbG2rx zoXg9kYe9tl0#I}N?LuIx?Jkq^K6Ame~%&UOYRd+ZkJ%6EJe56#`vuLru z-zE9QNAy`Ei|(ua+-82PIYh6n3-5CT-G%r5hjiifQI^RSBqPggg+Qww@mI~)C~$tG z;lFzetwv<6B>OHHG(3m4o`9KFAS1R?F#GFsXzvj%h;IDSIYT=3Y5`kmjw2IofAVMP zJs4R5zT-WQe+#M*dNv}T$P910;Vd(44g6+@y;X8YJzvkJL+FQRm%1$!#dWYI3 zEpn-?3+03Ik3WHOG_CJb;EJ8TWcYfuELK~t)ATK*li<0U;jG-sG+@T`b&{4iN$n-6 z#7#QbNqWOc@=DSLZc_YODe&x3A_Ej4j1Q;dFtWxDsCl*>Up)3e~lgP z9}88cpu;GuadyR+igC(1L6q0!`<$)_IF(e(D>Z+7=b-jqDiI@_|DaS zg)f)X47$uS0(fE7s}-BfvkAsp5Pzza)38c=XWXXgj>B2&qJGad?bXu-^;2EcH!&ct zI(i84jLnrmnX^|xp>%qcGhXL7IlsG-oJnrZ=bfZ}PSS}|=yzM3{9>A7!_M;&HDEo1E|-e@xpZ5H8R~;n(4Vo2E}v3kJ=6OTcNr>F2?ILhp6VB zm#@S+|8PU}b4{ZkYKVTKY4p7Wn#vnpWVKxFRe8f>UfU?OZ?Z9(9*8tZ7^T8ng}y#l zO5J3aX_vXOMOUS4H&CXXmSSJ#*B!GCj_a+*VvO07D`f`dNHI~*!6cY2J)JYOgNV~y zav0DtUq{v1#9E3Ha{5&(^_=s&Gw;Nm7KbrKTH<<1YpNNb4|5#ALKm?2OETNv0uY8N zd#l#tl$KJ#OZQVLl%$LsPlyRd89TP|yVAZuW>YE(BLp4>G;>a!tgW8aKhU(`a)%s4 zf=bkL)H^h8owA`r=^(c+ju%dc|8L1~-wNrAXQlUCPA@Ca{5~$HzgxStfzwYS=yLj3 z?$tsrq!3w=&d_o$B%PIX6;%(u6gnUMwd0CV^4Vql5gpUD1B78dB%$cB*G%L}+SCbu zLl5&&jv~Z+%wt~)J#4hq@W`Ubiz0D~9a3+^3~%`;vP$CfBr;D#_zvX#?wxTy@%Co^ z$jxS?80Qt^$qMaKiBGen*sJ+1h|jkRG@N!-SGqGg;4*&f9-`#_u{q}^>81??-9B8f zL7N}6^x-f%z0!`BnTOpe31&$Thn@n&*>B0^($j9K0xO{`ou!_(zbX~geBn@03oR#8 z(hi`a?;L4op9}cI^Fl>GYGIxwPTCLXR7_NOrRcTT7boQG*uiFmoE}0gT%H)2!N|X0 z!20l|DpfC`lu&(3Z`n@zCRC5)^OJrY=`H(CKaTd6eaVNdxRcq9CrfAhLuPolmU?YBi9QUMA;((R9TS zM{=t8fhtUecwq)H@t zd#6+7?feA76FS@7dQ@tI=sdn%3#7XipCC>d4?Awy?PGdqr zX+O-^$#r9WNtP55z`E8SP9ZLT$D-t7Ob-j{IWrr}-&E1|tCsCm&_x!ymDhY%niCEY zlT9Q^;f&_4_k^;CYYq6-l$#RGcn~GO-VFGU4ARMN3YzeIH(Bllc{7r{$8bhro?IXn zAQ=J`s&2&QAjPJoKQf};-X#ql%g0o0xu@fI$~lhu5hnXE{1M_@r97pTB21&)Rt6(y z{X;A9;!+=L=^x8qv;(U!AM}uHfKSYbnF2JWcfF+gf~BTOyQORYsP;j-BZP< zyJD?}*#h}rfqZ}jI|8>2asr&a-U80yqRsXW{TP*Pzvd$l zz98GK<74?;)%ip{=@`eGK~KoM95+dt$@&A93EWND$-;Gir!H8^eJ=w%I8S0e)R@ed z-xBd)eYX=R2q|4>3o6#U&%HD5CCWY^6##t5_i`Xr<(wC;CDPpTskC<% zn!I3S!th|!b)gx#a+J!v6UHDN`)l%tLl<~i$sgtZj?v!;r)pvyBmq5)TI?4;^mvA@ zH}7B1F`2lkM-_7}#oNaP2jypd2{!PvYzgQ#w}(b2Mv2D&G(~i^oiwFUC2U%KvMVksAv^7W z)QJ*izTVU9HVXTM5Z4%xI93F601u{AnGev_By=a=YHnDloQ!kZ$egwXv6JSqfe{Ky z^b7n~luVw}od&%0wP=iM%(`k}yH7|VNCFRPVQRO-npWwC6GT{PA0T}{zfU~m$oglR zb9qKkE}IR?P^}o6Jkefz?uJbw+vfA6Qj)ob%3!ijE0AX-0u*ptMb_)Wtcx+FJ^6qW z*%D8?&OH!wvSxB#%5-PpyPxYU>k5uLUJ|l zHB(7A!~AFUE@pFGAo8=lfzc9kuV~uaWEB6bxAx}e&{s2LBR!*gLN8kjrRc8d5Q>(J zCzDZrw-J_^wB}p-9A%asRg5Ci^r9AlSV*AZ99K`+{bmLS!OjW$jP6ww%{ct+Ic|N! z5xd_^x<)n=ac_9QG^groq-vc&K}Euq$4}R2u{S$SqZ=pCahif&(p%n3lNyIvn&nPG z`r`R|?TaTSX zH(ES_-WYlRZ=p=FV;U=~v||Xk?#Q!H79(-v$A#l_WQ6v{)a`=wT~mcGfJ_8}kvE(T zjJT;3Q__z}v`;}+fe24hPId-mz&8zpQsOa>QkbN+($pEU#kEz zQr9RzVx$sv+jA5^M82~Xz#ZYi1R5{BRodIN4afex19fRM&D_#k=8yFV1s7qzleUr1 zqVN>XEk^3$!u~@>mRU}g*^(u+sBfrQ0L;n0q1vL3O9p!3G9CBn#k!k{AqfsZ>l9HP0BoB4NStj<89P(D#wQlwc zo$OzJA^Jhj>XovCta3G(FSdq#>F#M3xiE1KEzISlWQ|;y1NHTSW8|z1bC6R;g;Pd! zzcLto8x#0b_nt$)o$ z|1qaDv`+h#_By4--l7Aq6}ysdeWU{gU3sT*b!*vFrY+^i)=07F7zAn;>sO_nNsP;4 zCkPS|&)e%^vH$y!4v5?PNo8$3wETBb%(tePkdzi0n=WKFQNEG?|6WW(SG+V<3-WMdI*MK_Vd9S>dcWNGeobmT{jH`6BdW$mKK9JnWnp+Jn{sfdZt`IPubJPNK#1|;! z=Z%F9bs(Pw(!8LFb4lEPCG?i9)wo(y|AxC7E+T?v+<%@cOnkrx6<#F8^uX3agxX^S zpJ>{oqv<|z5&x~^iKp0|nipT|IbZlAsoce)cjX2jM~^=xbL;O@(&xU7m`8t}y@nxd ze!t8euNLPyUu6D%6}hArcLc&yq~UDB-m+Ju=!oaD&vj;=_9>Ykfji1Wtur+#@xn)? z4HIU}J^gSoXmUHLLZ<9@BAG=asLG|5-Aj~OLX>Ex&y{XYCDAno_V6iIlH;8Era#3{ zA47c@Qq#Wd=$h$0NgOk!yQVtNDMexJT z9Va0+g$qZ8;n$p<_osKt_+jH+Xa0c42@yqzvYAfl@2}Oqc}6;R3Z)-dY!GEjDU6HF zEd5F80rUah@~7m>(Fxdl`EC^8G1{bLx4V9GCf7MsV$OS?T18X|_PZh9TPEHSoC`O1 zc9Ru_;v+;gvCy~_G#QZ>#Z>l%j*g1#S3!Lme~@PU(fd^o$PEokIz=?wL6+p@Ms$`qK)Y&NA1x=X&+|f1N z2g=I1-4>Jozz$Q-R(AmE49InS*_-%7OTH3=(l0wWE!iESCDI(XCDJpEPfHy^OT;QY z1k~RG+?eeET&4ip)Qc$|oWK7RoPSUy!vGT9rk=^CI#|TAfw3$>N$l}RW20$npE%Ne zdG?&gWlJPZXs4D$+6O)Q0_FrTs(0jmz$?zwh+ojK6Gs5=WkiC7e0+ zF_~>Oe;TxkNsy>{cc$tM_m&~hrew_72tY~oc3~Ty_JxymZ*fmfWExYa;KiHRBTe(SA&6K zQ5wlH^b1ekbC3pT}#ED!7 z+@49Y7|i#Ujkqg8Q60pFU^qLx`*mLXCs+ z8x#ObirWW5-FF~29Ftsv5r=}owJyFYR}qPk`g;ruBl3sGWb#tV9c3qF=A?X7o9MT6>t(QAx9w0R%f zzdzNL!EYSkn-`8z+4S>n$H4Q(W#HhVC}VdZj7(0Oanr&U3c=(msmq+^qW&8tieVI@ zdwN5rKUw%imRI5klefl4?V`KbX5-QYe}}>ZLE%UTg>(KNP>4UI{iVHh-TyBZ&pHFK zO0e>lJs~|Cn&*VdD;*3m!+c9(@V$hU5UbiGjjuHko>O!qOMbSOX)NcmD^2^0-= ziHLfhevsyzqb%rnuxq#&@*~OStt??gUu)L#r>F!o~+$*TsZ{=Di23aYio z&!DV%?j@5i2$;*YtU5mZk?BrZKFWGSKJ6T$mpij978MA0u58o*+R8J~TBCS@Q=v0q zsQe+kNUb3i`DdB=9aJjq8TT~Fd9DVQnJ#N2shAK~I8`{kYnZM8y;rgV^m!XJkriA2 zN3zzL79got9yWs&YKsedBF;ZG(@FfMwHUrQhBZ}AdY+_*G~Ki5d8Bu2VY`}=Q{mX* zw3QMO5uYw4Elf!jtQy;-v@2f_9|>G@`rJEv)KQD`k4iQpcSr@EGfAm9|0oCEC-BGk z^JcMRj1+6r^)xA_5Z)UgBL9Pt-Cf*dmCSwKt)8Q@Yy;YTh-wLy0yTb>n2vgx{ zRA@Jo5&cm0_vnYV5Wllr1dF6BbPg=}E6gLB=hlNv@yBYXN51CdE5OToHfXYGB<6SQ zQv8uwqI!_ijPh40h!g=z0Vu%lwSp)kG#?j_}G$Encle8y@QQ@roarr_)u66d7w1`3{Rtmbp_MlUpGTb?kO2aU97E_m7 zQvy5JMf};3{H#zFZ{oaJi~e^3;?|l>BpAoI|8J7y+x&X7TB=>g5!axMaEl zr*LN7^md$E{%(KM8tP02?jIfX-3nqPWj(*a$VXDT3a>JagLzZ4yk)g~VFIrPAM8Ot zlSN&zzzbRH7!-4PSai^x`9w*~7M2Oh7*dYO50k(sPyx-d!v2t+tUMfBPWpwJwJowTu_0%&6=$9 zuIwn03hJQoi@DGpO7S zQw$p0QS0z+=SU^7xpi$v&O1x_Y;CP;J5ob$3(HAWl5Z^ISIRVJoxwVZs=mXuso~lJZ;qZ|S#oO$;8qqio(+RU; zBqEpyA1Yr-=<+LVUkxV!ct29Yvi1EW2G4Gc&m&&!=C1k%PfnPr^Zu@1Y;18coB23_ zSSJ#{{FX#wiF;W9ygu<;v9YFSlHD%6E}GWU$-bd!_Ss%H`{Rw-e{IY@QL?LkBJt40 zSBmpW6CNsZ`^CDJ6{K^@;#?F~>1ve5a*)LMkKCD`Rhp76kB~;wUiw-au(|;Q_Dfp` zXal;s7!bFexS;y(^LW63CN*!z!m>9c%8}iQLE4NbMZul+2cYVt2luPPIq%|(>&h{~ z@E9EQj2XrMV}g-kxpc(d#mvp&_sAZwco3}MuUjgtDI{|L3mp0^bA^tJ%HdP^v>9v< zf?}AVw$0C;EvM?2D^{M1sRpd>k{04uh#xaVv0fz9p_={+71Cw6XA+P)z2!yn)#O^k z00EO-p0`}aziI#GNI05y!DeT~OAhuS3b0mtHZRi7THRLmu^+Lh_Yz%a51zv-If7)X zeVO(Sqkwh-S}A7OJdcve9QLAWgN_xNHGStex)N{seL9j#iLoIG);nS@6M6I;8I>gRHJn&`D($Hf1}zSK(^@?s!VIo2a1Z{VAwHb8^L~v& z3>7#$J3Ywn+<7g9jy*@nowTn?byqu8%ViJ712TGU^Cl6t&wb=_Zl7G&Q62`~MQrHn zLqfY!OIpp*7tvmjm|f|d=O-m0SYm+StG4$_Y0*O;xuipqvpE<;LBYs(W?5$uPS1L9 zH_u8hI0r}m^|*IBm7tDYnMmDsiq5ja?m@piS{<(*AL`F*uRH9u_fx2>2yzfFG8!kT zXOytq=<%N3OG+>(|Hn|4{F`RaBo|wQ!UuF*W;#C={4`|@VJSN5d0TEf{&|R?c#p&| zCvv!@5U*{Ey`g?|I1kpP4~nL?8DD_=iMx6b<2!PJ@5p5Z z^EbEBJKw(6^9$~%N@5+u6_)kt7Fe!EN*6lFAKFjrq$v#xZdNkm3{IYodL<1$+ zT4^cWc92th=l7^R^uDfFUjl9J!+EMs6OZ&km3`!4VLB_!?QVS8&kxZBzdjacdaokceuuT%MTGXY&322-K3=}cFRmnd$%pM z6oO`|MMDyleo60RYskx3c@JDa2)5w(Pm|(4rF}ooos6b^ir>)^(z= zg39FO!+cvt>p;Ley_65#JW!3fq)8q1Xs;yUFLj8POorthgd?X8DRIAwux&3Enf=5*Qh0H7ub?Ydb^v_;Gt(b;T=>r~paNs@Ekd}fSLk~vC? z>@Brm0f$n`8;lG@6@;qrVpQ3&mO9G^eIw~=2Y$7qfj7ab*6fQl3LCCfa%7xu2DSZD z=EfX&7>hxDEKR@ECLHZkV(HRI5f$+2ji}&lT(UJK7@1W{em65m$z_i-CG7+Jab1W$ zFP{iYjw%pq48jfqQ+JB4wBY>AnJ<@%<@HWR{J&Yj>I)iuoM4C zIcNWi5MpZnC&ENfFphZII|*ksQ8bBQr6j@oC?l$vYz)g47{4Gco0ih_)nZHC?V<<67Cf_E2|K01JC1) z+|-h+9n~20?5Nf!MCa=hqVx3$(SV=vOO6c!D*a!fprqKL|6B@0u)>LD>hE+eL^8S{>)8qhi{ zqmmY8^wfQ_NUR0iVbsMZ9Vng1O^cU=necu(BCcAFjpqZ>duT4>eX5j*lBR5{03q6V z%Vkk*x>7DD?5ehwzp6R=O3qv;rP97hqBFC5GjxH7-*0pHklA$j{*!h^Af;Ajw%_l4 zFZC?j5-0~ivorM<1yZU609KfacT)-u^Zl~Kci}s<8^$8FWPmTOpHmjau;P^maOqUAl}Rgo_s<|Q zW7{_ARPRfFU(Rsb-Rac71&Fla>|0AY)myel8FXfUIsc#NjNb{;9^uTr`1l*n%p19I zW`Stn%&mYtV379%63)DpnhI)~%L0UJV7t$$ICie;HagCMkluS!*6!pC-jz8+!E z1b?UT?@4Z{>ZpPp3w5nn=qyQc?>&&RLg=yx!fkVvypos8WRX( zW5176$-VTF{YE-5;#oUeS#b|ho4tYnS!q8ap+Fs3*bEs?Tw>4AagAnPisN9N{V(xB z=10hE`eP5miqipDBTN4I6IfYqwJ#GQoY)=z{fZ6&fy zM49;@?6hjV_dLOX=jYyhQgJ85&xGt5%vo2Ix6GA2&&WpfJR`dxuXf_$K=v)^jNmCY z=4;=QR?9g-$=UW~3I(LVJGfR-ml*&0M5?!}i&JBkN}efw)`-hu^qP*?`Q+2mOFaM3 z#SI zSDajG9!wW;vbd9&^@%Krc0`tEWXb0|&Nkr?@~TfUb%0c7)@g~&wF=KPN7OJJ;LD}9 zN%S2Tb`<%>RlcqCsJPZT@GRb+_j55vWq;TtAmqaEN;7?GZ84?ndvF9?-$tAzuwUgi5(O(2mH#rx7MvidW$0WM` zT*@L+2qYAeUzJvFm9HlI`l|>xrHPvfb25sw6|X7ne=2Y4*rzp%p564}U_|WdvBM~lbf0%Ho5v*ukx$IHPZP=BvJ;&88d=e`O<3HAk4fVX zWO3Ihi+c;4Db_n(`jb+Hb+u_y@H%a66COvw4LokFQ*Z;18>_%Bk(^8503LUiMAf@w z4Wr9QLK*R^J(cM2H88qsI@=2&6HygSQdQBlNTbE#h(yPy;~f^v5}j+9j861T%y8h>h_y9(^>wUm4Uop{N5oel;RJfQ19&K zET-XR{^*EQfAp4QoNe9|bC?ti9sem>9hLZDx&F}CfBI8aa`pP=95Rj%H{s41o*5n;!cUH|hBq^2W6kL$VG6h+M^Ugrd(!a1^Go+$TO!W^6g2B~ zIndt%P5Kzp$>a@*-lgCJ6$nG~o7qgKf`ViPp6vkl0az>49KX_qP6m4LI|7S`oP-l$ zJ_4a6kwwH%BZ;?Y@Y6JXEN-u0#H(M|#{Q=tO&a+;s9i{W>8_HJi#R!ujaKG@x+8Ew z!3>r{gj4a5(}rT40LlJ#I{A>#>&^TNTO`?MfND&;hm4x`yrfMhjSN$WjNMqeYm%N| zO_b0DQj?r#6;N0#D5W3f)RoysizgqoYEc(ZRP3}S5M2(0$Q6h~DD5E1Za|rK7YdpO zljLGG`a!|pXX@WOW$BZ;p z5uy5*^W?m(Q&HTVm*tBVA)|VWa<&%mRCrNjp&7omEmDE3itPXlCSQ?7P2PL%)?)Ai zlk=OvM-~^n-_25?*00YDrtel({EC& zPyb29$IFACxuuhPCj)**Y-dH0qrajtaTsqxIAry}kwIAuUQy)FBJZ$$Z1q~aFGCgU=2qWA1@TzMfpr%~uIN~hxBQm&jDgtcE;Fw@ zw2z9aVkx}y<;z<*v4IS5csP{@BjUv!)!SU1sYr2=D4>3M52AO$`&sV57Uk^IfvquT zewv_wg9R*kT9*Bh4F`R@k0T`++@i=z2vT2#;+||E%rN7jokztWIS!ob%ne_9IcH)Y zvxFRET%?Cus&1~@;1%6U_)RC}Rkuhj&tGq*%oEkeIuYN>Dy2U-k`ig8R7+@-MkXAP z@4H=`N@>30i(;Jx$wZ0MKJtL7lvq3v#1&PQ!Nu|kMdl2qO@pF&TuBkJ7 ze^vYJ@Sji`Y4vi_7GKP@+EX|qQ&-&x8Fl81Z`w+E#a|9(^|5ONiqZL!$5$kFv7RgP z^0+s821!Dq#VrU1yl3u!6mWM?#7lPGVLM*R_m~JB zFR!L4Ic^tn+#%$sb7EJLTiJ`K{eyX1z4uJi(_-N=Ta_3WI`nBiSe+or$pQ*fvOxt+ z3r|F9#CLz$P0*@Hx+U^BTe@1Rrd>;-h<#mD&fKvSh;Z6@P9)Ylk^><#mtXXdqBQJu zcXjvt9qR(oe80cz62u0Be;m<<6v$&pp>JA*cI(rUIFRI(9C=zYiKiu#28bPqHzczJ zk%9MhZ=v4EA(*snD29D5;5Y!^ZSIBr;ZSC+IC_dK(2ab6XEwsAwN}mtmz$DDbiw|f zfIk9j9_kqMVUEWAEj8$4HES=Jvoq^{ne6REao1pvxQBqr;vB`@hyB%2^?D%C0<5fQ zfwQ?Jvuf5pA?gQ^1n;PrBRb2Z)Ffx)JTI3(&EV`#{Md(Kk2`!x&AjC=^R;tb&EWn5 z8=n3tZMP2)hbT~#4cD;PPt771Yxw9*_*9B~ z7SAl^gYN4KfImE>b4`o3)F3xypW>Ize;~5n9`-1mywtSJM)t%sdOBi-`LjnxQlwVD z=SZVsN2_uqo*By%B?v>3x&C>!O^miR&FSD2X-`nm=tDKe4zPcSO*XGfajWcj zQV^z}B*dL)0!_2RO(3);*#?52{h>)={^%v$l>j0GJNm~C&4|}>N_aY(RWQNie}E)${aVRQDfFt+CY(ZCD;1jz)A~tck4y-e+rX#R5F>gM_4ODIp?3i*W(Fuf5_V;_)nj}QchyE{9IU$d4d37nykS8_u=*nJW& z$c<8#HfaneWB+tLorALjuBT%t1s`0&;$#l)y%*aAT)MW4gNRsD`p~;m(Kr94cHO`) zkgtTn?`(~hg>jZfH!h6NYl@ugJf|rM`wSizKOo$bDQ{lq`Jvc|(16}+j%Gm1debhM znc4h?2K+YRI3mltO3Od>NbjOl@ery>`-~)^0W;(EKjYzJmlCwUX$5s=*0Z{X+wTdR zpuTUk&WhsopPBBDwAsZm8qP2CPMiFlyxW!UkDN=i=ljokV8D{R zRtVGc1p&DilKBfC_;P*kiuu>mFFU)&NI^Z#)>9fBV zTfxrJ-}E@33Xg-{nOBSPMoO){j9(4_>{toIZSMImMds&D*-+f+FS(|rkb?_P0dH`r zFK^jR93f2kk|%;4+m-uty=C7~RWjVRr&eENy=c~23;ymEggtr<(pSSOhK2Hr2U@L+ z(OVluFRJX=XtZ+Om;UgS7wtN_glfH^IzCjpR%hO*lER%W$`e|6(Se00%vDkng@;G) zUx7bD;kQ$!s}pWh%8z}_ zCc@uKAfJz)oJL-cr&`S1?k-B0p}LU~RvqTjuVi zW3l#n(e(XJ_i+^;DcHDa{+vzzl;8Z}k}K?o0EVW#*KA6sxs0d-zJ`4;rB>Xd;C24I zJyR~mPisxVyrk~ZiYYflir({~yQBwwZ%P|6(o8OHQxL64`Vt|gO=ZkG-j}m@d|^0s zcr3NBA{9wvWR0lNaE22e$<$dk`9r~%vRY^_gLf08dVo|gGG!A<-}`e)ZU}@=>TcWV z9531=HbeWrU_ifq|2MJH@=c$#mFHr%za$c*$OfOvSHlg9O1n@~^hl*zlNybD-XXl) z-|xnZ5)=z94Z4r3GVYWV_Y^VnZQD*MF z%7%JCig6LgPb3nn6rk!K;Sk|bCpldyHEj`5Y|Q+T0Uz*Xw@7jEw3;h8Ly8Wl;>WJm z8ur=Ev)PJl3Qu{=dgm|!Hg5wH{ID+}nxbb(Irs;k2_Ni74YBTK9uP4+La+3Piz@9k z??WE0;b*!)4H_wipVC3Uejr6O3Qyl?c$vw(Pfn1YAfxc#H~)jsA0B@1F2| zdZPA-x9l}?i6|N^8p8>n>4goa|Bko_PB#zW=0bi&@qjVxnn^bP!Moz)y~m|xJkcS^ zo4wt8_c`SCmY>OAGb)wpgupK%Wb-5{^D|i|L7`Uyh4lSUI4gm|F+ev#;pN{NQ1FJT zq3i?DnD5&a$Lm?&F#hC0XYsGzcE0VmWt6lvpQN}*d_LD{{5$u$jlYLAva#`>pWrtB zP2if;e0*cgHxE9b)-$LzQCq#%HZD=yRg~h*;0j!{X#05YG~ae}@-1>6*;NMI`>6;B zE#ZW<>Opyy`H6Q3l}J~}^a9HC>Y`$Ux9kI*aA#z|g^TYH=OZ#V zo0sDpqo|kMgYi|##6AW0q-Q~`(hieph_fa9I1Og~REisR-AM>m;IhM0J3CW&0yOA*XWBL43pzZO*jK80JLkJBg~AGTEDOmU}R*a{pww5Z|1oVYjNjEaVL@sK3U;xsYd8P zDf)JBlR@i`ryTR*>kWNfe7cn951*Z@LxzXN);xV6?bMNrXD-W;D(bD?=sUFPU!!gHvpJVwi%FrHPSp$7twb?igL7bi^1{9ORBsk;FuFj8;ucjL~Hw#^~jq zj$q6X9l;R2albP}_uNMtIot&y@xPUjIkgFSyNgdVEtA|~K~{rwe3iUpGPNt+c&(Ix zAL=`$8s6=l2)9`&dWC4_jgW_(t?-Pl$R5D=ci_KL(h+Iev?2?uS*bl9yKx{6b|A(+ z%o;E|B18EIyt&5rn9L~q>#v1%b5@06PC~wH8jsY3=9=KlSJc3D=CxP3 zBF5tMxjAlB<0y78rQgeh`+Sxlb$jlV<}rlC+Z~!XRB3`8eFIIr2eLvFAzGRk_{6Bw zyY9fBb%;CgcSxx+IcH|N1Al|WI0OGVUND@=dDR^Z{9D-#1K*v2pYyTt9^jUYI3#=ZQefbOn9C2f8R&7%cetR_G|`7u%=h<=_bdG z%x+fJpJm5~UmO-odki4DTX0< z7i;RQK>9tMx9M+xN~U!yKy=&!{kfM|?eqm|sDwD*c^1ckbm8~)bCj$dwNWws;{{|u zm>{*e*A5Tu-B)2~@4_=hmQ^*>YrfDi1+CD}&u6VIw)uw)7h#(yA|1*Epm#FR4?P3)5}?Colw^Q}vgc|PF|N$_ z=Cu3?qlpX$|ufxOX zlg-TCbFQdkXoc)G|F-DgJNt-$mt-JjxY28{@w|PYC z!X6>uXZJItLeqvCxTA=Bavq!Z6&RMj^1M;M$U0ZG>dZ;-p|G`L{lKfthPzbbWQRoA z#xP&{YF0gmq!q_s-|Ei)@~Y;H&Xq5r17&rEEh;m~E6>>Tez4O&Cc&;6)>_ysRCGM5 zN8v3~sZ>j0=T`Tgktv!QtD^sgeN^ZcxP@vHGvGK{X?cu8h|sYw7^<9%HFKkF3ld2o>_8IQkB3Cu@Ov zfoT4)1Iyh48#RvTGJ{6$_QC7)gtOtHJUJkp-S%m8U?*>QC`Y8^hG2p6OSX=?4g4+t z0lp3RxY=Mt^fw}!xmcLf##m6iS6EOg2z(c@f{4JkjI)btO0ou`v%6^1X09o@)2%hd z`3TmO5v{`lA2zhkF$+O6%)%5bksQ2!$bxc$748ODuE%g?#>&ZUUo7~zzU+)a_AZQs z5d!XWAtQ=2QhM6sCP`}=B+U$5nWSI587Aq?10zZL^?wVNII@XMUswRV34%0tcw2&Nk?O0)<6BTGD%w? zqcBNVdqC3QM3bbg0fD5OAT;Q&&M`@vj(kAUcOcWKnPlJ~>c)gsA?miWmW$(+G zWw#av&G^oi!C}8PxbTR~@?1P?^$&lbM1M01t}LQg;HdA%nS`w?RRl*>)lI_M7-C52 z*FR_xc9RE$t>rO;ufSC{6XPQ9GmRe^m$L?>5BHi^Ht*CL4 zQ8x+zgZv`B5KpdRBzb!yNRqX}hv{oj?#VZmhz!_x%1cbo=SeM2c# zQVccagFC5Yc9;K*K9i3m;|K$5<|Sjz{3Xxo;hiAXqZn8E^6}=>Ir4zebpb>XecUW~ zJ?w5Iho9dQP((G7OwD7?*8xahy(=GEafGOhFn(tGcdF;gBLHP0+E*zc6VI~DygZDu z+gJoM$A0oFMY1p`8ZfT1c4hj9?#uL#gaDUbq|yY((x?6-+O>j~g1vVZAGNp=o@xjj z-c7>Q+bf``Y7*TG(R@oiG6!`Y@-kfCB5GSil=@SGt%o#NeRW(UYs+Oa9Qg}u?Wo~~ zkTCYaUJTEqwwMNj#O_DKFGP z>}w<=SpN@CtDpmIa1s~CdsEM#zkjTJG@BBj6ZwS~f{&(RH2-|JIhq>-0q<78?8mScU^Q zqKK93LTz8Xh-%;oqpV;yl@`X%Z#2`RxMBE(i8}8AHjw*iIPn$T2yVN z_>lXUYAS>L{axx_d_WcOq@YB;kFjyFY-e5I0W&xVz1gD4E!IaqOCLOa0cCcZ7OUk= zmaO{3^R+XmuHsy~&w?1Kv~sKcgYhtV1`FAs{!2{nwiz%8N`vi9Zjy~E=iB03$-D8s zfQ-hw$}?kdcD$B1w>$*dOV)#!^(Ws;)(iHqu`od%gYyc*q=)Bo^~?l%fvg3^A-zE2S*=W8e5UWNSk+L9mM%cR&D&K=1c;Zk z0h!NN|}W(6(2})wVNpmmt8FVzas1yZq&iMW;w(-SwrReJeDy8xJ2N5>AXv zXtvosRN7lRvb}uN5LF3`s@T?Owsqw<&@<(ZlcxS$g2Tex{&DAAJ~^Pk*$d1kp&Pm# zqYJ|()0ag4kV(B523rUW#6F4;jLB4I*lLvMZD3JHPU`)EvxOIjnu8w3z(2xSW4AMc><@|lFWNGNOAY-a6WXgJIs%Ct}w z`YU4%kHqQ@EJM@$px_U4sVU__v+#wNiCpR-e5AseN(i+nA}!qe+NpueXPoBhzk`gt%w>)SDzNCf^ z;sfhjk$&wUE_bg<%^iy$mUXb%Ib7`-|DYVHuPb2jc+`2DzHGeVM?4Us z{_BRteu=7XoPUfq@^E2OtG7WOYA}vXGyIPwkx2y{2cgu4ms>Xsy3?nF15#FknNVLT z<|Gv80Wddxiy^_h4C3F9At^elnd~!jPua z<;!|kRj1+*s0t|b9-Hi-ogWq=`T-WN3KPz zo{!HAf1zp&0M~-}(!lLz`)9EIcOn}a;3J!lM}m>zR$pl2T&&BUGdRS+*}2}&i$Z+% zml?~6`Wsd90f!&3Ui)!Yz&?j^LBO#AiddJw%LByp+3(;_z&_Z3Mi7M$@zDTZ{UAMv z`@VSZm=`f+u=^PE9bzndyEurBdea+WZ}+y$@9cPN4#nOsXRl#z7eF}H`{yBj&H+a- zEbh>AaGNt890mgf@22q;6RLsz>EqRJ$UZB1llZodaBN+76^3y#oRC)VY26B;hEMB; z_%aWl^Hq`nVFCRHfp_ZPb*Y1WpXYg4$F)X~?wrV8*uu{h#So~MUPRZ}5J)6-h^a(m zdKTf~p`pONB0$`M#~9JK-OIebVVZ8k@#=dCzc6JF{7#pm`=n#CkdUhVfHRa%ztTJP z=@U6iXErv<=};kK1zn6;fjN?yC1~cWsf5wh-f!`tHWLci>(Q#vH;)%()X5DJl!6gmz+qp~o@$TI!2!OwtGUL9@Q)sS?g#<3Sko4pyk0;?EY?$kUGmekAx$6)wpz zzy1m@pIF&nppk*tVDIM_6tbpcQtBL|DDWxU~|;`|)ce&KjDGdlw=6U5wu_ z7h^~PaRbd4KgGFgf9oC0-9VRTHN0Gc>%SrU(+J4)(aE#CbJ9>wgs>m6YJ@cRGYwxn zN&a!xc91x`5C<`z({9A?c}@AHF8C;xj{(^o@g7R zCZ%_~Bi4Odokp0xH;1GC8g@#+@n#N&#v3c>no{$Q#95=tGWr5t!1%F6xN889bh@Hn zMr?A|SBUOyMRzYWqF+a}$q}zc)?k3kr-37WavOC=k0H{0Heq1|-ef}`LOeh4f~n92 zrP$o@ypB|)fANKEf8B}VKdUq}I0gN!)*wC9LFByeHj(thk)AJ1xR3>(qJ171Xh6X| zXyAsAjRra}a@BH4nl&A4*tqaiTbg!46(AzRzkDvo7v4H+VYXv5azH!u2T{M^P;6mN zOWv|gtTvG{1NVn+-B@qY2gRXpcvOcCdF1nHD2}otc4U{fkyaoOX3kyUoK5!jc3b-@WS5mv#1^0h1268d2$dzsxK3`OZu z|JsBoPtAyTda+fji;}^?E6R(HY?MGt23$i>WWbN`MZ=r-HjyX`6G+I^&#?>|3XMXE ze#Q_6V>T0ahd%qtxGzWI{=CT&xSAjpG*d3+#D^h+B}hhahtpC%B1=_6S+(T7ln-Y? zK75p!j++JfaGGSlUAIM)4z5I@cR_ijwY)}x1|J=2j(qLVOE-p_c7+5-AY{ptYic+W z7!`aAUsC7S%7Z?X+)(GG{D6T*LyXa8ABlh1Y9RYB+YR=z4o!kTn%leg*+OHQAF*9P#vFK);59fMr&$EySQKM>!2Cjg!S82<-OP=m0Z8Z5RHNlk`E zQsBmf-Epxjq?o0#WUdqpi`QC6`UN1pEJ$R!cS(0zOxHr%M5I0vrC>QDx-?cM&DB#eKd!lzwV?z&(tU|O5fJW#NFt7rQbg(9mhskG zHv}4$su9f<#N;R!t3&`lonv(^&2GM`vI}s)F=HGGYEwwn$-~SA_P|qw;2I;|yN3kt z{yQVGUgy5EXc4VC+ervy#`G7|Kzw^cGh@&El#0idgVnw8iheRxdv+@fItzECWiK_7NPv zxf*4RL&3e`==tzDN$Cn?#Iyzf=~-~Rg)j92Ox%NN7Gii!XN+oG3d_`0Rpg#_PMd<9 z+_HzYyk{{b@#TU^Furnov`fboDtBZ3>^m}J7F5;QWMf=+IadaZd96ADV-_TK4{%+D z_K8e_e;LVJM3M7qDn{scusp?PTEB>y$KO_;$AOdEuVE6b9(9R~LA68Q4+OpGcXb(? zfY?l5hvp^{ydgO5Wo8SJnN^A9XUmZBmlPqPJ=F5PDge#wr{X)owyUOnVjA+tBi{CV z@sUyJB^v(~+OrYBfBI`#Xc5*c@qnj!uQ|d7hKEBFz?uHZ3E3IBk0#l0sT=vH=04ia zrg^>i%<_$Q!H|Eo!JbOVt~fHGGoYdW7yN))1hxmFMMz$W){h%F!?jyw1nLjSz&!{T z7+MNBTwJFA5ce9cjKaPy){G*_^S`0=fW5d3^S%L!|r}_tnc(S4#0fdNCN@L*&!*k7>MPVat1Q z0sE;GF)jOH;x#s*KPJ-EHyFIR2U1C%!G?wdsZ!|fGknbw&}QiT&}JC|+Nv7b%7VFP z@7BDV${^m%hW?5Kf|AXiHV@(^COs}#S?{VTcdQg*0nfKR@wu=4|7Y6#vgEpqI-oqL`?#BSa=ur#~0Nu^cbR+8BxDY zMAQR_QfZJ`jW@ZVYT}+M@u8Z?zDQklhfcxTUPK$4asA>MZ$6hG79(nEzVc$T?GRs<)#_;#CkmW+g02wyvrXgtxVm8oK3lK7m)NOcvBhu1Q$}JysZ>) z>_Aca@B}d$oFd~*Ru#2$J*#M~FrWiw&Z55|*X-6Y+xnG)#?0 z4yHmU?oL@XPmaf`_*XxSm8(s8xSg9va~<0_i(}By>2c~W5Sd&c zx2N;zlplTPnN~Sr26lI4ocN&T_r|=K#zJlx&9x@*Gl~j02F+#174WpSRDWeSDDw|9 zk-NaW;Y?(5>-m2{8N8~7@G@)0yoCLcn98c-pp98&XNRW3H1(*@z@xb=)seEDJDPxp zlFzX0Uq40U`>zA z`xYgh4^e?~g6+QxY{lp!&D-Y;vkzx?6JU(hmKPYDGJ#wk$NItqz16>FAQz^9L;D5y zT>m=HfXXuKji)fV0`?t0a{@bl!;i8{%5W($lD)OIr^Kz z!rf%t(;6(9BqEav>_~5g9MSsSC|=e|7$>(zfh66DjNISB#`c7GQ&i<1yA!nvXiVqe_|vB>-zwd3*~nKKnKQW_~+nk%aw$IHKaOu=ZM{n_+Wy*M)2#gTygN21(Vi zl?Ta%G#Ml_u&)Xae%x9YxF4p>Hupo&Okm@ZGKTXf&6T@4mb2O2o%T|aU$MS!3`mbv z*VOy%kg@KrhS4`dqJdJkiFaWZOfjl+6_89DrNu^U zCSwO0v9XBNKbc0c;hd~&;kmd~mT+q>LdRna(%CD+qi9d|KMm3`97S{5|H~*ka*|}a zEPGyC$$;mBo`){)3x;=-@ODu&+Na?R_msSL(B+~3p!YH56AW1>gpMzhK5uQMfYfTG zz;2-r@o^HGtHUp%JqZwvd+l8rEIUh+JsbtmO!iREpkJ*qm3zKQZ&v!ES_K|&P2dlK zeB}vzKWQ_r-M`SL_{0@y6aCp0gMa^&!H&;H%hJ%y=8&L`m=(W}2>TZXk|&bIK)kfY#jdfTSB8DdHUGfkw?Knm~Wt=Kyes|HBa*Iev7 z;-(h2BikrJ1?(l%(I%JCQwj8ac>7DD;SeG>8F!@L0@B(xxW2NoW*V(5<^W=Y7D=dO#)Cr)z-H&zyX8~w zb2;AKmT#X9Gm=Wj*b2;$NVej zScFqqY5W!IIQ!pPean?|eCS_uy!N(#Y4z{NuGs2?f6X!H-&+0Bm2=#KD=8*B*aa3b z_({%fas_uRU-SG(HOmY~>8A z1A(#9atgMTtVGTU^e<;*{rbr=(fiKIjI7%&Ecv2(bvu8G# z3|bh?YcXUv&LN{MXR&zB?g}iN5-XO|i>N>*pYIGf*JVguR^3s#F3Wnza{9B#&6ePh zul5UEzHReD#KufhM{qOcp9grs;C~s8BZF5Qj?eyUj-es{l4H#)=hz!LM#|LBL*@6+ zb#@H>mlBqWP;nV6I`m=15^laS$670BhDdT>ru4HRlHf4O6iK>5Bzfd^_6hV2+&G#d zNez9?W)Vp|gXQ9y=pD9?smU!#9QNOkM{vB_*xda_^_9;3emEqK1IdueanVQ2rBjTE z0!D0RgkA42siwFz+D_$o`Q`!68URO*#dQ*&wLmx-cI~3i^4|yxuMq|CHiS3isLY=W zPh1$ODWR+I()+!!o(>plpVYbz_ql$>2^kuL_2V{Z#SEu7SY7ZQe5_}fo(oYiI23Eq zJR;wzGA zP>h_KK|n0hi(a$Diwasd*@-@Y5{!Mw=c2C)&#fgN7y}aS2OJIVH|`U z@4AmRVcLR)yNyONU#o#IzYrV1GL?yK2WtK^SfW1Vqp&cv=od&bEx#ibpc9l42C2QG z;}QRSs)aNBB^ikWQ*t*%y9&-mCl}4xVM#+-%%eH-F!w4}co&A#&p-V2n4{{*E|xT~ z9ld4jIU^^xn)l#WOzNo0)-LLIHY7?p_V7AjBjU?pGPVX_Z0UotxNmtI5tetb(crB5 z#5#ruwG6^Ebr^5nf&C9Q6q_3px=jmA!=Vb z1kKvh6=VEr?(+POb=Oj-zs=K9A5s7c`0UFV;4i|U_SDpe^koC9ir{PS-GRdin!>%> z${EHZ$(rJ>tga5pD-6(7-a<<3sA z;eoZ>b#jn^39&S@o()eq2AsR_0mj=1;;|Q>pu@_+P=f{>(*VID#09-ke5RIOq`z~M zASIOC9lMiii1{AO_>&D-c#;)l0;u>#|c zDOItvgp+onPk;yOvIl%v%W3vEd^oM8uxk=iQK*#k73qwxvzfch`{CdyYabm1V*2}s zkAV<_!>MfihbJ=E7>tZ~v5!Js#2N)983s~idbNWWkO2;wAU2)<5DbO)r9a16wxVMd zqvu`%SgrsF5WwKmybC2bJm_Xg4DD1Nk(h92P6EtU{0A>Tm$zab0`=da<-(#QKfbv#%zuL|3ho;`H=%3y>jFT^W~Y~5-A%rD%I=# zDbqsp)`JoY!@2Ju&U1_nlYPOrV=vLJ09hHT4ojq^i!wrQH; z4SgR?ShAEw;e|SJI9aSOJ7t!#2NB5dP&P`Lj8e!SUqm)~o8CN38Q2a9^f?yxTL$(g z#J(k5CoOLhk|3Ljw@SU5O1-w~gGJpmP~wD72n$!Ig$rdZkr{&92e~ux7HM9c`t%E- zAL&Pp%=oui-zoVbDvUdi`2)LvY*%77tc25D$YvL3{QIY&0qvF=3!Y~if+k} z@Ep~<^MNInH|jyQlR^(%2Xl~*+XO4xet}wBu$0+ciSSijq~G{HSBc9^al~Y@2NLB5 zqh>S>FN~3zZ$!;JOov_Nr)}c+Q17u=UIT^1-*rD$zcZj<$bMl01ej3OOkbB<@uilM ztO3V$4X|(>f@vm@YY_Qegu}e!O_5eA-Q_?0CfDpT)rhL{fa8=CY2QX#TwMpZNQcqU zcVDr^;Vbmo*H|O7V@1tSGY#l{YT!iZv>J=>4F4H5Lw-elaere&eX)N(Gq*dQqj(cm zUks9HcMU#C4%-hPS?Y^VAk^xAR5#Y%?TDZnVk2`YzfF{{z5tAsB;aWK3{2HNtxt== z6Vfr?6#;YHdG8OiJK}cBMfOaF|1VeKNqBhW^l-iA5YeVfU9=*EXCAgLVgs<`bi2!)C6xcLR{gK^gtaI_wVnD}S2P zp&xj|92>;$e&3nXyvYw3<~OeaWDefXaLy>{1J0qq1QXYtDUg6MZ2kLiTk`;z##N{# z=-Y)ky^c4It&`Z9R$53~cmKgWMabxfx%FZu=2k+gF}DT*PygW-+|Jqv(^0GBWHU9_ z4ftGq{xG7BGi*W(0^UUvJcAG z8;KsH*zLNk0)JxwN(I>GQh^e^hFJkvLPm~6s{-zLh~kH0Mz;C^xbv&1g>>xBq6hbmbO8E^0^-`OFXOd{2BvXe&Zt18{oQVZO0C1Ggpc zoGdA;CgZLpw#8qxrhr-=ddE8q-KR!@VauB?8?Z~l6J^DKgDuTN5L?&tFt#cav1t<# zQRI+UVI~DHL!S^1*gYq}XS(&l?XVRLsI)Z%t9n_2DKrRzHNW1LU~z%WuL$Y;8Hu6L z@U+B)g@#iSr@oOe?itz%E$rm-r6=JRDhf#F9$52uvRx4Jxm)&Sp_-+z9=7Z2dBs^4Vz9L4 zQf{~t90G^8Zq)!s?hB#_2W~D&h20*Ukl-=}mX5P8h#5%UqcwOh9KJ?pCAhH8zWEi_ z+13<}0*-HPMvLxxJ-iq8GII2?2u{KitcrW#4FBeg#J(x6g0kpj*%r^)BfAb2Tq2p? z#Y}4xU`FEB3~ZwDjPu%ug~^nr1!8*ZcYjg~G7*#> zMwT^SfwjvS?-F3x;$abS75h4SB3a?gCVFBwb{xh76uYVZzsY4Ls1uMyVeLgrdrGd} zhTpIcDyOrF$3OBlsz+ncF0(i|_P+C6pQ7KJK5h!tQyxovAvv46fqkUHoE(%&3`b>XFRjJhVw?G<#GvrR9;Jglz znf`%|L_)(xK84Ol(LwEKKc%nEHSE6V!wp+4**@WJ?=P$lGN5f51TdGG2a_TPNselI z>TySFXYcPqKKUvhc&n=dmb^z8dFRz&_2l}{?V`%DMvv+Tkf#W5LCcnf+szq)+hE!S zH|0C^6gcS4mzyAKXMz`j?|j%519{D*IPfK0O$|6-?IvsYyS>PqZTh=yF_zAvXz<>r z`^yNw01SN?7_~ZtaN}jG)kdlZkV)zrY5Y~W-OC!08L0;lsHwW7qd zs!>;?!q_5tX_bKT+8E{S?@V3IR=pY01Rr3F-Ti}uO;Ka&jZ)pRRAhQS0SMV>)58eV zXU=68cv8f!&$LjZ$-78$Dh|`*vf+mN9}rnUgl%S#pMfqsD|&4eCzCZc^3@8!kYiHu zdX&oI0{j)8p^;G*#HBOGxrgZ>RA5C!k|G(v0M--ZAcBk#!kVH1b!q~v4fHTR2K9BsMh0;9xX)_;uDKz3SQHg zph^Is)0S03700|tj!N__|4DU9(88wW#{|YDa?X07OdIO}=85U_%K8*M}*uwFDW`c&%rM7G}U@&yyiyfiSkR3ZQEo zq#yd!bEW9D7t@O0@q8Z{j}z+gz1R)hlOvNqy#>Gprh=Dw;PSDZ|xx6tKy*8W|~5Sza2-gVQ7; z%K|@0k~!KMl-deRUEK(K5^C_`jKGr!geG3EE>-1yjb@T4+#9uwOb!}S!u55L$^Moo z0UfS+kArihf313nR;x(&9qB zAsUgdt~27Q7;$Y7M}6k`7L5B*1cj`8C<*Gy>KO%O%Y$hn^15jkF~dZpK=nesg{CQ_`1$5+e_cda8~NQG(XRccF-!RJvXm{UHSbAi_n;F+aXW;Q z9s-Q)mK)i%Vs`Eu*nyjjh1lK>_YFtraa znntZ3HgdZiNmfJi6-wOXdLhd{Yl}_4%E&v;)Uj-OEY7A{i(KP)gk@KicrCBCgxOcs zr4nHHaM{@UCye>W0|M$}O3-CIhBRG(;LR~DZ#BbmABn?sSSHcaaCi+FsZSUy&XcHj zoJt7*;br>W_(XF9-Gt%;FiXI}=(#$#8RU-Z^q4SeHv@I7f!g0d83mjZeDG8uya*}&_w z-jX$j)_cxZ5^y^oep-@1T~`xepf={{*eQFAFgIBTSWiJ(DTb1?ce$WAR~eZsU?$PX zBwszx2ny3-{(w@(6QNfJ89%r=gqtrooYD`>0d;ww;al7huRK-;AfxgrV^*v?!^-Ie zS%rnsr$94&D3~;I5C>DFhhA}D5PyVWldmqVAOUvjbymYB9nC~{vVN8_3o?pl3^(QX ztFM5`ZByv2S~hvs&0iLB*4 zG+Lj6ah00ecg7{vcoE8%{FjUAhq=f6s)*Gx0mB1Sc%4};hbG}ZIGN9y;Xq@DKFUi5 zc2EMcpv=I9%iK_`dvtCn#eGL^sEP;rXgQwejvDzU z!dsWTiO0kvBvpBmEF^*T9?&Eq@QloHZE8e9yK=Ox4^iB9zssXuV=vb}3a_`68|RBu z5L{3((IQC%Cm51D6KZ*__>IF2B*scE5hjJI0pQs}=&AB6C$R|1fOEK81kZ623kk%t zy4cg8v-VyM?)O_G4$97que`hTI|>Z^pRp&Ofj_q!g!8+1VO$NzAH)~$ zqTUL+%KS^*rsTbaVBXFgD7Fswe2YBnd!r!c_|kuZ(EKgHq9nX`2;~yqmkHP>$+HZ2 zVFt2Z8|3IqKcgoyEpUz7h0QI9%3fU)$ay!4RR>U33DuW*(O3s^%cf{~=MbG+macjC z;KOhCRk_X|o~nlrEw74zx6T=^_E-SOaD>LFCOY>Q%evL)%+Yjqne+Pzk8xk-9-}oK0oI%sT!>1EdmL0RWwYA zdAXEZ;* z;UG|VYk6L&W{lfSS$|Zniggc2P2B0e1)!F9JHfB#J^@3!y4o4*_ zfKOlZy$3tme6J)lLMzoH61fc_>VElrlX&;Y=hOI%YVKpe5C*&gr&~zklE@qe_rNDe z@Z$lHp!!0R0Qyh@7yJNH{X4Ny!5f$L6ZF0q2l-0dORCr})c}>CXGl_y8X0()rif|M zlmD1iP4|3{)sFj>lu}NIUC8!LqU@efjj#R`VR)t`wevephC0}^^kSbw$A_AO%#2ax z!IvQDKXo(^e!_=ZU()-o`xsxDz7M3GuH0?Z^&{e1mj}0LYh}rV zxo#Wx7-d%PH)XYIv*y?bxe|-DRna-Vn8q2=KjvV3;8?FTh((}C*Zg&D*i8rWjJyNR z+DI63#%x3TfVdySt!yIpSA4Nin?zZxE$RZjKxVi5;ARZ*;Xx5)`fX?R8t|UF=}HUup7Ij<24fpY ziJN@(>j}P);j6V-EtDGX&@YYQQVpFOnD#t`WsbAg1Xg;Yp6cJxKTv-&tabFm@0`a% z@hFpck3k%u{oD2EEmFIVQKOJ^EtkmXBLz2u-FXYx-rYO|v4jEZK00&Q78 zWe>pv~F#0$G7_?sD+&Kku7^9;PkeG z#F;d%nl0GeU#hM90sBP8L7#yLSPueAZ;a^GqmiLn4H6)uIA(M#2%iOZryYzwU_VEp z#%DhcD+`rxAO-R5E;2K1U}QQFnFg0~4LSS`CgX+qb&bggigmgJ-L^?xLgEM!0!zVp zj!_C-e+G|O!dJP;G`7kWwg{oBbn;uoBmw7v-E3v4{`DUeSH(QT`?!@Gc(x^{$SK0J z=0+pv3ttY&R}+X{t~$$CV+98D8@iEPZ3IBn*0DZO_6kKEK+N1W)NxeSi2cup72t$< z-;)z^udR7Yg(<=%v$?}wPnLKA`gg7=FHpfY9MqhOf?>(1pC48m(wSk1G6Nf9v9pB! zu1FvG3%Bo7+l-M7wRPgI1`*BIBM^BqPh!hY+6oIQ3eaWL#J}T|Ar)m?LpY zdl`wNpj4r1@48xSIcEIdYrwxZC?CW#tUCZQv61YA8pyun8n-bgcUD@q!_z*{ z8)8Wjpv>$Vo~EvG-{YNESM&x~56T8w?mTc3ye~N`hKDTwWoGd=qL$F|;xrj%rnuy- zpW|Z(lnOHe9B9w7MkJ)j&h91*IVvrJovA^k^)47LH7gGv*xp-O6C(7Pe$GPIqFiW?}`hU{B!$5It=u9qK2r}3?9 zDgiMi`qG)Em-@P2lj1|C!vE29RpTp4Wa%!|2_LDeNn&wwxkK+UfbX8}Mlc+xSMk*7 zrLC$pP2CN+m%r90>P|+$D;yM(LJ%C5U<#(s!MErnk zufMvOZ-9EL!*ShlmCTI%Bk>>ap8B)qaGPK8^uGehEH$%Gy06rZJD47lOL&TQ0L;k- zZ;5)}SGdN`coV+b=BOaagt@ADkMfHOcUpqLu;+V;VP@Y+OgOV`0$UQHvDO;ZhOP5b zdCxSjAqu3JU5e>>H4)Q#=!b+4d96gkL!h>7*;K3gU-)5pLf7NoWU6lLA zj1V68-S;TGF_-FJAUTp6=u3jHxcn_4nr8TK(W}DI@`ALM@vcDMs9={&JmsDhUC4B` zm@ZG!d5TUO|uxl{*w z{iP@GYUv_}zt*EhR-ummg4S5E*0W)FCRpj-> zdUHW5V=r8bUT9DNZG&5;g0)uXt2YD=4~drvS7PKm=*xRnA~=ftm6ALnuyddfayQu7 zB$s9@(RX|uXXD_oh7=-Np*nMuuJ^>xoe_1Dr^(zIRcxO6B0#~;xma&Fr8Z{Y1!Oii zsk7!SLPr4c2F(kbN_?g%gZ=fC-9OI^?hA;NXF*gZhng3>D6=MtD|hDu58) zOu{|&gr<9;P&l)a$rl=E&rRlb1ZaQHW^%Z%4>)tIEDsrBn9j~StgszMSbc=uW`(Vh zFkDM8uIE2Dh6N;|04WnoezAUT5yc*3zk(Oj(2Fx-<upHXE+iU&OFOmVYjW;U?Z# z?7~sq9Tt_~9qnn8fVjdH;^FpSYx)`7svoo)9j1A41{zXNNT!al5Pq=BN(3(Mm8=Di zv+1`T}bMgC^1;j#*?PAAqjBgImFH!n|dFF=2h;g^0%yt_V@kicNq>3y!I8{l_b zcSY|qJlEqwe;jox*YZyT`mJw`jS7kQc1IR*EAlY|HrHf8D$7}Vj6}Z)pCx(*$`>bV zQyKH}G^5VP)Ck5JYPkUeu}y)Z?;`}62YAC^@{Gwfw-qK=ZVbev4QdNw$&#-E`8SvX zO35r4D0DA8^Loy=QhkjCdF-;6#XSC*yCFyzUWh%Zl~;Br7eiJ%UqLbA!X3S|_p~93o>2)ap|TJDCZc{QIEI^z?@QVkMfA z)Y@auJs)y+hIw-9&Kp|U?>XCnn}A#Yke|WE&k+2mKT$iBH2g4Wx1TKxI3D>L!pur6 zo7@hpB)~PaBpnMBwyBP1;zf|@p<|ygAsX7TBJhgM?KWXHE&Vo52-yo2#uoCgV6X&x z+iHk;%8cJ|%Fq36v6OVgf%CaG1c~1Z*Y{y8ytS(+wK5 zA@G|C+(h6z6UZP?Vge%wtT%zF1Xh^969nEifwu{~U;?WN_)Vagz-$xvk-!5caFW2? zCJ^HTFw6uR66j|FHxTGy0_g-gnZR%YZA@Sqfd(cpk3e-3SW4i+Lq@Z|AaL9Sz9sOp z2^=NxwF%gt08nHCjR<^h0*M4ZG=TvG-Y|i?2s~o~vk1&Lf!7E;YyxWuOfi8S1jd+v zPGGPJoF~wS0Qf`{7HXH~+9aCP|F`9Nz*JIAz4S zvmVrXWLn?vG1ysq;sor!B(|{?_7;~i+>FG#e9>gZ*yd*@B!rwJJ`kN@Av9pawP71_ z$JMf(a%tCWIHlcgFM7O<4UeDqj#EFN;N0=CD9k<$`7xsumk;YNv|`N26>`>-j651@ zFx;%c-$;dgvypFMU%vAg&U%WGb>BF(lWhV8M>l4B?Y}~(R7WHX9De(|rQjl! zv`oXoA)@)uR6>+Mxr3dW`dX+l1e+Fm-@BIBiC;q`ih^$U(?PUN*rbm^D1@W;l*7y{ z_(6GQ&$b8@1fm5tbSKCq~)zE~vy8&IGI$Ne=T~$AI&_`U?J{ z_dHqXhfb@FUHoKpJ%VbveCvp$Shk25J5xj7a_5VCZ$?z%yk~$Qn~!871)M{+z<>W$ zkh(GxH)tzkduc1{+Y+}!Qyaa>yT@}3t63vB7z;SlfQM!6>*f@t3iW3%P|kL&96;44 zP6T$~1GgVQm=c$^ZbRjEbwgnpp^cfz-)ajRWVk8X>#jaGxd&_pNjG@u?;h_io7=s*`%gUb&6yOi z*B;@tosL;h%`-KSy7%U&hbGKDJK8-iGkN>8oQ%ZXnf@(&yW#Km*dr7$-S@D29ZLzr zGsiw!pEV6UMtXjwDnp^mW$>DLhVSQ+h0U@4Xt+@tFAYNJ6;_+XF{(kmnxvlL>>ChgQUjj%Fqg zEVCJPC!;VW6Su}=fhV^ei!1<_N3y~GwoBH%U1XaJb`nVJouUfO zGL{-;yo9X8V$5g2D*)?VkQLlYtcBBYGSnp8JVUMK^k>Jth`;&jOEVY$VThdpX97}@ zf82N$6O2hblEl&l;Vu_oeeGk2#gsn~+)|=1GXO2`6+v}g&+;*zm%hvGF3x0`B0rWX zPJ7_Ds8~-fDuX9Ej1ReHhv7LVMSG#p6XS4(#i;3>GE(Gb$=}+h zV(S2S?fcNcq0gSFi8W#RZgUs$CW}1Qh&)2(*HQl;Y9v#`>&?|^{+&ESNi}Zl2}?(v z2G``R4>$F9Csa0Y{nHvL7k_&R7f7&w5!k91=vzohKHz-) zH}v`^wdBo~BI2}9_8ba+&2iB|7#AjYnlP?rxLF?FfTKBGYM}Fm&#cagGLDhl=N}3F z5JrOMGlUznVg@k+j$JFDGM!(|I)2siK0&ylXK)_5R{G@d$I!(>!34Tc@o#mj=&QU| zITdvQM)4f^F91Q5QBUCmttfACz;RD?)OX1Ysqg%suUy~B2#-jGmL>DDUxbpYfxwoM zDqqDBj#Non%8$$S+aS+}!8g}_Nfw5Cv~Xvr-&<;qhFZubEhz~vj^P8gRtM2Lxc)e$ zQyrVnz8;VoY++0hj89CA{(|u~F@{(e^zHyZV^jhmkM@G`E+93?!Wb_Y~_j^tUkX5{x@dj7@@(MGO}r(7>;oLF8IJ$q*sS2)u6s$;|=0 zY61@tSY!e|0(mCz0fFfzP)J~+2^=Lb(gd6>0A!m$5`o?(FqptiCh!n}_5wt7r}I~- ztB;YjOw6|kgusp{0~HcDWdf%N95w-GO91;!Ag&OD>!Xn$`VQ+MVM#t zME<0&X-A{C?a8yH#w=W}qH6rIuA){EAgojyENIlLJ})uWmj6huzc#weI1Ofy;kc6X*gikZ%B?-C92zikqU)>8*848fB zThQQuV+Di1WN>%};-L(tiQq{km0-OR9Qzyb9V6ppecD+Ic~%FDHcI-Xhm%G}VOzzOz>tVRc-J|n0j4b)o=)GvsNOQ#kG z%2&)4c}O{}rJSn~vWCK9$mx8?>g;;#?5*imXD6YmdPC?@Oe=~T--ZnpC=>4CL6WcY zd~Nd_uC7KEkRw;4B)LiNe@giCG-BcW2cZ~IJAur|>x{_lj11Wu1)%DKuT=b~Rf1ov zpBN*mD$V=fBWUS+QCxCFeHdCp?bZ~8qBcAAA_LEppwAN=*yQije*lil-=S!9q8yUE zqC@Z*gg*%T6k)0@zLDBd+MDaO!ry##y)wc!)s~v3Nlgp&ypvoZ|3KuKeQG3rkZgj1 zl4_#d1r*~fr%>Xuc}C%7Q@D41Av7R=WKOsVn!cjRIfEg8MUJuap4nd!czvG zRXKz_a}>4W`iB#2$XcAMV}opLs;;5lyANp?FxaN0Qmw7Je4+Ddm49 zHS;^tflj&R%b*dSeUjDiQJsQ9=O4#ih|{p|EDLd44+}Gic8q4lk6tQcm*zz?Ea12k zxcXHd4yO(7PlJom?wEb9D6u+27xv^nFa_*?aLD6mvJNr-t&fWP z><<~?^z!QH#ezV}2aigJekkP!oQr=m`+hAxfVL?Xw0qJ<9N8Iinv@?x#N+-F(gk;+ zRmJ**Yk5<4#u!!gPm&4COsQUEzQEU9f^a&wQ~%5iieV7^;z!rB1>?=vp#BR0g$`h$ zgV4wF8r1zpU^fQFNKMoM))wrJr&u$gHAk8zjBaj@3pescoocK1|7KOPV^uxjPBUUN zqdKZ;_~vhG{u-Gi7-f824Vml%MKaqbYTl`5m^jSFM+2re3!HW}(r>vy2Mh24T}su! z+?z3A&SXSiWTX35=Yk}hunDw5^st2mt6(ffyzl+x=rA=ACF`3p1%l6^>eEpw8sb`j zK5r8$3k4qo7w@+Lnc(3&HITUOI=GbJ%N~0v8F8kwt8&Qgcf}YU(Hm>c?@ksm8?_U51z}%{vwgBGUHl!uR!>OA02fPQdFD>aRoJS!OSjS~*X_r)U zd^6BHlGzi2jRnZOL!5?uAaHmYv6nGE>^A6Ofw3t!ji@{Vhr8`ffgQJFSqwR+adFIT z`}rpwLCF`4n4S{Dc*OW5=1Igv-XZy~V1}i^R|MXxr~QYwSHV`U5{f}=D%C&TTn1+9 zWI)J1tt)a3*eByh%{^~e2R?-;Tv6}~2B>vL+0J1k20F}M3~g(3d`J3Bxeu@_(4l)S z#JUCiwv;(p1|QceqJg55@A|e#fLYwG}46gI~b#J3|KToKV9LXJ+IJwEqTz; ztXOgnZ-$N19FrWFL9_9K54t`cud3=RfQJE6U+-`RiuI6v>`nApxmis^IM&k1_#scc z6X`Gqem{XZ&=PNAAu9R;DHyF5gKUu!^Jam=CGQj1(b&l0y(sLh51eNX!m#ju8-LYv zU1Y(j86)L8Ud zN$>AO@p&?9D2jMdy{#Z<_0HP@SiOVh_ypOM6H}k4nuko+Ts#-LxrV1kYSMkU0PsE` zho?#E6Mdo>`*JuI$GrhSAk-bv(ttMST8W)r;%{IRTwIRGrIJbUuBdLB_d&rm*NJ-w z_$IZJ7y+z04mV;tNsItiOn)OLNn!-BVs0^FQY1zIE9QD5W`@KFV8tXz%=-(-8(2Mo zt;mK(q};M(q`+2W4I@vNBon}jxkz&Q-lrfckpf$hCxrNp230T^PvYGi48S_L%@n8q zDu9;vU+mlTm+^i|zM8-y%CC9lt0sW;8B;_u(7bLSDos#Kawb*6pG?>y@7zetX#zM_ zN1+yz%z_hGaBCEdrTOaDuryb3FnMo0@eFJ{TnOV~NHe&+uIshTm`us1Kh9I&7T_1k zI#zK+<%m<;@!{W+nsgmx1YoNN@P}q}Zy9-{2#5Mf$~bMM;}vkG#ND`VurfPJTWNoi;4U2Rcn32N-=u8SPcpM^%jK&{0-H2r zb?CzwD?_TN=oU$=!(#(!vhijQXBcnI>ecYhO1?UeXtH0_WP&;@xZ(N!qeO-sEqu%P zfPLF!p6sQ=^rht`H13F`a@1o9e}LXB;a!&SHV*iV5?oP9n)j6870F8Tn|z1cPz@PH z4vooxGyV4IJ37#P0K1_=n|2~az?pX% zy4SAYh`3;L49lQf%ZTb3c_SDH5>BMh7pEDIpMDMiOyr=E%SA(Cxb6_QWrg}xKXc1g zK>Wg!!aHk(q&ItDlbo-51BjGkQUH_ZUL9)Bx@?FCLwg_N6Z!8KRQs2~4%h)`D{;Xt zW~&T^2N)5usn7ZAYyOIfP&LEXY%7`c>t>$gjGA2w8`muVPVO0fheW_^Y@>qAk$b7V zO&^6$#`;iGZ;aZaFPJCA5S)ux3^RxdhL^J47Dj}i0+zib7yz1;1l50$g_Q5itbJg< znvL)X%zTwXZW*D4*@edh*Ir*0vkC80^NvRG8XVj12&p}y*RxOlrUTjoQ4Y_V?}US_ zY?xaO7r&#qW3nMOj2X^9V{Cfzmvn{z!+Mc*-#{+#+>1O=x+h*Wup9N$ywmtqUUj^X zXvT0EwnQEMO`Mhn+v`C*ER0U@P;7ttBKi#1)<6G|e7~aT#$}*6@+r|@{E+1qR%IE3 zVr6W9Dg`<=*=6}yc!294rbSTp>X8DVE3`Eu`Lwq17bH+OOBRkVFUUxFj;S6a^J2+3 zE3rr~3X=&&)^7lbR+5W;Vhw5L*HbbH_eMv+poimKBUgPta!o|8=)jK!)yftDzcIk< zQKmU>tlz(OM4B@gMnEZ*BZXUI_36XJyzO^Yk0Fm$aD>}hc&d#>v-9vrPk^N+vcC@BELnBpj`^FA({}yUxPzhF5lxEUR-NfP zhxES&(&LKE<~ZQ50X{_kkaL$LbS$;fZ!q8&j1jwJ?9M!BWFR6{eo*x)fSH4Q?jCoCYwb zRm|v|>er4|I_i`fNR3KO-l#o3nu*~G%r7oDz1k&OGk@5v);!I7qsF23K|&D{XZbh5 zeN6fjCAh5yE4xxY`PB|vO&9!q#p|~^@MH;?@qz%dW+-ID+DM%V6SQpl8yv$h`iN<^ zD=WEVR&rMKujL1E8ZDy7WF{Zf=05@RM467Iu7aPV^@i)onrWd5Q4LX&U8g_F z&A^=M%?28I2d{>1kkrgd++qu~eGTn%5fE8rYcI%+S4tItu7+_L+%`8MQXCc20U%FuA_KB_ko&b3PhChX|@ zYAe6XJ^!G)R`LP2GthrgYV!8!lkr_W_x%0tn9kdR(W(CJY26RIYoyM-z>p0L*_d1e z0(u(hZzAh7{{{dkONR|LI<+X+0^aO~vfmi^XKe{gg;`Dh>3vOqh(16G$#)J-&kBr+ z`g}0()F)^nrdTb_n}i&D`7=4iYGI1C2bh!Ec~7dga&u0>&#@d_IW^%IZBtG!U;XJA zXF)vK$1%r2g9#|(CDYg0VF+HUuQfGgSm|%1QA2k-W?(7|d|njlcQ2Zr z=r2MgCV6UWE7L}UgXvXq_3fdm2ut&5z5Qv+V^X`tOxrIx?}LqsQ+U>uvXBn!kaMt55BF3r0dF(Cc~E$>5or6cI^8sNH~)SN!P zn5k@NuvV|an5ogQwEy|sy&*O!-t-`vwi-(stbMtsf#|Jjs!WmWib!c%toie-1cl z{-V^~Dm@xQ<~NT$?TN#|mhAXNH^)5GAg%i^?mDS{*r;uq)fV+gP28FmU6dZZEfY2# z@##-&HmC8Z-!7tazQFjEp&g#<>49v#2#E2^_2H`wauxQ$H&~idzW_;X>Lc)%RR4yo z=#qkiFfUqFf1rPRfr4lMg0z|&QoHYQ|Ex9|D17rWx**k`HZP`kV$72mu<4jNA+?{; zkHNF8%{JZi`uhulI&YA`kWG6Y8{rMnY9|77k4CxE_$MLv92VxoM$T*VQIi6_Q4Xq* zQ*&dEFAA3(ss!y4j>;A2asL#R)7BOWCsDb`FvEX3Sk-79e3NK-cz7z56?KnI{ell% z)f{vQX>ePE0)qb>PFKZ%8dGQm%n4=8Ud%7cJCOhKUR7lg27 z*Gq{3Pq~E{dTTpl2teR$$@n`yg20K0PY?kygDyOdKjV;~Imiu*={9}i90!}xk=YuS zBdrW|`>|ulAs!8rs$lK3L`Yaq1)N71yZtEM5JT0-w}_>A+d)zYw4835P?}H zkVast33Mee)&#C0Fw_K^6L6V89D!sLh$e8I37k#@(8>f9f%+z}pFlMeC?#;NpHb_L z1df@&X9NzKz!Cy`P2gn$TTS3e0&7g*F#;c$fSbT;CNQ4Be@x&G0$vlyA~3@QQV2{k zfzAX*nZQ*92AM!(0%;~ti$GTs2wel<8WT80pt%VgCJ<)=`v^pvKrw;S;8;AeT1P;c zz{dpko4{KHN=@M1C0C(;>Wjlw8mi4_YKoR0@X~Ql)yO% z#BBRU0>@0?GXe)qU^u(@7p+T<1*?Df>9v> zA%TQNK*1gN_iPc|*hKpK-FmN+5S^L-eBU`=&dKY#Rkv>KRkv>4x+N%gHKJrSN9iCy z$Z?IJ+}wyVxH(FH3&klYUOUxu1sG}rX9#eP4RjKqmkl@s$h3hN0ovNY&u0LfU{aF; zeIvk+Ht>M}U)ex|0DEj;od8>G;57l>wt=Swc*O=D5a1~r&;_{921*48+Q2OWEVO}Z z1i0A-E)n2r8yG3TMK&-*0JjYc5FpTZQwlt_Srz40K079O#wF9z{>)>VFOPJ@S+XeBf#S}uuOovY~VHl%5C5#0p{7j zQ~_?Vfe8X!X#>Lr7-s`l3E;AUz5)!gfvy6aseoqcUqeol9@!+7xV{B^e+&2>fkTd+ zy&(1p+&Jr9Q{~KL4Ktr@^w~Vg#_N+GVoa|@CFIIwPoPfR^Vs}ytHLt zkFF}svn6nF%fKmCV7df$Z5jBm6?nKOfpIMZ_gH}+O5oQpZw0+huIT|S;A90yIYuua4hdjMbkg`SFzgB2ta@okMw#f8B>m`=14lTrt<- z($=nL_cX2?jhHqrE~14puElMvscY1RQ76ljkI89X;)5y3hx3Ld``dFi#2XQ9jOk~K zwW#3(B%?|ecI#lNt@H2*9PQ;R2po0Y+Ba}?#I5HCj$$XTHU8l)fuqxJ?TtmfTiXYY z-mLxQ7s=ewd0JT*hgHYpGmU;1axlT=)Ze#BSF)Ra$*vzo*n_#=|?bH}iL*dfO zI*F}zeXA6mrh0x_U~EI}w)K8ycve?D+Lq8}7nP3??9W7&+-(B;XX%L7KKF>_z#K=Sfgzek+;Sibm$9juaK zxwOI)E`6UXxaem6V6lDz!F;^ApKX1WXjp~Q){0n8f8TtDj8^fOO^os|?*}vJ+?ua54s+a3PPDQ)cv!mhy4J;KG=lgLM{Q-6n3Jnf!pBy`B&++v_4R77H2IMkE)<|;!oa^)%8 z_}eRz2qkmrSkP*&LJ}RNl2PNywW-PsSSAA!eOWA=U^jJxII?4q`BIK7kG{pY@`)6V zu*S-$J^Y#ZH-3?^>Y0e6+%=z{?rvM>UekZnbvNCEnI6>2{|5TJz|^ zJ|z5a^;|+5aMDW8^5`9nyLgM+!+lFaUj=Qd87F-+4;&eiS&1SyRq9`N>jhcdfeq|S zGWS5USl3XO^~P^^zPYubp}`Z`<_ygkfSKRY{NehD zSMQ7C!fV`S*O~9S;@&H&NOS2sJ%IxpmSX3mIDgZ^jl*?UfFfFv_O*yqaE{We<;>vlq#1;Qu zNl~z|vfs5Ud#$Q$;uVKHC!B|+wp+%<;$-|r;@Wk-t4MS@X0v*QhV?6P2AwC&Yh@|> zU&@@Y^#4-kgg1D%A=BdaLvm8R7H`>XzIq9(%t2EGw4YN+ zr5N9FJSl!3<0lh6wlM0X_G*hz1x0-RyGpc$nYd7KwXwLP++Ema)E0^;+`OAe)&T{J z)+Ivm7za^Ud=p}f*}DGLa#8+wJj_ngJNI$An&5BiT!Uae#(WX~z>#G1eVM(u7s!;X z71fyc;=QTxJT9!&%WG1>eB&6eh*c`|CfO<(kYPq)_7#w{rV2PyeDv|6qx(L-%&8bU>uR z=(GH{NPgmm8mz3A4^-(n{<^APOrX~bc%cpXHUPSX+uEHGV_7FHul9z{8&r+2R)pcp z;YXO_rlG|_CO2d16m#5Lu922F=$^LS9nW3-#Glsni>XbJb6+)%hkNvPa;J}Dw5gj! ztwRiHtIK>*wHjF&vQ(a%DRV?>J%LTBfk?-N%gyB!wKlO8Ib`Wpra*4P$LMvI-9*m= zDdu$g$BH$no=ZiAcPU=3yKpmlq1$`~Bv0UXY;O(c%y5#bzu|hy1Lk`KxFZ|QUQ`DU z$(g6|%W<`_{9K7SvF9vh9;~F?-OiU*l)qj3%W)zU=||09_;oHlDw&$yQ5?96J2Mx5 zaoiJF-^SccxEDU9LGbin#CUtMJN|d`sK6Lbpc4rRuS}-W7Fa6wB^L$HG0y{FzBtG1 zYx}k-3i_%N%(Efe{Sbz%R!7S``NSE)TaY z;b&wxp|GNF8f%}8kSPeQM+6g=n-2(STqDhuxJFbYq?zUamC~A-lp)+&h_0E9vx)LK zigKY)zECLR8fl)}L=XcJ(X4H>vbMHR(o6$|POA;%U{6fdNv)Gvt$aSfe<%|;OMjDL zsVx)z_cinQ2s);uV|_`5LD%wxu!DqLBRRz?tZ=2#2NQ2u*$=*>Uf(5{u-&nGy|2By z#!T?^z%*t`Y+=y5JUQI6nGY1aBNM`DjBN{TIan3mv^WoMV~NVkmXrOH@o!B^Nmfdv zMD@;-XX(OIs!fLu>s1mr^|( z`twqy{Gn7)pOZ=@p3zc~^J0sd)KEY2NeNXIB{w6M67EH*qdtmQt8ja(F2vWS77w+^ z3YE8()S6d#s-hP4QPh&7)Wp}O1`Ck*D%7apMA{IFTKTJNDjI9IjhV|fVa-MVmnxfK zWy|UaY_+5#Xq2f-Q!h9@3fh&`PIZAU&1$O0pO-E34>c9_Ik~39w^>cSr~he9r8lEy z)l}5y?X7m>^_@ekIQI-W|>zL z*vwNAO*MHtD^gg|C9O&(5G?8)Hy0zbk^X8zNhZ@S%fnxQ++}3=Bdg#2yJ^-Ajm|(5 z?HOpIH3LmlGthzHpO4jO_x~SeAjht{m5Q_P={L+L4xn_-bhsryfy z<}Y@ynOXqbGE3fhYfCZN)>7F#joZ zbjR(x)ndL&1Tz=&BCwoQKSq$zueZJKe*pw1b&-->EpVHMfyJ0xvbK7t8IP|%)I2UY z9|?2avGf*~{<(8q3{nJ7;CQV6RPFV?`C;xuCTio=McHJ2%p~Fw9OrMPt?oM|9Iy9% zoQ?1z*h-hSdPY0vp^e;^z~^r84)1`q>Hu&VO1TPXRZ>)b!1toMB=+gT2cUiTI7NE} zKjsT$rom>~CX821n{O9P+uYaH%_iMZ0t7!goiO9fdd0xBBb^2#ua{ls34rik_s#@k zMqiO0eT>Ql{GfJOSL<_vy4;@zf@=DO5e3S6kCJZR3t(O`@@ zLx_lQ&6Qu6?$U-AraMt6yYY~4b(Z>Ee*)p5vJhjbP5Ho`UY+S2?K81Ix_+%-wiV?F zOoCV^dT_uo=HrToNAGc`DpdDs8uFqos!(@AF*M@2!C7-Vxw#0vBx=&9W)3XiHse_y zSPmzPE6qTZX32BP|Dm$s7zR0`U#(IY&MjCHndIxh_h!tThB98B-8}|ip0Z7H3xHQ2 z4IM{2;vl`NE!I7mM(b5pXZi?wAYZ4IJ!83U<^rqb@*{}FwML{%LQgBJ05nVaC`J`_ zHYzCy|Esys@pdqr`o%0y^+i0582BQYWVahX^=9({S5A#K*XLE%FK=PAc!ERe$RmY( zZM9P3SqvwH0oQL4y2y=MV_}69*uM{BBeZt0X0{dt6z+qm;)vhl(cF8?1aXThk}Ge~ z;?gAJv0vJVX6l#xkhEfL5xGQ+Var6qDgqZ#Bn>RZ;mYL^VKzf-{copji=1&AwV$2}Pdi*e+h7i~??38#iDxrPBPT&~WG7 zDGEhe*}FhyEgwp?+Gx!)c_R7UuUPaeR-3PhBQ(NoitL4>AlPCYs_QcL5}f8|fG#~@ zsrmlN{u7a_D*sV9L^ZGcH$}m5ij|?rEJn+RbQucY(eSr!7ZX^tJ;rw-6e7SD2}VW&;Hl?d!$+;<&Ibqp+xtNwDk-IRl^5=~eiz9Es;|&|E*0q~jd==9;0j z1X<0cotFG8x8fbAO7zC2|{j0RF(pXX%sxxk$No~milBDgZ^U9y6ZUZ=5|=brl&K91m~t>P+Td**BQA4kiqg# zNRGYyb^JI3M;U)3E!R9VUov8+t(D&cL?W1q#bG8x5%f7SsOpTbzCfcY0~cPixq;~8 zaFpKP?TZwIbFIwVgks3~dEm$tZQ0L^GKOZ7c@PIDn2zvP)kqT$(s%!{QD!OYwpd_6 z7Q2LP{x0CuS~zt-f}?|@Dk`69^~TQ0<;E(vqvj0Yezg3|!>&YOfh%uLwm(T(2@9tM z7G%c>usXdUoG?sJUlQyXIM&CX$cr!G7Qc26X)kv=zOsz`6 zNYEMrFa_yu^BE}V=@sT<{JL7tO)%%nP#KdDXU?)5$>wy+kzihlLu3`-tBIgaCYWc$ z07~Pv;#gn6h<{xQA_wdSR+0Rg@y#G>E^1@mN-yBv;{3Lfko)i_?%>VI(ga$?)lgPV z(2ndCNVmscTWq-FNf~C$rpuU3uLyRO+Bf_Dzlr72lbnGg1GL+JpcJ_Bv}Ir6!m@6% zGgPp{J+02IZW@r+#qOMUo7f}w;qOl7jWD~m7?o4^4&?hm)L@H3_)dp9eZ?!>d^CyCM(>o!W8Li>~#Qx_DnQss)glI13`@cjRo zQe%5ehlxERJBS-tRi^Vqn-XNb zzFCd4)pAw8dyQh5L_)+o)wCwvAvwa>mphbR=gvEm9c$n_%$l3A^M5pDL03mhrY=~# zD@9yyyGv2ONiL{~T8~47+vF^0=?dF%#(R9brI+dBL1@B&k zXWye8DQ3@heE@%(zr}ZfvHxy$+vaQ;%GceEs82s=IOPRU_?G@=x*Ft;-S^8?IV^-2 zk1Y~GugCJf$x7pNN#krQFa1?Wy>VjjaYm6$cUoBzB9W6iWhSoxG69jx9E-v)?{pK% zX_zxVM}g&a6fe1dl=cFzPd|uMfQPg`=M>Cseoj;zW6iymW1_ho$ELEL6*S5`cc`pq z5Qq7jc*b1ij^AW9lOxX4a3c2}js;`Cvk2GVA__W)bPv|53VT;&Ws|XLh1|N= zDo!V9Gtc_~cT?!ea=Q>VUze4&0ajk5ArU!cn?dq5V9FgA zO6l-i*gHm!Ica_=c(&lovbdU0RTSCH`1%Ql$D=9D`EVuA&Uo^4q}+)9TlZJCUV_7! zY(;3hn7#F)$3!lkQ348Q`6AA4cH=MT9_tReC-Fa3uGp@+Tso|MF7&Jm{A5S|pe7<*xy+i4ajZ`n2TwwP{zDyfMx}B4$Y(C95qLoA>_TMy*LV%*P1R8Am3u8c0g4E z9nBq*(`iZT*YTVw92p{>xAtL&8IO+p$7(8(w#$%MdbM1o1b4H-4af18weFZ4O=J!Z zinhS5{}6~I%vG{&}gcK;Fd79?w!y+=J4K5)jfYpm}>?k?9i};RF0DNnQPR5-EIuYu=oD2;UTQ~ zm;Ac(W+pFgZ@w(fX~R>+`fcb10KHY<$W^}NK=n#ASmvg=@@`FC*w(_})vhrd;f%=A z>ns!b1!c8jBi|Fcq=k)qdZ-%~T~q~T73n`fB;7X_36Vb$bFtwRk+CH5+#FTkCggnY zd6xc&uj`@V330w;=i50{L%2Iof-ljf9|(7J1#e9cr#Wp^2h+>goaK&el@csUa0h25 zgBzAa95YubMHQtX7ZGR&c~+*2oRXW)32?;L%U zdQG5{%%)11npFeDU(&QsI!GnUml#a1;H)DEON%sS zR8~cLEV#%hvII?@!<5YUlJ!i zPHnZ&F8TR|@RJhAitmmemCU8P-G<+RcGSK9rY)rIeT!6WJM(Mi&XJm)bJPD1^{bYr zKs6^))=I_XpA%gKy>Q_)85=tngD~5=DLV-U#vOY@mQ`17{Z{(Wucg;W^XB|2wLVNf zSyJ_*tl0Fr(BM0fewJR~(QDv5s2wKS##V7l5JuEjOPEw0Tgg#bqB15`$6hl(g)3^Y zbFx@%ZW8H~p7X^>&^43d^F3|$_5zn~v z?{XpTgd$PIvzkSF+>F7MZ{uM;p?sD6g=9Wd(4y(OUkvQ(JUX{%dJz4l{6&kk!0W6F zymPe9wS1^^No2_!mlXIE+PGHa*R7nvghx2*D;7;h9xL=BwGvqu zZ7KYMSL`t_hhP!*|1?BFbB)zkw~Havr5jF8inSGM=!v-EOHbjOpp`!d3=xTKb|WTF zIW6i|1zX1oR=nD99d;;2ZzMsIGD)iRwiWB&Pz0gmKPT`*tgrW)-I$HHe;#q{LxFK4}!;L31k=ca_ye-EcijJB$bCt`gchqqI()Bm(!jioA=9OW#+ zf{pdwqj>FJ7w!M{#wo8n6TqOErOXtk9rK7eGd$prh9P2C=%m*IY5by7Xq6lv} z%}F~PvxGmMU<_0zc=D@f9}wws{(7HdNq)>i+qm28t?nF5N@DkXgIuyZwWD0q++hAo z4^ zsMkb3tVG_;ly>`pD0O^AmBMT%nBBl^{@#x>8XiPqs? zRor^xVy@@Qoy;EWjE$RKWS!ia34|8#=wuv1>mU`>B?52HgVUFz10bk-8O4RTWxdvQ)!#0l$;>(%Vn%f zL0GHcX?t<9l5~O{u8QFZr?xOvq~19@JRCd*CnTGPi9#=nCRl0SqBcnOWwbj18sI-e z86A5Mz|!@D*J3;Sfk^s#x+{t)Z2s~xuJB+V`(dCaDx^3;REDH9%JOR?eL`0K+mNp3 zHH%~P3Mb1FQtrdoe2R}ZHotk@L^1+io?#9Sh@KM}61~{~dRf7aoBpEqtG!>4?J*N` zt#gZe70MycvX9-oVpEZ zdtFA1>Yb{?{_0l!j~B#ffY8|f%5z`TvrP5Y{l3}m(0Ter{bQ=~#Y6UXZwrc;6(R3p zPY?w$=INYI=&>9Wd$bWBGdW|Qt+>6sEjjqgaO-0Iok+&(z_z8G#iONY+l&amQlqQM zzwG8)c|tSe6f-y^lO)Z@#b1Ai{@WT*Jl?MQidR6go&*x$jlNjJ=mHsD_MlFW2FR6x_D@S2LN*O}i)K*%v+6R7t= zLkQj~K+pzS3$RcC)p9#$Ny|Nd0kMJ$3ak}x0D9Vui)If2f(zzZLEW1NWvHMxMZ9H& zrZ*2wvO*td3~kjs^r)mr&l#`MKYg%3j;~FbO(T5WfoZucP~shUN)oVB$Ww^+(CP~i z=(R3Bo6yi{$$#k^vo1j}A=`g(D`ITOa*HbS59ViJMlwzm(Vl@`FG~dTV@11HP{mff z!iUXiZ&iR})W1~CC$y&0zI{Pze#Hj8#R66{p|IRH~CaP$dGYzgnO zh4oBxQkWeJzbeji=K693Pg~hmMRMkXo7*fo!Bxqb-;p(R?9Im>;`#*k2c*Zff%R|D z9UXZ4)VQsf{K_%irBKox5gy$fxHFQmr%(n;5q{EXpO;v>+p2yVa&)+jF|i4VXAy=< zX&q*mULpf3=KJ0}8$ z=IdyCVVlGq3KhWGL^59RNK+wE`8&h4(!9dSiss6Ddn^)T-vwZa!}w{WOa{I)>3nU+ z^pBDFdOgG>Fp@FDB4H#HNq&DeuY!h6-^jc{Q_XwYuF=dAoe#Nt{A@Z2*H$N$(CnQz zyL%ip^Y9RhedSA(gSXn};^6IDxxuiO!lU@%f$Qj|A%xc?B!)$aH@v+5*&SEK(6 zP5yZ)Bd{jR{)IP31l?WYmJF4vHl&&I5tf3mhqG#ymyUE?Ij#U!giQhlzTO5%Q%grkz_N7)HFDV0dZ12Qe?8QsW%nG{Xn zoj)XSOH%@+l0aHh0_R%^^oNjht(1VeVZC7|G>I1-axMBbup8zoI%*#6>_@49Vr*8M&bM4Bm*@yu}AARg0akvMj#a|Wr9lAv$!0HZ5S zX$`m`)_^NFtQ39{)**kdcKcp|p&q`|7#aSZ)yJdLeLpi7TX~y3g}i;8BzYT+kIVp5 z#A~PW`WY|e1N*O)L!MR)<&zktUs1x3vKjK!gsuoxVT^>GJZZtMc9HyGCt3@*5@}!1)0iJE+Rnk8mCsYiJL+3AWbzqYDin^Om~9k z0`VH;fi?S3WU4bJ{>CLV{Zm(-uje(|U%ppM61fr8Oa!Cqh;A>oHNN;2HDKEg!ziLOs@rClFu3R z{vtA2u4=JPPB&6&WiL&KA(TjVWGaj;gA6}!&v}uISc%TjNTep7Vh}Xd4w!L4`5Qhgaa%>0{WU==0Tt`^G!E|3EiqrD zdy~_)_LL(zZ0cyuDqCqwNoDWKQ`5|Hs1-m&joC|ZnDeNiNJa`{v^M4xYABL15BC~z znqf5`uIDtf{ZZr%8Q&BLR(FLpUa-WeX3eUvtUE66+{d!Gm=k*zz*l7y$W%FnX~t@M zy$)IxKDpyDADI+kA3+9oPoZuwpW+ug=g6a3N9W12C&HN~O3z?Eoy_o?kRT)SXTihk zymfdLC@)=xK*;g4ywZ4<^7+Z~X)TX9c2Pe2)iBXtkpk>sdoWy4@%GF$9{4VeZ0yIw zxakyj^@sO%-W>QmDNv&Y+ftNYM_B0%xjcjPP-kQ-maOvD-^~s#J`IY(JoNx-Fg`l* zdnAlZ+R^GOX*Y^;8V<_njWd<#czx@+n9r=MT1GC!goWp6fMu>c`A0 z_!+p_ypbPle|9T|i`RF_wZ(r_NCo=N)(Z!OE{=5uixSLfijJe`WyKv{xRN4oe)0(O zK;gNV*3~BrFt$unjWQC%1|yhZOD?YVN{$>`UsLg3UO~J&iO0b;0n~8D&*Js^3MJ^N zg-y!Y<~x`FQ}eM3>bQ?+{tv-=Nw6jnF}&B>t!+1E4wAz;-&Gj?o-6DX(s$#&D-?f{ zRwa7t?3IjbuU8&VdG$HT13wDR?O7ZuO=cV8S9a~VTH~I^a|AV7=v+u}6H($gW~eyH z@t=AEwaMXk#V>6>%+zH{S|dWXS5$&FQ~s0!n#}2LYXKi`0T;>6D&+X?I(o8yzvNtY zXj<8)D$k?fMt6uloUye)-m^L@);modwl-e(K{XOlM8#{MGb>ar_KR{mv+Z0~9T_kn7a zI#97>V;9(2sKlRZKn0ShoX;Yeh}MlHQae|KPB#$BZj9MzyK(d)%E|nE(Hz;B-DZVc zo~f=`AEi744|zlAS@CSLYBbT6owi9e+DC+XbPl|>8$>FVTeNO7Y zkGvt|{LvQY34>^hKh_kvvmJSzMBZRW=EVxFtSvr5-nl|_##B3%A0vn6JrbZ$F2=>= zqejnmXK36^;|Mh+^*&2Q9z%mVS)XR{WXCNt=!iUU=^;;l)(hLH7^*uqM5b%+^w+fURbLD$2}j(hVo^;;Pw_=^KC+8q_w`+RyBCyE~OrD)idnM z5+0Mmc>KM^sgOsc6(2kAG`d#j|+8Fh%NuPR>nRJ40h*c~|sYIV$g5eRyxA z&PTi5bLTB^BgWSejN~kETheVM5UMwZ(Pr+zsIf#7@wNs5 z^GB8N9vkoQhf>j<1dqnA*e*%*;aE=qUrCPf9E_6V|#EY(;w~8utpwkiTEU7(0^n`A*;?^5qU1N2p z3bPeKOy?7zYg~}inj)4@fI-f^0SgqRgqdvwp_x7WD}b57{k>4GPj!YacFC*q;bNTvJg;+ z_TwkF0(gTjG)cVtD%9@HGXNCZo-zDrUu-G(=uUzB0YN)^O;@Ihnt_~;GVBU<@W z%0Id`RhoAz_~HS^xoeVWh$H6h%ERG&-)6EV;b4Ih-$-KTt}@Lert@Q_T|}Rzq~p z-X8NXKZ@j)7V7t5j_pWcj0K_tNczJRpp~uWSKlK~6jb9f|ISA({N_J#S$3hH#l@-~ z?QT@a9T$^=Xl)_UZwjb1HOaBk=4$d~bbS+$)7EW9+*z{i9WRj^sa2XKMDijBD?sc# zR}rXoo9k5B3*6@GI0DC#{oN1MWckuWyQLL}lw$KBP_1kp6u7n3G3H&M{d)}FqPhiy zs)^LCxj~U`5;?ockJx%WQ$AhglP;gun11y;L&Mr`Sks1R8`dCfQQM{0E=Q=U|vC-?<^)+o!NmJUJ>aYqtEl|lg1jY?>hoYJD0wJ zTj(j1EN0XH&+xNRwk^8GTg{vcMdQZh*4RJs(W6hUCKvS+21R#-~Z{Qfc;8a1{S}h40&KE>~pgjpu|(0r#y-MFQf!cr zJu25ml5e6jV8r?g)VHttW?H40EJ-r#>*&Xo<^&sB-$|gNXqd{}ARGEidkO1fLp{3* z)ETHb)mC=swhj{dyQ=1TWAX(89k8KOvaPD=K}Ie6`s;}$>p0o*oGz&EfNFb89WEaK z#DjF=e0J_1vuSHrhEWQ{h!y3=5fF7J8#gK+Z_i0E0mjXZ(JsPU zoenUbc=rtELe$Dcuj3yJrQ6ggBT)zg3%vUFfVXEh1AYTp%rcU;w_@&ftO3pV`N!WQ zx|Kh-PLbU@<@8RgR{MC-ul&hUpDx=XZ6!Ou+GJHXR)xqd-*1F@(jVz5VkWkoRVAv3 z+nL~!jeps(R}kB5%cnu+Wu@nJCOTePc{$C>Bs%c{HHn4}k)@bQSz79i-7{rt{#S({ zbAP?@jU^HI!W^SKZ~YI0s~;Hl;5vSlbamg0_P~1A`1S%JJPr)F1NK~^PO?Z*tTzHG z39bAlVDs;`=S<79>>=@-Y>H=cfaL9&*eW)sOcE zdHh&rTjW&mfXvD-9};9W1HWVL7fjJ`cq9B$6Uj<535v?7$Emc<6OXI5shLRIJThN| zB15he8kc0D%eBu)ECrB?cvJaO2X)4ECuC?{anMY{&#TYPDscubOz@9jkXTPVKer^B z3$5$`iRqW5qo&AZ9^?E39%rznjb*!4$yBw@j!k2`d&I24OE$1S`Jg;)9~9*+tx1ZW zY@IL^2L@WTvHs3-iX>Uw;`QNNbn8z zOhb7fWeL}Cwy3x(i3``GD1RW75laR(jD4^u{%hyq-`&&dP=MZ^T$Epux$q4svP=vN zn+-fOTxljt{?!83MqG`JR%sri=1*?L){-}A3&op8o43;3LQEtr^3YDs6d|Jc+3;z# zg)X%fd)$tvm8YoSrkKYGAq~f2i$kgYg$8^IrXW0!rC(OeZ}538mTg1gugn;lYX`_b zF%pecbB`iR9e%EUF;h@mqjYp?484}FwtytmxSgTWx}FiJAEus|6VwAFd*pTlGv7rq zN+`Bo3k_9>@b2}-8RMio`&NnMeryEwa(qs>+3IRK zM{P8Psc>UVVPl(8d4P?K7IJ`P6Iwsk8Z%z&B&0d9@LSkpO18~Jk)O|;JTa}ta90tf za>3iJ&&U?q!~a{7i+bA0O|X;ugh{YP-ow>4$xIc5igBP2O&;mT{h@!J@y80Bhm zl>-@yZPiKmO?K+pAo1c_s<9F_Q+hoQ^-_eHS^r!1@3E6P{m-&b2Y^2mSplmn)h=o3 z!w0A}L|6t%_G?kowE8u(6SMTisfO^+61G`|&CL8SJ>(YYz*a99$Ec8)cc_?6y=23G zt2`}Kss>n71y+r=D$r$e>17;Ez)!7WO8fj%?qmD8Ll=2ZxVb#r-$^=QLktUe| zMXS3UlpBNk%+&vutHxe3pE+B~wVH^3(o1fohoH@uPGb52bWWO$rbE2!jYxUgM%B-M zQY(ZSFuiS(*QmTmRc%xQibE4CyKfXnvr9K8yBE{D>y4-Im7Mgmijet#F2d_}ga5(; z_Gd+)<52`zRR41k`ZpC}noY8s^7@k^9KwK$RpX_k8ZE*;e5DASrARCM-;3}wyq!cm z`#%<8CAs>~MYs_RyTi)HLP&mkO!9J45w4d`6Ic|}#gF{sqGY4nmuX77LaTTcq7O<#4MW@|l*@#2UTG#59IbG=ri6DVT#RbGXY624C773~ zJXp>AmhCs(^2;>;rs~-08IRk6eWHOnrTEW9o)3myYC-_sp--)b9NVFWme|-=CTF zUuL*`*;iUK+|6uUrS?!Fv}?~=2idRwPu0}%8!JoK{+leN{+BF0r#94TCi&Q&t~>pI z%u?CcR+e@i{_|S;Z&}J{%96*<(lSUj=N6jP67NUz?%WJ`t!4~CF`B(cW;Jrpe% z3Cmi%KG~cL=kQ#r*h)?u`#t;dQ?#mma=JYS0KXT*!dMm7cD9_A35@K(Ij^fb zey=I3wtW~e;VE?(@o^ABpWSF#3Ytl9LrEa-Ty7YOSTvjh&`~QF9$n`Juzm4Au#{#y z^JiviE7pQ+9^}K7o4<_i&gT7n-ggTnUVs~JRJO>SXKL{J#jr6L&}an_9zbJb;8yk? z2Cqj1s0di%M~QIpRLUaxK9x8gZs3`P#3~jOxSBJ4Qxu0C@4B-!Xgt`UcT(D1g1 zC|sdM|H3#)R&l6rwkK4aZQO`r7d?E25WG_eV!AVw9%N*ALg_nY#<8CKUlvxFX^MtpRfTH% zAO1!|k6R+mQ%->FH6FG?c0WVNAQiH~4q0l2bbpDE(^Sa!R>&n-qN;X>hH>ks9^fy-K>l-s`18kI24c+6Yd+kvK!H^lUe`P=$q(OPuc-sC9aE)bX|;^;qxB z?UE)6o3bYviwSBsVlw|e53j$W6qkT4C$i4Qfjm7aWJ7MaA?|(LBN@=^^QL5$7I{Ux zU_=&%tVipUQ@Js|YdKZB-dTa2&FZph|Bvb+yht@k#rqGVN9yE_HVluB-4uHkilwgn zF_{b3R$Pjpi^3M6TUL$iB2|(y{&6>Ze7!hZDvd*2j;5_gVb$Sos>%?7!A04|wUvT- zQMTxdIv&YEVjZZL3MKPWf$faH-3ACLiW1D0wpNG24dRL(e65pKGY0X>vJ|-dRiPj6 zPc=0h@+c+J{I`_F1vCogCl}`*U)Tm0YA*T5OXG|6Z$*)!{CweZU>H}X;Sj`AsP*E| z^jMGfk4?p)g*_vv#(EBaN~4O>pRwYx=n)(80tP{`zTK-IfaIJB)JA48Z@Q1vQ|d;A z63!kOObN@3KhK?ClscQI7>iPib5O^w6GWvU7#ho?jpS0l)7c!z@7{WqF&Nie3#O*;`cOO6K=yzO{YJ4`A zS-_xZTsGEIxR2AkJvdp*Ke6yzhRMPz`w;JL9J~#?kKx@U9$=%r{Ui@#-Ul+97O8fq zcjt%w4yJ%qPO*D*O=13`hhMgfdAR6~sCZo~6Ilm0&r-eln@}y(9kJzV%w7#1yE8J$c=Zii$G8rM6+Bpi z`>9}&MqHHHX!<9PQ!wlNFEmOvJ*8_sHQ&V38pn$DcjRhI4wCmcPmuf5I)Vx0`Vpi- zah~}1J+PPlFC~iZ(Nm5`D^{&0a*0za*1U-{nKU!0kM=v&#Q$Z05&unzjCc`hQ4f8} zR6YE(gZjF6fw}~s44^bry~I9{aWQK?8<^K(W!TZF2FSSUwyquF`CESE9CC;4M5@-24TKObGBJ0g@{6szdaR?+8 z7m;1eali_V+04uXf!3F~SG20iM&k%~W)dqRXBqDos##21f%!X@5shMje4UIy*&}W@ z#@!@szR&DVG~4S!<#ogyiWke)C`g2pa9pNn?FzRY6-r+Zd~BG|-e!!RuEm6(mrKV% zHL1HoV`4F+vuLj?G$qcJ{~;!Cr`1Ra5$O%ylH#kjLDrfr#4ib4km66o;D5N-xI;2V zrMcD2IG(l%)W+v8z#!UE$=|f?Yud;(pw_BUS=fY2!7e*?eB?H5iL1Ph`w8Hw>-yV@ zb?#75;V5Ytk!2bO=}INxcjOl4K(J_|35f7+%WkWc-z@1ebBY{pAjOZW4u$YH$E(_M z{Jd240`jPZFzcqY_Uog(}(lB2W_tL%gAWLb{X1~zenp9}u1S}Z?vv8F^~)(vK3AWm(}sJ{ub9m;YA@_ge_}kMADw0N=`W`P;@ZQc zL;v~$TucsOGJ*}>U^aNZ>>_jq!q`Gw7w6*XUzyL~ub{MQIMq3CTI2gE*f--IiVPz2 z!)rBor$#V5`y?=Cmd2cp!TxcWtMsI*7=3?`laRz z62`0QwP9o>9X+MH#H$=k)Fvfn_=-bQedPDBkE&!n;V5D13ouM3(mN}-e^#=s9{!MIG3 z5V@w(S|7_q%iCeM$QE?oLs%T3>Ew+MK4abS8@)Lj?e*;kXl#mP42M1zNmXeaoBt_G z7I#PX;ixnnigff)nM(n{uKcI#7|~kULaDz{V($?)kG#z|e6>dG&|bCf|KZ+v^T$M@ zl_Y&|s`2<$nrIR)7lLHdEyi%hy7bTv2zldcz{a)oktO7#|w;^8yiP`!U<}pekYPifY52|X?DyFD41+RKuZ%NlL zNi`n+LXHs+gW3T5cNzvr+`)Jm`Q?2T`Fg`72jn_Oz(8J%uahxQoCvr-r?W6tcNlS3 z%H5}V@4C_Q#mhJbEC|(J9Zm5%r0?k>OMStRw7!tEr2ol5ezbx};B=@8*WGK88h$e$ zWBAqhWH!_7khWIHJreS)3aOP48Yhou2Glj1dgC&yk`t#%;niu&fNP|_&rg@` z3~N;FyIT;!$u?r9F_mL>*SEy2$1~hq=%C37D?=ii8jz7;_&$>=m_fE(`qv(PlQVB- zroT0I!?N;bWcm&djO5MBEKL!(B#@ir(p=x#g}8x)twLyJr_qW!rd3Y$mE>%FThw5D zlXABD&XqZ>2XmSg#g{_GyfPG{a0UwtZlAbCYYlgTvYrrdEqI*Y~PMZb$joVz#uh z8A38|W`Vz-V)x^VU^1x^E(z|Ya;PV(no?CYg+7vMa;grjNJ4I&F;J1Krq-u$l@eq^p8JLNm6g&1mqWk4&> zqz?gS1Dh$9d$+iMpeFHuPTW6Ats0xRDosvPhEcU)p22 z)JYH{vHD)~M!^&wMi6CW+$Mo)QP9dhr;vy`)M-BpHI+vs)#yFHlbY*94PiR)ZRytW zn;zs?l1XJ+oiR*m6uhY_xrYg*Qe1dUa$%RYw8%3}Sdb-5DOqY$1HTkcvSO`#eOnktPjMaNE|6+<41*CfiY`~2?06D~kTZOU1_`Wjk}qaRw$Liu+l*zZlUif-73J5eDv3rDBbN*WslsfQAb!x{ zU=o&o;|H%ntlN|)%P`UFM8UJ3RZ12s-lHm{Kr!eybomo*vUj``vRsGp^i@o8Twl6cu2t0|YK3kUOK*#iIB>Z<1G^ibfK0kXekb zN$~xXuvs{1s_|m*2+gM!+WwY?(V1(>2t|iQR0{|SV~HanR<(rQCEU{hF!my@Kv@Mz_PPyHsFxjzvd-~gYm?)TQ8!%5P z<`OkeY=4O~0>ACb?~uQ>8It2!=z3z$;+{1?llesR7761X+%vtEP}ni(r(P5s4N;2? zo1|K#ugq~F$8SIOiV1(g4BCu4x zH3b(BAaB?vQh+U>PXlN$BAdA2z>a93KuQi$&6ba9Q5`8;AC^9Fr<#zS;q<1`jDg+2 zB!e<)j!EI}XbHKE8yFSQrECZYuzG4PGZSb6B%bSJ-Fnca|KL1KSO?}wqe2AkwjjC< zQBc=$-IW(1PFnAuVk>9VOA zeZ*i62Z)KBd#kF=7}d95qj8b*F@x1RRcqy_RtTJl)NYKTHjJ<>DrhLMam#E6ymx+# zRz3hw+U-n<@y2J&i}0H<*i>UX;-7?i_}cOs6g@-3Uf{Pszc2IKk>9HF8hTb^@vlYm#zb6`8?@!d!mC{lb`&f6*)G2*clEkiMLcDC2>fs9{{-?}R;hk0K z683_&wlLO-5>WYm@U^wBuFNMJ;_&h77#~T{)+Th7;IeH5n|>-n7?@e^U?+Dlmn~E~ z(p%n^774dg_U*(bH*)#qZOS(Le_+mJ|0pWs#_6+^kVv%%b1o;5D%)o$_VVqP-VZ46 zXYgjUz^@HM%7CnJ6^W_6k7DxX8TYE=F`25hvKI(5|H8+GX}?g$Z3C_GKTpR0c#&T& zZ;EUveO!s<$Ma-XB(_Kf;`=ITM(1XIJUW9ae@XiIbh(!C!fu)E{&kYy9lONu3H%zg zvN~ECz2DZ0=lHIbCS9q~#CXJ)j^vx*%jKKs>#eOkY#}CTD^Ig9xXt?|ew=*X-VbiL zBfhw|iMy@kZq+R##zep;{;kCSXUl!PxWBdNwebxhg|@yNzA3&_VbFdSo$6(B#e`^w z`-1wG<&KwVqIrsct@!`Vat{=LbrC3(_;?mcuE1X_+rby2slNH87xJ4?I)m>izDxOb z^hx1P_4f|mmdR^4TDi0y$~37(A-7SiZ!pHH8@|j5_+tiDADKlnwIv;T=fYcQrp3I8 zOOKi(@j{8M2ViyPR2+3=i|f&$#MR>9G%E2#4v|8R1^d#O0$`m;4i)a05{@B4i9do> z)tAchYDG*uBBa=v$>J*;6j^8sluXEYW}Gm%Nu))7&10;BvXyNOL#35ZRlWSOZN|%w1gDSc6Myll8Yh=_+mY%zG{S(qOtf!BwgZ_i6 z*B3ImD@M<30ErdGaVhbr*!3X>`mfU@`XX=|I0IWUxNQtaW04wT5n3^F+QsD}$C9H{ ze2Eop7_-bq%iA(+_XBZEiXLa_Qz?LR4d8TPgoP4Ol@QUg58jsIZ)5C}#~_dcuGO+P8G}IJ zW;)nXFU}iOy;R*ny?k=Dgxq6?oMDCRm0R!|RLEBWyh@-YZz&*73mhQa z3`(jJ`O3z~VkIYk+&#58!9*DZ>4&^-gw9>H=sCrG z-1u)21dDATsPL?f z@qF+^c5-dt~=KLaWP|t|*PCFzA&$SfG z6&k#Xi8f|b=-k)cHQyw1?~%q(MNOip(Ps);kz}J%g$O&+k=kxI_9~QpY8v~JrgetK z#JQ&tgvni=-$mBWS>|?QDeJMqSqF|Zt5;4HFu{uMh3-8C=D>RjtmqCAhDjyAL27c2 z&dPKkK_pUS-o5mPC&;Ilx4&l;=YQkT_dDN`jB6{3)l}akHd0qs?J6B@CrB>nX7h~0 zF3Et!*q%ce88Ls7sabctb+ejWhOqV+Ydpejq=8WND`~J$U5NpBLLF7W5X#$7m9Dr0$1j&d zv_B~^UZQ8O<3&_Fj|+yOJB2ZkI_;-QVs%89>hd&;%<;&d7ByR4vI&EMM!{sWCr~|4 z3Qz21)}@s4HiW8K->i{5L^cN<$sPKmxsC{6#rA`f2E`b@>yBa|?WgwrV-Ssg8qQQw zoM7T7cnHp{%fT5dIEh>EGK-@vlE$B(G8HtJV=1pp1iIHN2YFsEz*6pbD+W*=^@QPjx$EY{_B0hsf}$D*Uc?ETwU z0MOYL*&~<_u?sPm$yP*Rel4!3M#o+S)EgtRq~YHK3apcxeKFb{M*)mNEbvyEKPaqa zPe>C43lF-3kBigXBi@SU9qOpnPW^TPly`Y^?|F^h3z~b+1R$>y2B^C@pGpw-S2l4% zpR`WyQ8XxI$M6Tmn#5GTmF6$XD{IbOx9;vf;*VPe4yXW)O06A8uY)r-LuV zWjq^Zk+x0?9Y~^6Ik2uY=P1&Ncc=CjgI;;FQcI_BBq5pz*9ay1Fmdof8H|x6Bk-2w zq)yg)`p9;pel<399CD{!)OQM!+0*^uLb9HC9@Ir2D}Pq%!Y37LcU%gg)Hr?;SEKlY zGb1TI770}+3W{p}$Yf8@lk5$SJ+dR5E8z4IhpwIOA33uS=5v{DF1V=c9 za2pI|!y^~B*mwuWQ7~pwk18P!X)`{oa5A3;lg&?6qPNh#m(mfAGT@QI$qqdG@6wFX zCfH`U>E?fEf|HNjBq?4J*zP|Qkq-%DQ5(D4ZkS>&$)c9#36}DUO|wA?(|nu~@)q?2 zs%aeB04et#V`xXYp7~c*n>xB|N*q>cwxNV>{e~<|ag^^b?cvr_PRJQWdv~Dc33m0( z-eXkyF267Qg!&(NpK!OF%8tZQX&zEE)Dhms{bEixceW7SX7ms-l<@bXlt;4CPa7)k zK$aq|m7lFb?D5+ZpuwrXC*v@N=GNZgT2{zWChmCU9x|`87iRQCfl@l~7PXM<0B4Ed zjCm9MKrOQNA7cHV88_aJv;+H9@hl6$qH3d>VC;*J^@dJ68!~2plJnB{IFC=J^A$k? z^oucfEaEUD7W7K+PjoI>3fk)a^IPg;&!C?eT4Jl9;6oT!1{fmoZf{T-->6cM9sOPT6PFO z96ubHIRR_&!88Dw zS?%1-LFdi9jE{80_hhyCQhff}+~-~Kc~tq>v6j!nC%~tX&YdWCnw><$GfH`}_+&Kq zxk-FdoBLcYK5hBPxjo~>(HPq)o}A~IB{;YzEt9eSne;41vEfXiBPrJbwZ7c}k`zEK zmj;0OS3bP&inM2=eWL8_teylYe{uoAk0@Qq`iPtnek>`_Z|{+x)5c3-_bnBAR`AMi z1gXCnQ$T4eJEiLug(!3<(-KyG7U z{@NnhuYqOz7jnc;5`oP7#u@*TWy1r726vx+=WXkSH0lc33+agi0KzbXiL1BwqQKk2 z)I#E$Tf{BrXQtAj?$hs<28q+higP0X!Qsy!HltPoQmue#0O2ZpZ{I1t$JDBwxCj8% z#qcWxT>7>Id~O9y1R$41{Dki&FlC(tzGDR@0T6g(Eep3i0xRL`C0xl~^~59q39li1 zf)(Cnw}h8j@jC*LNpp}DHg!X<82^owZ3+(Y?`rwy*5N-9|3Ns!KgsfcWi$SR%>$gM zlJaZs0G$Qat2oT}EKkP{JW;?-Ou=Ew6U<=FkjgE4Q2;rwQ%l83T$N&@J3JyS-_%p$ z72KrfHW=7=x4U9!%hv)_oq>#n;+}djTUwv8WU>5Fy!+xEwp5X}8n2up%)o5?-N7mB zXJyy-p`vW_TU!+%W)8M-I>`1LR7Reo$5gf1zGeo*za4FDw%?L4EXK$SbnF*6QymKj zT1UJp)qEkxOS~#z7+By4XP<;upzzpQ=#K7}D8gax#~3SZ!c~&LkYkYC^#2gGHk4xV zF~00(mG&0^v-@LG{{M%wF9DCLSlXVD1i~_$APfWq40{kn5L7Ur8A#v^OaK)SS5Opj z#U)`;Rwq%$!${oqx}n#rC@ShzfvA|UB@iHNLKJ0Jx)~5qBw?NZee0Y_LiFDIJwMMw z=5%*;b@f(VU0q%6#9YBZg9P!k*$v;I82*|f@;cBr46FAY$fJbZTSp)jQ_`*aSdPyu z#&T@A`;F-gaj;1B>to;0ss9$BbATp%%&Jc%R0Xn7zugx4?QB>DZHQc-0CB3dT2zR+ zhNi&bxo0wvgxfQ7&{h<`mSAh4QG6K=0u!m3?s5a@3F7HsQ0G>KcuY;U zaZAD3K4cn-OnhpkF-gMS;mI3uZGjB-pgt^wS53dV0Kus8{Ie_fPQ|zmpt_!5F4`s< zImsVkNX`R{YAUfu8Jqio;Pu>%JYtB4F6QijQlF61@CK)V?L$Zw5_c;$f_XWK-5`0R z-H&awgt5KDnByqfgK+*jInr%byEQ!g?YPci4Tp9O9SchlY_)A2z~1VjK{(mD>;jX0B~ z3kL{*q^Z8(sG>O@Vdy*4;SVO+&TeN-4-Gx1zNF{JzymI^C5__XqaU4Rq+;J0MHFs! zJ`!Y)s7aEY_eQQEJFeuEx;uk53&od?!yi@no^3tw%_3ZH3rB%;7*^hLmal;LINdW zXyZ!NA2Z$P={r7Wx_j-l(v^=N0{KKDMTJBQKsV^je$YyL^k@#Gw7K zA>wep5KUf=0){h~d5v&j53DUnNBiNc4vWDEJ|S6At%)WXywLd@ueK@l{te z8aNM*jGYY|_CF!_UAUE`lE6PXb+#?KZnMe*mi zPdyf1**+onJx`;iE5XqCZi(HFd3>uOPoDwgI`#d#TrhTjfm|VXT>K@_li}rI)FbO= zOh5JOaW>t|wL}y5*OcDvXM_tkY@6 z%SE`NqU#_M@0Mf@;-8Lz2nKs5;b42bBo9qqsFKDP?uIE_{etm9ys5anR=BpE0+2$L zSS`^PySZB0_zo`I|B+ls&)^dhAgjbWE@$ z9u#VSg*SGcIj#_XAf~l5XXEOAC& z3Y+dTAi*4WeX=jMS=yXOa9Jj8&b@8WyluUBTyKWQ3;vTf=Q2b>yT?l4M%WRdy+1Ny zRJ!Ab%B0-+1cvI;4B@X8#A(eQjZK5hsWOIfsmuy8NI#q43wi`117c=j8>@$zDv%?xCZE%=ZC_9flgz9iqq{ zKhEbca#LVrWPFv-A1~Xxx~zpVI8uN!#={VTa`ya+QBqv&;f z2TsKrIrYAV`2uVWpg~#tAtXVbiTN!Yzqm`VB8wF!7e2MBv2B6(BQk=VGW?*W-yeg; z^0I%irLP8}>NU?|m=(o(5$z!eVAL(@tL12F?GU+Nout-uvyEPnL)~*VI2PXF?$HU= zFI6Wt6Du{uSR8Nus7H_6TgM1(;I)Ft2Bb&^8@U`Fpudq@?D1SAM|Q` z`>jVzt?&UaShce2;$oel6PD4i$j~nQW~3g-YVV~mv0gRKb;BqeEl$py4JmriIUNre znwyOETBYfI=C+@O89!qZ#qWXq(?PsyT8Q+88oVhlF8F!Tp@{q0aaT8V>3lowwi;<~ zwM5#RNb_15$;jKfUH@d{bfB1h0p0*s#g{|we@xw4tD!6WC=1NspH94z*!*uw%=7|o zh*`9POgx+ch??atz6cPV|9heJzi`7!O{v(1=!!D75LQX|_cNS%a7aE@=!4RQu=lI3 zjSqBmE#XS67qTN@U}xlXf$xibDp`kjHif57~%A$~LeD3tbCN;_i(! zOsqbD%%qRsS&5uP*b8A)C4G%+Pe6`-uRcZO#`w)>M=YDztPD$5H{aq0;H3a8BVgr% zj7!`(mjUp^faF<5?tRiMCF=HnID?h1P3n;x!*ns*6<%fG0UAMZtD0dI`mD`x!g_CC z>WH=@UVV2BKiA=t&)34n!pQx)5*{&jhG$z4>OE#?(VCyH;nPh0!3aEqkM!ONa2>@M zT&snZ#t}V50>zRrNkCUjKBDiy7cG{W;ROoyVQ)0E9GJ7|z$-(ZYv7q2?YCf%)3)zl zObPN~gE}&gJ<~1Pc+pKeW#}|N&V{_?vuWaie@WR_I5@iiCwl>Shez=a172aO zXxOOC4epjeLUFawCBJSTz(LgKK%jmBf1*lAcnCnJ5+vmQtp}EzH-^!l`Q3$8@-EAdT)=Dv09*)_!TKOO}aPyUYIo@mE(a2@N5#fJ)E423(G0gUe&bmT9D6Jk`i{2o-dUM(>a&`nU` zh^H?JPtp@4a47Y;9P@yUX%wFPQOEk)TA#6-?st5&IomWgwHwxRW@B%n?shq+9feqn02?uvU1hclH{(IMufR zeo4gOz3XAUEJ5Bz*I|E)m)k0QWt1 zd2KI6XCF@GjKipWDg1QAGwg>(Fx#u2eON8M0`XW5=UvS_HHHfY>-X6*SU2EDrvqeN zAcD)!+wi4!zHlmH9c9~C2h9(r=mnL`IV|I_O)k zJ{Pj5Hj=bkFo%NhfsweJSaRAcR7}T8z#SYQ?Kb$5HZI)`Izeyhn(UEy70Jk5jg}8& zHoJnW3%S(R=TAX2*v+PR8)3bcC1Fz$@;m~M zPA0s0usT%FjbB8CSDDDsA0dv~v&yRrG1;xnn4WZgOLZFBazcNpcnr(c0$rkB$BYkV zBoeUN@Ja8Jje#+a#O#7&EaK0leQ!GbaD+U&y2@IY27Ky5)@Z(9bMG1~oyC1)a=8KM z6Jq5X@eJLJ`c>4%x&)NiY+i8^vmed_2$FSA_+GsKw4F73L23q8QRMR2DB~J|S!_9h zYeS`0CTzCT;R;=yUVv(20Doh~z&>#daPkIdRHrnI;gIL)E<)sMUJ!XTSS5vRX(XLx~1 zoq3hm?v#@8Mh1YPrbEbAy+@Oc+!qm-zY0SWWR#JN=g-K^=EagTI{ou>d+gxE9;FvQ zFcIMZn_rb20+$pK25*axA+7Rm$%N5n<+~+vizzU6tV@rOd{8`=s=dyu7S1Cn>5@{_ z@+?bzbs3wgGd|@_G9GoRdLS}SrwDk7kVX37RY*8+lEgb4xIO}GY^1BL5_iK;wL@=ajA z$_%HR3@Ny0h-V?(qkzsvU;+Uc=sBUpir>==PXZo}q$OjY_(4ZkA2WGIQxN#bP2htc zOcxPu6zo2b1gQZJ3K2VHyvfL{7WuE|24k@JO!6kyjMhuVu=@Q2ne5q5%9-H??IO;Q zrxS6F8qVid;q?&m7{VM51MH~ijf|9G_0Y@xkcWg{j$ie*jSz0OiAh{ux{vk4jJ*FM zif|TU`2_rli%;?3G7Xxr*d3JO^!OSloUC4kog5@5J#DpA zy&?`nXW>g6I$-;2q{96a@S++^I-^?cE*GuDy+~13f~{2F%E0R1z;qe| zy2n6)zThoD|Jh5R4-pUK9*ThdrJ%;e#9SpfG+zT03om7%&G6}1kmc!yjDH^S7+?+7 zG6AxGf2!V&Qs%=u$^>{sGHQJCg25D8x_75M*ISV^Xqus-f>RM%!#F-zOlqDJdC)zD z3j*&8P~_{aR_&DBQ>52XCwF#Rtl~F`*M42g5f}r%4~@IHCR}ENGGw z>MK1y0inQSiFEO3Sg%G)nk-s_EQz@F4Qi%(FAsP%DV-Q%hmn2;zBuVG02b?_6{NZw1 z6w?h(ES7}mWd!j;O&qCCT9%|iGINFJlg5txBTA2s(m-CM%a*=GwLfL|6{GUUAcx)t zB$cl^#M{Za-yl-ABFtFAe2$>cGAHoN`!-VMw+4^RM4+E9u$0oJi(5F4(FdFd+llY4 z1Y3qeh?~NCD)U{NN%s{dU845XqY(2cYaW=I;>v<2GFcH{?FifN`WP)-9=G~M8oH}D zrrLxHZI#w^W{Jdm?-iN+D*V8+RwTZM9lqEOi|Ft$Mt;?@l&5cJIOLv(%P6Wp7G>P@ zXNWC2UN+7Bk!7-{(FvE0ZwV}SCR4tqZT;NFe z(e%UGh%>y%C^Jt#C2-KGR@?rYff?X7*iwsiToRtja;=&0eT-+HeR^`p@2JeLe*utd~*y8<)@uPo{LeJmd*VI7-&RzsVMa%si z1Q-;YhMA)7>&7wRPDgvlyOiGH@Nfl1#AshI4!7vNV|~FoX5jYW*tFlyleF8%f~L(` z7y57!G&|lGY=#?fxVOr>M(?afRt3%`8_$q`Ver*LVZ43&dl3o>x$C1)h%czPTgo4T zB^urSchpBf$4-5}poywc^7M@o-hzcnbs9+>|0FH~m2VW;gJ-hDMdcr8PY_;;JsS4! zzuI$v9p8gcd^>V&co}!+Z(WX|@)!mJSw!y*7!^HINVKP$?uvdXRaY!wX6}>dC%{ao z)CVPIcNINyUDLun5uQl{-4vih=C>R3%zU-#lO*EczV%e(()@H95@@gd)9r3iiTqV( zmjz#N(^$J=?uEL;1MJ_c?6RJv#P%dHhvHv^G62Qq7vU|mZ$WULUWf!(jN5$T_Ue2B zZc`jSaRs{SKrfq5yo@!}5hTDTI?P81U3QJF2_}QPqAw-1tIT;a*bDSYJVSY%br2C^Eb1#hUq;RKG4(?hE8%qP&c zr#L`2NKx)LqFBBVEK4M|N?Q9IVTV!v(Lrk8w08LaO;VR9J~w|598fi$Qpsi(_C4t`J~Jm z)tUnZ0~2fAMvT?S^=WYKf$UiM$++utRNy`kb1y<}G#^C{Tn2{YP5DSRa(mZR>Kn< zMv>O_7|H2(lbpi1o7-qNw<8-YQWqdA+#NCPJY~G)K6;guUl-U2_$LJGJe>qUjO}7I zG(mr#uGpw-9#-?K3pok7>V(3qhyLM$-kS%(~9$iJD1 zTt@je=yQk>be4OfgJ&Y~l=R%JJ24aVoqgrkJ50r_~zEq z77M$hdp>C_1K^~PHZ{qWy~F9lp8*v90q0&{i}a8UeQ$~LUav9deIUb%JViQhm;_4I zt_)gg4n#;UU`W~TPXR4h#A`A%=)O-&OI6L7>xqT~>AtP}D2g@dRCqSJ9D-|PmBl1Yb zsxt8W7$VpGZX^y#G;TP7i@+OB)OgY)+1Ri7 zc~G{34mjQSeB8mclp)kEO6*mmjd-1S|+FU~anFeU<3x7Bk0__0>m z7vlZ_3wrG|3;KA4UC^XB>s+{2Pm+L>R1)@B)9faMdsN_Z9k|K0_$VaFSpk)Ib0Gt2 z)EruKg0xRQg4N``_-5P-Yyj%+&pV`e2C*VH)ObnpQO1WZxn&aAXzD5>_Z>e z68{omB5-!n>d-)3lPZ(8aTgzl9Qyc^TrPe>%sR7thjg*tk4%tC$RjQm(e!Vgw6y-N! z`DIVC{67I$z0d&+hun1t@s&W_X2*CK^RC3)ftXA_xfY5q{h)&@qtD&kc)yEJ*?2=) zOW7LyFIlyN@-w%|A9Rsrs1`i-t4rFkf)@#`gSz{z3BAKm z|H@aIbx>b|1pBDC9lipmW3!sfs2eyPZ#?5Au8`-FMo<;>Ty`@CqwXdkFf*s#GwN3F0CA6UfpP_+1{ZAC=WEyS{?iQ^zDyDZ4B-S{FU%U<9>w-Q1Fj|Zlv z#TXe!^(rKxjFv3JJ>wIh=QG5G|GDfAX8jkD+|IAp@Ks$b`zON8)y$!6Gt+V23W9{K zEStex-!K+4*vKuymR&CqtwMAj<5fQ-Q`)}0o3!I{I4a!4Xv2aBH|< z?b-(}E}KEu4wK8w#OZBgZT6o*MAA}T@?iRIEyn#%4+pa+h3#ulVCP}zz{klNH156n$URVWYr+5Rq zle3yWy}W(ei83=Zz%(yhgWHbEj4kBTfdk}q*te1Gf5G96*vF#S3k9Co;kMI|;htBEj|Bbf4mHz1&?T;evOvIj9d(&|J)I9N{d0_#p z8PO8O@=mZxybqtznGW9n0%)awR-ro(uIdeIxG%*5gEz;!skXZzw2RvFS`4lXYfy5} z!(MA+;lWygy><9(ZYS@Ff@HWsdb)tU;tLHruU9ZnOyjG#l<;uAlKX#vT^u(d-2Q)} zwBi<|7QwIz7e%LFhWb(u;VD=!K!2BCOil{^n>j4hq?bQ+<0BB;-NQP`j3}rJ=CuW! zv4*|+N+-vs@u zH?T*5R)A)!*fCYDYZVEOa3TgRE)6EyD2?>O)a8@f!$E|NwgpCMOLzgX5jVhBC1zh} zaEv+xp90R}nsX!S12$?E7wTGpJ$0z;8cwZThXu)5O=LDW{U0(-Gq#jtV3@gt%C2Bc z*!Mqy#sjL||Ad+o1EGul6p}NoA~7`M#=YNV*ka=_x`Pj*2n=K4RT=v(5hY4hvXhuV z8M7%?VteX8P3HBuFs~@%!9F1moj{&szvkzDy@PbwpE!0@$*s5;Tn+#q+&#Rxj+{eL z?8u?81fwiCeNfcP+h!?Q*Vt+!(sz%%vpeOIN_*JoLK=OXH!22OAGMzaWLgWEHPt;e zjlanu!Stfa6Oo~MqnC))$nC~2Tfnxj=CE4TC1&B_2?8Z3^hs$A_xtUo(k@oIOG{Sz z9LcfV&)5kEa4@MZkc7Hyu4;_?O#y^!?^1O;9)Pu-gk((!OvgsnBzx|JNxtAIJl6;g zeIdRB#c7BwG%8`UY(7m4Jul-q%arSU)ZyT^3>Oa?^V@62Z&FmW>mY_8oSC~n3vN77 z{yKGS33F#{rZR>xrD`9Z*9E={!pr`OktI}#9yBO{-m7NwLTW5ysj_Bms8Rkhgt_kB z)6QP^V8fvf<87uq-4u-k&&^FX`cgLBPydj3b*ZkDW326P`H5UD-zrwcRA}UQXxQ*qvni=U`M)3PZVhc{>ribKpBb$Hb=Bi!w3B% zY*U_xX}~rFFzTQ@EuKd3Q2g7ouyyL=O@QaQP<;C*?0}Iw9I3uw0$v?(Kcz4vu6m3c zh#V=R>PY-DNG;Wk6R!P{VRtJK3;}Es%!bt4Nv!QuNvO)GYlP!=oR6qkjj+E)_#K4V zu2yF$X#`)Zw*6PF--+4D!4fKmPelsMJN3AanhbrE)JAS)YA^C)()!Z1EttS+UGm>H~?oQ&!|M5 zBaohFf9{5N{n)J+p>H~EhKK!bcY>T?{A8q1%SP5-B)Q0*C#3L+POLgn%Ep2+oZ$~= zG}gM2@`l;+$_Md|p=F677Z`Bfih7`)@)A)(xBz;dMpBAkP9loy{wL=1n(#RXeMcei zFHPwA{HJa%YhZi4%>o+v>=0k6vP#7CVe_x{Y1Bb94NlupIlR%l*N)p}$0ahZn^VSe zi7Qd3j-SF1{76FZPWYO9+?)76-;&J%9_Jms9T=}{m5Gvb$C`-v6jC8RG9di0s;**JgHYo^$|O z2qB{|obWQX0R*~2u>2p2+anA~itFuQTPJzXD=xm*pExOjnirZ=_d`E}E1e!IQ>LXI zZ{)m;OzCo5#sPFW4s-JK%1ol(-f|9dGj+VR5JFlk($q3UI_jlG_eXmRs1oEHJ&&lqvo%Vi>)19F z5Dab+K|^llt?ev=!L|O*SDz;ZV8+5sV!PV;v!q`vQ&_BHcSuWbSF_GB#R!%lOmRLc z$65#RcZG(7}m%J#lGOM z1l!M3*p-(0GRS?NwC6Wo*O?Vtil9ACt`^+^jmjSXi)RZ1l(A7z>rC zj2Z~+4yji;6gzED~P7GX2cKLNk}u^I=yvo+wj zY+kAc%A2iI;No}C6mtFCld?qM%)A@5-$x}hgeK-6jiG*YZB||NiYP=>l{tL=U=BST4A$6b_#w%$EBI zztAa;PjS4fQ!;^#T&bG$E9>`{n|8cdH%D$GggoV09iei8vs{1b_!L+!vxtyq4`R(e zsc`p*Fu~`&gAY7Oos7hlOymNk|1FUZ{-xY=zx=0ir+9%NP*vuGDDz^L*(Wu-r4-c1 zDM(Ldv=sBTM1e+Kfqp{2B}tMy+)SqRnfqXT`UJ!bLQesH<9?V`_1`OPKBnghJ!Kc< zuY32&S?-+g5#W2nX~v61`auM$n^@%`96h^$5_*?XV=9j?jNB&#x@s5kh=kp9Z8F{f z87jq~;Po&Pc>gh$)9InzC?j+)Zt`d^$J&cbJTa@!tTf~K)tV)msi%yE z{lAUWH33MsV7S2f81Y{Xu1;pw*rP&tC}PkqGRBfBX^@RXBwyHwvJqGM_U zTDhJ;8u!E=3>oNg0^Gd|g+yg%a_4`zmQjWjwfFo>qSuaBWXwfOF{k<`_&<|S2+@Jx`? z0(LzGyyJTpVtHDq*VW=Nulo&;jHZ{CfQ;MSZ1Kr^(Bgq*mB(Kjl+S*6bQ3khNf~Z7& zx7%*q^Y888vStfxZaNYu5`SbMGKE?x{OHDr$_1uYr=Fuz4$l_;80kOia<;7HjK>sJ6mwiDUKs|xxf305h4-$R&pgI+gs76Ca3JqT-^aGStMyhgLo zj!AIg(9yv2G`a8C5f>o>RY++l8(k*ZS&i!R@|S3h4;2QSO%7X`ojed5@BKlfR45fkxjTVUH=cUMj1Iji_q zheV92W_MkB1MIFF&Z6D*0ze15>)VJdaMvpski7r#6odBroO${&1mHEGfG1yRP%T6@ z(&nm_+7n+9$q$fih1}O(jX~EE_HdX(YZWu!(jLq53+_is zeM)8YY>D2Wmcp3`@pcU-tu~rGrgl8`9XbZEL*o;mTvR#RDruZ}mC!f=DU~#iAv|bY?a&B+t*~#ZL1XQ6f$^Ym zsL;3uHkx{`J^H4{gT`0x<;dx%*+K6681tmW+`t%cxnAS!+kY)^&eZoDs0w*h%$WYG;}YO;I0jG09@ghrtd(KvSZ10x9ibpD zGe-L;Yq3t1LZj-!JpCZUfehEVz+I?8W^#-kBM?w`wo zh`T2Y3Cp#;PdqMRynlFybNTOekgKPXX5bncjeU}_58w|(1-XaY(01;J8GLmjPdRZ# zvELu8?k$qly~GD^pBv$;36)cmc@+Q**~QN06IH*Rp;pq}GXpI~d!51f&_5uOT8PVm z5Ip21xL;PEVUeRGBpqS7Ti8keX3|SeQhih%o$%Vf;gpcxCpXD7Td$tGy{d=)aYlM* z-+j_U({4a%*CU&{q83R$BaMd+xRY@Wr?I`_?>AZw$MJ4ld67sot(CBo}`fmI2*IjIS`yYW)Q<(W3q??ZMo8wqNQv$1=MP>`dm z7BW~6ATHgCzY~67#I?!>IoFhhtpe-Wh%_``D&*A}%-i`=Be%aGiK?FS^kod!(3s-d z>wxnM%Ib+iBJi1F7gCA;_%#mx)_;SBC@?BqU?7L0Lx9o0>R?5YJU5neF8Je=V&apFR9P8HsnGXHu&RgdLRfu6vl;F#o<=CT*b09+Atu<5G84|@ zS%NDH5zIr!B&2M6?_qLeX+!iS-#N=Q2e5t!Eq=#>ja9 z;S4M1qgM)hpf$H(wfBmqS30NIM`M}?nWZx>QF-x!7N?tAJnV%44}dV5F%CkWF>y4d z8iGAp&Y_COS^$~5WrLbMbiom^$7)GLsk@M?`O_3|;(rf{fU{iBManu=daFH!Tk3sM zWQqFLiK(Y|AVv-SR#w(Vhe5+{Fy z`AmHQKJo?1jzUI8d3l>UXCbCBzHo`pFL5|Ud%z2=Dj(-KiQCp!Aa-ylZnl|PY~*xC z!0fUq-GW5ipk4-VS3iX542@YF(%}m^p*r+wv;~|7)C0JHW<){Z=!D?=^bdfjM7~bI zzp4ap8U@FT41nIR7Xm;?n<#(#*aW_4 zfb}tu1J4HAdFWXHH4+kk(N|Q5?;J&Md_~yoNdjlncR<%iDrw53%~X9qX)3S$1DI`HB*y^rq^NE2EHTIu_E%1{Hb^==YEsSQ8ON2U~SOF?;}JArk9V zCRU#eXsSonQGaZ$P1Q%vNpy%cy^fK8px&cR0@F{svKr#d%Jag@R7?HD?zFPu_7s#y zJeNvj5hFt*%hl-QI)dUWfhvu745Sn1zYsxGcm@UKa;wyxz8|nCq|AaZkbL~XT-(5V zIJ8TnscFRX4`h}z^PKT^0VugxbuF{WyiUrS(Wg=FxaB>Xxn)+`37M3Y+)FXVji z2O__ryhN$54Di@sd6#0KaHLGF0te#=I`!wOKJlj(OzHyDhpCNC`bX!#S%@=o?h|6&i)=!QQBnN} zx{+^&;Yd~cNxO=#kkR}s0{Q!Gr+71tg5*AhY^jQ)7!-TU1>`W%$r1cs#ESIdIHB8& z@H#c_Ms6_fJBDvO?h)@FSK%u>5buvY>5J6SU;d6PmA86L75mUaC!+1UckBmNxN%)iAjDWQoPvg{$ ztU_C1N|c-9)~n$n7EwoojXXe%MQ6>BnZ)PR@z5!4GhdaA*ulhgK+{}P_*?6s_YAym zhxJUPc&!ak(g0~ep>B=M9FQL6E}}xDFB|U-fHQ*+K^JT$Q7xD=kSL+PjiNjvC?i1G zm7utsBJ{ALcry_vQmgTXhTllvt%o5>#g$T)HgZNF0GmflEpKEi=Kg}qF)`@Bpdbs% zfy4TGA`^$3lw2U*KzPA(s@87ZBASA8k7x=I+zkY@B)GCV*6V6uJ&W!Wtmo(LB4FDAGd?Z*E596m6NY1#n8gO*V@r;XtX01g0E zxd%>PtP0d6JSr2d+!E$&iP$n{0RV46eXq7v0bDNlL-CW}Zv5M@cZYQ*vZ;9^xz9bSzeE7j*axfifAbSNB6y7D7y6%? zA_~rH5q37^zw@(lp9i;Vy5!<8JWUc>L|CujG)bb2)Bm_u@RWcfMz%I4@G{{ zn!ek#ZlyPqIiHdJTbXHQ>;|<{v_E*VFqn}hwRuGnacZ?e{mQBbGel)P1K0h)GKRyh zJOjOynFeN06BkHxg-I&zW;rl|*fLTQAw&Q;?gCh2C&D3HW*0n;XomX7G805YFSO;M z2D4Sz&upyB7B$r_Y&VF=z7&yVqAtR5i`-&@xP}%1$)W^2PO-&K&ONlp!(#i7+5HX(pRD*)CE6eK}FHiM{6sKFdW??z)E zWwrbv$PESS*`k@dg~s}oG_vw&E~^^kOEzT9+Kfbl|wfW~fMJTDG@9<@V@n%4tW z@%il#xJ&VY6e}aeOwGVfkoy=ZG>90Cf*M=@znIooBU5nRiRSGYQMI{12JzS`iFP=1 z)TBj9U|fAPZUW>kzMyILxwX5IlO^V9w<4Q#Hd_3=} zG5`7YcaSxo6NwCq`3j0~n61V9wcH)f;*ccd+4egY{10$pLYtTzKI>0v(4IMs>STr{ zC;0+JEi*&CmU*p-XH-$9m~Z6%j8W;e;@W58Vn&?xJ&kCMMc-$3DK%pcn=msA6k;yu zTGnz|#m&Nltus^4d4tG6;9Z%X78oM;Efp`hvzQ z!Rr(CABa$Ds5o*wj&H0bWm@)uq318X#8kmH%>HI3vlkk(fV``o99Z-ga z6LNQ0Nqe+|^oB~5Q>l&8a`z$w->VGvPYm9aq;Dpg6}dYg92QkdoTX|f zPV=HhR=ojYEGj35b29RRPFrRy$qc2%&ECTSR2XjU4Vq_icVuhRTCQuen81ug7cH)~ zsSnp+W;;e(igo8oQ2qm6`AO7e62=+b2DPJ@3fYZ%l|*e*B~G}p@Q4+D3oH)r^Bki* za6n+(ubh<0=sSYJ)AAUk?|AigCRzM;y@fPH;;-le!6OuZDSq@+W|GC?s4U>lUD$oH zdWYPB0${n~I&J`-$BOK;n!rR0LL6k*O*mhpjO^^+rrKiLj}<9+H*yEAf$-c2ykX5o z3|NTR7pXCKp{QW|5=Pi(I`!3+`n?s`FVXGV=Pouj=~z*O0p8`utveWZKu~U$!N&;_?(;pU-6o zN2E0N_VfDuk{@wkP!h4l%xWT4tWa9DHH{YnD3|#prAisxN5bxTC;+@>>?j=IbveTJ zOhy8B&R$GeC@GeV8fpI{-ze9W8%$Up|7aG%r%>#VJo|l$=laejHgu9UIa}96eDhTSE^z<;jeDZ-VZ*M!uX72QPAS$ zDiD;Bh~Gr?Xz?m?GR(U{Nf;IR3;`0puW;RM1_4v>G!>@knygqerU!)N6f=l$>^3uX z%e37{uc-7zoo0r{VBs5pHOqcZh^{x>Mc-oVJ~j+Pzs;j4(EWY}+^q(NB%U&ZB8p(E zm|((pU+_k(+eO-gMpKgqbEwzj=l%E$-(=EsxXKK98s-J=GDO{Vz_!L`3@y-iaqe`! z(#ZW2E3sBwjyw0{b=9b)Mz~S_Q2VCn2M0mb7oUkX_#K&LQQMxjY|DF_(~4b z%*^^Ns6(@eeNsfMbo2&%(_~%v;+#ViwV@JPA`m6&&_Mg#Eq4baY6u5Bc-V*xwzhef zWWjSRKjMS8ka*|9vmkA0cMK%~F)|7vFecd-Z=hb){|4lL1+rrFJV9Gkjoww<=ky`j z_1tnC%`s*>&ZQnR12bX7eT=7uzw`2ky0htx!)Q!e@x8lH55 z-+GcY#6tmB=yw4n904bm>($&4c>GcQjznVIhCKaWlY;;F1Cty%_u*mPo)Najj2gsF zk#Njx8?;P#M+%_R%xF*eiim*j~VZ7YoG2 zxzzH37e!X`3FXYxU#9KX27xTkxst9feXI2SQGFZZuQBw~YRBV(p@M9(2&c~t&=DI)5igVF~J(Rl(u>xFp&;H*VYNVJ>@&yx7)F(cXuVYH8# z`X?y!8ZWHWcU8}6m&o1e>k?hX{^ugB_U^~(cn3TD{&Mzmf%Li3MFKowxIbhQ1~+n} zMIfIt7Pa#Srwqsc(fE%bd{)sRig>AlMFQ=LpdnW6Xum-JRH7fV+*^*xoNO?H4ii_a zZ?=l=_Fm3^?6*$R{35HhpqBv*8x~U!<_GQyYA-%GpW6oZCTAt$vR7@S!g5hYl8hp z2rEIKWeXGYg@6Q?#EFxGxeXS0L5yTti3(yu7>mtX`Y7`KCjiTg6BcC8_&56iF=jk$ zJs@toufGn=@be)&)mRQ3>cC#|#l`&mNj@nL3=PE{^QZo9gf2l-`|x77-4#AOQJ(ty zwBK}7L`%B+|FbIwhgxRystdZq7rWC8wJh`DTIF$2aei+sL=4`SNwP~e=H?@;Utv?R z&D_y8i*wp68I1Ekv{{1Qi@g6S9X+uE$##p~-}}54>vJtyY}R157-zitat~YVJ$y!) z=B|BUng>4w)5KPyM5VA%goBV9s9b@!(5&m!RQawYtu|#WFXIpAti`(_m{${qV{UO$ zVd>$VqJ%V-Q;w4ix2XPpf-Qd>rNP7jki^2NmW<}W_M#1&M zAS=2fhrq+2-z@^$1lS`e)|a|A%4@dhm8BjuUJ;8D!Ib$R?s+x3Sy&{ou$)PtZ@7Hvs zMqh!+T((|efq!B__oXh6l6IIaCZz4d*LkE(1Fh9a8;u}HOT&*^h~q5U_jcDk5OkDT zQNk`o6j#Ob$c>V8J~8bjx4(UgzKV1d6~KX7M9)I(y68B_*^O~9?|qK1VW{yswdkJ--emK7?PhX#T9w9s*9lCtuj;^j?{7r~9Uoov- ztM%7N!AlA9A`b4~!88aFDi@f0p74H4p*D0|oOZ!tI5YT2vVKq`_<@PK5n{}KwiGPa z5_Aj1oQJ6{K|-Ut`vTL}!^;~+i~Y_{`g&{vu+Gb2c9Ji3X!5k5^q(l!ETV^Lh^doc zn^)jV9hf}rkbWi}Xd#V!^-cwrn-MU!&P5DH-j^3q8~%O7vko75`WGTdE&NUz!5Df@ zS1`hA`G@WeI+XDT&L1EX^-w2AIwmYnuq<@lLy*yMO2JWlt)RBW8rbjZ9;^b!3&k94 zI`HO`M3kzB7H~SAuM6X>$r>0QS|#8|v+6&Dmgr2YjQ*9;e}jc)Q&C_ZBuZmj?uA<9 zg(j`Rgm1tU4DYLc>F^05P40qx$o)Ho|9>D3x`wMrnvq*75K+W=`a20%Z5`i`a8!Mo zr(c$EsS04s)no}G*crLEVSqRzTo2>7ZKlWT7SZSweCK~&m;LH4a^FVz>64 zKlPVNp=P|iFdM~L2yKE7=DiVfl@^*9yrE<%|tz`0fD@byfd4b*27~VnFOyLj{lGf zGG-!WG`=AetVM9L&+4Bns#6+f;w-`%Iaw@jGXYqk-hPxkI{R+wpy#{;yt+v{QqAqf zbh{W^SM(4AGHE7CbX6;jkrZwpZj+R%?ZZ%n)ezkN38Muzs5cH!OIM*!F}jyr3aZdk zP$?+ee2>G)Q5}944N4@>(=8YXxl`aZTkW`-ZF4bV^h`zr*={i@#OAZ3E|I7zf_5Ps zT_SFW2Q_v7+kc&|tn}>n7NDfau85eVzH=ckb1Fec5=9pNN$rFAZJt)G&(NZx7(Z$g zV(|S9zMWp^gkBg;`EV+FKzf2bFc!xU6VU~`oaV=wq?cPDMDLQ#GPXfw>Y_)a2PQ)} z!-?AVsbhiqcA}O&V1Fs3Y7dw>8ER|YRnp19x=4DITws=TkEF8?n@G9{cgz?s!3@yb zTc2q~`k|Nll@+`iDeA4>)PR=h?+6x&-#QJQGL+v%1ME%_!b0xn7ot@M_G70!jAXqU zf1)jZqzq}N-U3I1l|oOvRLC+eqs4$oy>7(Ruh1Pmh8MrJrdlyGaPa0`(#L#s6JpW;QwlVrC*lN~qNGjK=W)mAQQw}oOYR4>j!VP*CE-%?Y6J4#MYujHISu1<8 zo|{NQJsp@S;YTc|Kj2Q*PIz&^$mxPK{Iti9nsNno9wTQ$`o=Vxtot&b<<4O7IN#ci z>}$ZW91z_K$VwVXLAJ(L%+)Ys@}Y8s53o(b zon(~e{LGO7>#*g|qUp#}gBcS=eptzbqKxhM;qR^_0oW`4JGLK4bnx`*ixHH~@I7<*(fQuaj>Uy_6 zSeffr=~iKC;>4TDv-d?Je?)?>l4I+>0#GCJWr=)s0@qX=Ox=L)nG9fzgMK$Rg83mD z+N3ol<9PNL8abKk^33NbS>YA{+n&cucrt1RwC{jUEzMe^X0C?cNEo7^#_$!5GT)X( z16Gjwa+ZjOG;(`M+2>WKjYMH(4SD9?Wk33aIkIObHJ}5N)NVY6s~?Bf-1Z{uDFzJE z3z4o?GHndf)OZX^_?3`3Qlbvwf|4T?;5IAptAUb!r=*KKfD!gzR-(y&U5OwJ*b2Ea z_2PX|Szw1TClNUHi%nTUt|LdJHqNx$%Yg9bJrZ5Txi?7)7p9Gp5?z?`bb*B3ZBRe7 z$cH;HG5>`-5<07b9KJ*)%Ec^L9_Cz!7(Gp@RF!=m!qF8bga<{`E3aZ!;~^T!yoDFo zxV+@RFDM+{!%3LF2(&{^=(~oMI!ZqLNh6Lq_nSWp3B%}qqb*3l$=~}u&T>`oTE}z{ zKn^Q@z-GnW0Izx!;0nO>iMm~5JU-s9mb(MqeaUHX0TvbPf#UER=(lQNS3U+)4g~5w zQ>KuSs}Zty&hhUdUEQiqv842%`(*_6dIER0OXtE{h%ouqyP)k?yu5~{ns-%4Sw)UB zDKIk$MRY)UW}h2iBzhsgYEF3D-$@daf@4y20zRTmciko+zV#J*an2+J58-5C?uwB1 z;1AdB%Ot5vdBVi1>56+)2=guLMq&b-nl~SF3Wm%rS>&?}=#}`c4#7!dg8@ z3l2}v@8UycuOq`-4>62l<7v51juT8;B=<+88Y$@?Q%nmvRvMufY^x0D4ZEw)?xcbV z+E5%ykO0_HieE9Tw9uJ|Hqpt3<5}F#Tml%;R;icAgHdo7G#tqF!pdFHr9z9t`Pwod zyP!4_UB#dpA#B?PCh`kw9#7DyY;+;4-Y8+c7D=X3)vkKI+B1E+q>K0&;tMizi4-+5 z)vj?>HR8Pan;J0#t23f~8tY=J650^3E>{D$ZqR{5lZ&^K@}0T}ow9lvh^}(Pm8Tcnyo1Ra4+Wq#Pv4dApqv1!Qpr6O*A&DVj}(V^{#S(Yj3Xt=A1C zb(pDZ<0DW}E4v;%WVW2D;}Ps{wOp#t2%u@|-$1;z#WtK_2+u=l5KFmgf&R3Gm{oeMuBFa}ZD_gm15WnaPGS~eq990+#S>dtE% z3F1O^uW?djT_9-xU4=IMK5`F7?kaTJ zB-^pvgOM4d<23EK8iEy*g1uKeU9=k2fStg2!eCFh^GPz6NdO8}~adx*SEFZ;3;TaRIL)4zU9n`vPOJ z50k~Q`+4adnLb07{Yt);1;cH*(AE5;@U*N4tM~7vPXA^tm;U{86Z*H}3x}UUgCFH* zc!gU36MWO@!09%4Q`E!mz&l^HJ5V?pv})0O;nh_H>Pv+(cOD8s&w0N??MJL(?T_eQ zz+KtmTj|vT=IKK)43^LCum{UhM5|X;P)Pva`~iEg9I8?bV6dz*W0ihZvPUb7N74}H zwS#{$KJ+kn++kzRO9FIEKZ9RH_^d-|#;dE$$a;w}L-#~{6!Z2%1vWr>(=+u11sU*Ce(~&v#N60s+}a8)@&ExGawZ?=lnk^nFNk zK934G*kBkRQE#$1QHP&`A{afG)=a#zLf@^%qHSjEc2#hex}M#7Ex`R&hr+kI%I%!G zzDQhq{UsuMZpPiX{%}EH2IK#UQ~-+x=2aF1&7R#-ZdEG%-(wQ{zliI_6cTVl^0%Zg z%2v}u*^0ceAsDK)%4=k-hRv2uRl0Q&k=b{shEv=wTsI%?wYFwjTcJXjaXt9%l|w@< zKL#e~58@X4Lk%YT0+E>Pc-%n^8~Ci1T^mm%$An{HCk-FG3D(9`pm?;oFLpg<^*x!f zD`0R9Kb+Hw!}0kufrkBm|L>@kW7SIci}1gjZWVY7RV_H~t%F8uut3;8yo+8;dy(r* zQggRI)bdJysMlgM)OYgWP_G9_)!QuG7Y3 z)gBOR@J_h?c>LTEjvFwiLEFsOpUv2F{@6cZ8|6>kH|rW6}X_--ND{ zf<|j3=ymqg^K6i&Z%D@T1Nb0T%?QP2%YAyir0nPU$ai+iL8PeCiyWzG64)-lv+;xT z6tI^({W+GBb*j(qx@aP}?3ZEd{v3$Z8_VtGD$S02(?&jTJc_*o$n$h3Nr-A+;Kp7y zCh-rvAw*|4mztEri2#PuXgd<~nad%@(GmQ@z68SMi=832_AwLa{TUla#M6&i@O6e&jasKjxWY%vXr=wLUw-r5Q z>rk^DFbUOlkxhNsnm%BR+%rHP8XjX~(5$iJBD%i!8`?AJ>ljs$fDpVtXBg@G1c>6v zBS0ZKkX*pYBY-|Rs*`0CN46qO3uSr~D`IU7>}`oV>)Cad5OcUe;8emAV)Yv7aNLMT z1a$`BaK!?K_ucg)_$L1Y-Qc&cq84gD_*u9GRs@>(4YTXzLb~|>LDkT+U{6`iZJW0X ze0Y_U2mjY~=XvjZQu!CXBnAZ~YO#LQw@8r_Onn1B?5Jt@!Z|7gA#8f|q{{ep0y@gn zMe^|nuI=I?ukp+Q1pU^#V&9Ny^*V!HQP!m<95S;txRYrcyoHW5*YLa>mNv<>I`@kS zgF_-F23(h(4+?W!2ei%kps+{trADT`s3)Ra=e!r2z-WE-1fkCT$69H`zLdq^!syP^ zxg3p_`$s!r2os(}0uEl1(SOhsa+F3rTqRTDxEogL@EUX(R_`eoepxWqg-vRn{zQs^ zKe}DK2{vCsrE28%lN?{cr3k~QNX5%r%>~)ms9z8A+#jG|wRIu;Y)E%>3se&v|G~$* z+dIe8=oH0`Xj;WOVaC|!mcZ&mJJIVH|ie1s*k=Y$9WRo*92|Zuyk+_V%5;N z6IsY#w9is#R-A~yvLiF&2I=0`DQQ!c&C29i*75jpm z^yhSA?W|BS>VvyG;JgUKp~n}tLk}DelvH!*0VmXO=+TK;=+NVL=@wqJS}Q7uy+RzW zUqJ|q#^SPWc0bBiRSsjaE~!xfJ)qgBWqvuAx}q4Y4FO#%>v}FLSBj7p@>~W1nl~)r zEaZ5F?JVR-5&OOR4b@*hq#?YXN}^IvJv z*t?_I)Yd5ieIdSa@_7}+TM*V0KRN+Xv`g6h9PJWT$sDM9FM0*S$k5rw*%m+gCOhgx zI=+YCI}nb^O5vZTfzuef`w)fWhtzY%8wL8p%D`I%x?yGD#R45u8F;fm9|sL~p4SWX z0h`8`Dul*)__3p^s~-*`w#M#Jaed%wumB(4?DcnUSKV76 zA9(6{LT%|GjcnxHgwYB%T@M>qM}YsvMlccxeAZU=uMoxe>?Qgx6o{FBc$ILwH{sAp zefBMw8W8%v!$jb}nLs@yih7D<@SI@=2+vtJ*uwMeh*mc*;ST?>k^2c}I;5ytQz#bT z$d6tbe6bPPvJ*GW8>qQRhcUS0THwzACHHr!F83Er>V2z;Y#W(H@wg44+0bt-qp}fo-SD{}+AX8Ki1JO!Y{zUb#_kE6~pdhOf z_UAAhJ3Y~u^CQ0WTn0n#)l*T3ZzEbi7~l2s#bVJT**49KX3^B3^7>Ie$a~%VK4WM1^7`@rbfOA3T4Llt-DR#6lvbTIVfBp zfj4L`tCQElher}3wX%}Efe1Xv^g=k@Dl}~){=i~4hEJJpi&$fEA-(Ug6nL(QLM(mJ zhHxP|BeguMr577WFo0}(%R)|LUpxtePOnu;KR@aG(}8Ylu;D3*gh%y6Q=zX{I&U<~ z{ei7txn1GQ{x0PL6d6wXyOjNpffy{S^nz;bA~{&H-D}IiyR5Ad&mMeOEA;Ksgr4vk zPMi|;&qcD@=Zr-SbU*6M@ZNG`YGq5*Q%>4craf$@4bfmFNW0HTdyZ+n>@>r)(}p=| z3z6oX9bCZS;&LVE`@si*espUaeToCNlqlNSC|V}kX$_pT%}iTt=S$viqd)qIO>&rN zXY8~WCfI3PowOK4>re29dj|D;FK#rgiioG{jp9-#_ZK8t+lvOIxIq~~V(}~xSk-Tg zpXY+%zqRVs@|nFu6JjvvlZ{0ad%s$KGE!hHDug(htXE$OxD7BuZm-YblYL(Idh#+O zHy;@F1>Nn)iq z@oofyiwU8(ASQ6So{@8!Nhq^9D^`X+&sO@C%g#i2XbrS3{Rheqe8;SCIdu|Ifr@%Y z?sj~LW0ByZ1;iH+G`Kt#9F$NrD5VKbVHRfw6>T=$o}c>hD%BkL302N7L7+pr1Cb{k(^8)tkKzaD`u8|kI|Qjlad>f$-@ zP_^Wp2uO17#mF1#e}(RZ-=e3aJ|M%yaR-dpviNv89F%0W@10*qqJy*WW8h(&M7jZ( zC80*%Sw>>oe4~*s57D0*jlA;_E)#qqC9Y~t!t%=Q^v3+-b`5SKh#VLSw7JlM5o=PtPtf3yb!#~vIyo^!`Kzqgtb z<{0`HJ=c(#q+fR<0vB7q7hs9mjkN+Llp{&71{OW^=yp! zlyDtU@meZ%i;=SiMd~H^1Lv=N)nn)1kdQ)6w$Q!Kt=Cqf@rl~?#z&zom7VozXTzg zd2SnFJN|0mpt+1G(i-WKl6?@wXO-xwK%_iK3{-T>#%;$z$#Otx24nCIA;gc zNWX|+aFMXTCK#N{WE_8mNO1PWWtb20>d{7gc%d-xw7ag63oq_+{nq;iT7hK zhihru)mT>;vd{z*?+(or53=ta<>~>jqY+O&zv-PQ59Q;5YSVgoK6oYXN#8+Zq5sF) ze}G3>bPwEcLI{Mi+@VAw7J{NCMj(nMF_bJxU>7zJR0Io(f`}buS3v2T0AX2-z4ymn zAN4`NmJp?dZUZY=@7o2%Miuw{oin@1QuP0Q@AYzBWbc_dbEcg+bLPyMGb2m#3;oRD zdV77DV02xTka=o6^Utgx9`Vu>t+nTVNFm|DS)#|owMS^vyyUq}TcY;E1?(TbHk&@xyRcgrB=_TVhR7n+#n%RLJjtR%lz zPuwqsEN{wAZV)8fchkm_b0%KrK~sUZoJOY@IeQ**&*u znyDb_5!akww0oi%kLZWxepk%kxc_!48EIk-Kj?Lu=J1>4d`3YH<#m*P!^M%Sn5@x^ zk^B`Ctkclh|IZL$Mb7c=DvdIS-8xkKwm-MK-OYeo9#0;(xo&& zrnVYXr%JR`BQzWdcX@6{I>5fIlmUVs^GXWdyN_Z5&0!y{z~l~n8LJ`JoGO2p#)K}V zOFs|v!ABMkFNdt28%y9v_?_U2n^vr_xqn4T{`jbWX#|zm4a}}}biMt0iSA&Y7U;E|-C*;w9PEr+QM*Hw@9`H`e_)XOvFO^s=s1 zemXyojwFa6q~lnXx5Rd68zZQ3?%7@3}FW@hun6 zq#e=(tJ0;6#S*1j_t?P22>{N4VVjNj!`hqL&B%8JTqSe!yeS`)%!QYbzhGi^;0gsQ z7=TU2-y(#)#UHx%2s+ZaK&wLkyUN*3Ml-JFuZ+L`a4oHGG-Ej5fa_uY$qMf3YLcTF zg(gi#$ye~6(7#?if8#=ys^a#t`!wsE9@K)QHGq+iW7r~FgFp55yYTagqz>Y6ztid# zVSklWx2UW94esr2Rqmy-;eL(@Y}dfHx<%QN&huOqTZmCO5k15Gell>fmk;;bZUT!m z@N?aw(-dh#k&kJ7m%2sAYLQ2o)L#B05heU>q*fK*0OH8rb4u6a7+)H|g5{SRw@+PoD+%_Q5=#4;TB0?h-(V zDwU{B&&zII^o_3X|3`R*hW)8_@LACa3`z%5ReiW`501`c&y(PO2V8QTZuhtnqrWd{ zqg~lNrtDrv$dS6ryM)eVe8_W6qV2b9R?T99b{y2gDUPFX}mp7$FD?mY3dVMOYV|Klx)v(`Yq&=n`GUc6bWwtV)sU%jA{HZbVw?DOL_1 z!}Kxi9A8(&*5WLQDJLe+B4!jZMG`Zfm~ty;e%BfFAd#c29CI^}`0<|b#ULT^F%q3& z6oDmpDLedbFnu&3T0UvUPr_6qTdn)ARg}Imd0LsfdjyFPvQQX zKXRs%L1c&(sb=ecrn5jBQg1Je#dLLM6XOdF6d!HFUTaVxJpXz&+5~)(KX;GuAASR1 z$O`N1DJG{?(HV(JcW|gd?6L9K781KeOJNJny_$PeyIT1xQO*mEWjX(CD63DrtlpGW z?JSp)X71TSM@$$zbI($Kty$ubiE}cq%KJ^M`DalKhj0Co-7wgzde;c><+WRzrOsFv zji%Ik@zvW~4q2=@mO#!;arT4utsO)a)?2|R`Ss>*^aS^&OfBXw7{4bSjOQeW`^^aM z?mMx=%)O5RHQ@+T6|3@n0L-I*Z}T;C&vsH#j`7XYM3S+T`ZS5<{>0=8w2WbC7kS_0 z2&Bbg-oR<47Brn|yV+%Z{cAL372jI>6lb^=@~0FM{F=X}x=p8EXsUZA$x>i)42?BM z-Zys7++8h|ZdzC$X*P4uACkLbfGktA)S916Ch4^%!5S&rn!N)8(XEMN^A&H!z$St@ z#Wcm5BQGfx)(2cO_bToqot=oB26>>hiL`>>5a$lNwM8$*o0b)C+F5^T)7&X5;|*-; z+$?1`rH0P6^2GorIhXSVmAQ)lt26YEy`8zwZ1`0su6r0tPxurR?x-E-g>NeT84eUV8kHDvRd}Q?NDv8^YR~u>+NArwch*a7EV9!-1m+W5&yr z6{3Eh<}*EC$IuX6MkcD4ME zNa!^{cjZeBjAf_E2}q`#+GW|_qe$m{lx8v$f;Q{t_}G^}UEX7{D&+#jZ&rG8r1|gs zwJxl&ms~7|WZk91LoE<+uvUtuR>I2_G|!A7_tLy6amqVbkK+cmmgEi58rJYpjJW z90wrl-4;$0AdIC+_h;lG_fLp7HTfX+<$v9T@1Z7qHSyyt8(bIZ-vRo!r{a}*?BAmG z*vXG`BM9hBYP+}cXsF?$-8{<%&daW+=SAyc(8TH#vQZMmRd?F@^B>NPY#Lq{Si zT9wD@H=YArZ@$c`c@wy*oz_IoD4^}BubrYrhvdg9+2s5pqaSkJ2`v3zvKxBsOBU8w z=v5jA9YL=ftnhOLlz!yCgOKV9+@6pkkCl=f@OP9e19RU{n5n+u<0t-SjxvCgYt zFoV6ve~B!}p(O!PKqYHr&naq={|6cE4o9-?v$LrDfza~Q43cDu+p8DtjRsF>A&^eJ z06wV1yxUnyfRdi&89V!;W+F%l`S5zzjUML&Hoqv7>DqEaw6kj68)Za~;;vK!*8{D59Xs$>i_%_+!B+y*++WjL< zQEJb&{r8DK-gWF|?W_3IW5=ETQ8dZlUuK(mtLc*^+{@=uWY74)Wy2QqpgY2D4yq}$ z@ck(j9?mq6M0>#gSlk&N=)+6S%ZWVb&0O_i(<64K3DbxiZ;wfmF4{mNX+noQ=T>cY zhuO|e((ao_>gn2Rd<#EKc~R-};t#Vp|9(hSF`^$p5ESb$tMXA4Mu~17ZqqQju2<GN8N{FlHSd_wwTn@Jgz z9bHv*ZXQ>cxX7DPR46`2+-FEhu6mQ_VyVp#^1!hFYf|nvDWCEBk$r}yXgx(nZdnX@ zxt&MO{3}`!PWNp_0CHJ_BY;p(ev8s+EjCH_G9xxdKI;%No>*%Kb> z*}19V{rL4U`MFc1@4uywt?Cpx_TK>Jc9O%Wt0>##Hw!o>maV>u&k7BDVgUt`<+t zn{QT`aqe}zDTaE6M0VFxg?o5-(bl+#w}$NI(0a;B=Vp?ZKl*Hhrf&wE;XCH zGP+xz)mq-N6Uu+;F&(KTXG^~uhjORYib`QONV)ahcE4y>uh(Rhe$ExW1hDn41GYvU z-pQEkcxLXKL4B&GU-tkRMYW=rp8V>T48vG@B@^@g(QLLXpr;2qIInaWX zV#~{;cr~a=>bxO$wl~F{UKSd<+gG@LT8^`V_F^*)nzGwGgd@DQim+>8G#`kv}-!DDZkWK7)7~dpGZm>v&ur_PN zTJ;Aw;l23qS(VoiZx7xFwAkf;5?PhVrS8;Bu9Pogecy=>j6EgGS&Lin8RT;{29V+T zA|ISs^j8$$I-b4;8!s^u(O8RWrxW2qf7fwV<(e4G0Vnv_$3D-wY?f9fVO}63jF5!p zeEjm99_fyI8Zo1l^5G9ag)Si@<2fFG6Oe1~)Gfa26+rBVnPOPmyUrp5X`4v%;r1)E z+)l01-G4`|<3O<{GAj9D?{br}ji=z2{Hb_D|J2@awdnhb0g!jgj^E49Wre5e)_hO! z*7T&nF}@Jaf{}Iy<*BR|&A6hM6mL61={V8KlVg}Xc`rkBCqB+$$8^m?5oz!5&XO*d z0Vl$2705n2JI3k9NR)aQPMuXPHI}O=9q!`Ari%(?Roy{l{3zWsMmV#3f7IU^J}l)FU0k%e4eqBX(Ps4yD3B;aG3ZX9oJX; z!cX@-sGMpVkTG+_mP=#@B}TTuALg4Ch+#Julxw zvO>SIig{{(ZW8=KtZx%lKR#;YlN$M`(au`@GtSt`!ZzHqbMt`<+i(wdW|#^2tXG!V z#edU@Io{CU6ywR=FXt77zlci28oXb8E(3(c$~yZf;5;cv+&@p*=o~|3JRuIz2BEd3 zf*AB6vsAfpMt6LYGl|rgxy}C`)oFOo6FNZC3E6kx-w5~;k3v>mkw2k8zSLWxi(&!1N^0Ru$J`P7&f5+Sd(i=cp?fl+Pw%+~3Q1!%5 zvQ(EurgK4SpAWKXXCnY)Sv-y`*TRZcuXcxOf?G!Q8f8@sF4iU#IbQup?Qmn_6no@- zonq1PG1Hvu1V}vSxAIh_m_9hiATUk~N(q!!YzU0Oa|3&y31z(O?gMR@xB0rL3 zZPT&G*Nt^oVZU8dYp0n&aT5)tV<(;|F(nF8+;nVdRdF+Kunvcn>u!48M{g9avMMeq zVKH0SV&)#ZI5gVNE_!MccJ_t>OGq&A; z@buO%--yZy1~IBsO2<-xl~s(0 zpMKGZK3~P-Jt$9S&SVpft?+aro%b~*?lz>_c~`>WZY_Rbx)of-S<&|j;7zj!US(9P zA87=yY=l0x&y2;@5Vxd_nd*<+%M{yufpK~D8VU3i_y3#&kaOt z!OMV_g>PW@SIXgBMb{aGJq4Ko7PP4UWJ)Rvt@hSOpsqXL&Lwi^9lLaA zkuT`N866{8Mk?;Z2XlP@ppnn?A*&O8VJ{C^wZ7fWLl?YaRoW_9S@*HLVYRlw(DWPP zoCrk=r`Y;{7IgAHGJ+- zJyNa0udUz?J`f{B={h}Zc^iT3( zij_x;f_D*gdd3rHADB2X9)G>W(`;-B*w$mHem%$>YtH$^2memFX%Y>?Y@~3*gzJO7 zg6#t1JlfI@LG9`@A#dsGY@q4th91a_VLfO7lZn=Lc%mzHAY&aV^FYvS1zos*)F}Xt za`+!BXKf6iMy6Bv=og&x`3UarXw80EKaR9!r$BkZ-ADTa!QIFBTLgD^wkq!sXz7_M zJ`OXsH%WS&o~{s>_6=sLrJKWW{#2V z-{edvMq1uj%vM5)1okN_i}cG%;u8sMaYL?P%}+uEbDkl_aZ7e-@BQ*Y!<^IOF?0Ax zD0Wf|z#FP-phcQ_8PQw?Bi38HwTYK^+~R~vVhM>XDwxw?TTxe#ZUs*x#w{nmHBC8Y zziAs8oL8u_H+=42GCz9JaH+nmlEJe%@k{2z8~WV2PgYF(I$Opt>c84~f_P7eSKPrb zyX||+gjI^CXV=B|D6{$UcbH8UOjB%Q2BdqdjFP{qnVZ+8Lu!Xp8B#2+b4-p8CCATU zWOI&EFZ9XI_$0Xta0O7SW%d*X?KFSapxxZ6SVo*gK{lyY<%fa?xiq*+KJ=wi0`J5E zj&`mjzd%e0M?9=v37P+tkS+=FP0t_# zqR9wnv>Ig$p;P`w9fAB2+95iHxNrqKoI4s=r<3M(eS8tc@O5xu~GGW)((@_*Gt7(mC)H-qG zT;xm@9*wzTky(WB9=kwe8r=##tKmk?ysS}_A9GOBZD2wt=4imR_)e|a)n7u0S5Px^ zvh}+p#!t3BCGamNTZP^dw|0-^BkW@o)3( z3*ExKw9@pl!sTVwkmWr;$Esr5vAk`Yg@d>(p1f^gEo@SPF>#K)h0!Yst%#(Qgz9mt z5$NbEn3_JdnKb*cyJp62K%@tj zf#Dp*5OO6OIqvdT+3|facUROH9XR`+f!mK zxE=t$23QMnOq|zRaG{ACXf4PvaXxE7f8v~G1d*4sLS2%azC={i_)qOs=z&6X98P_69ti#xpkNAbcwryE)A{MZ;6xyK zEc#rlVl@e+xu_TF_#mpORk2vV_Hc}UB4Ex93cKf8Yr$hAIHRNx3~X^>k&-sA$te?h zv9J!3NO{~*?iKFNxkbfb^>jPe33}P+ZVvc z7tIzn>f>$|{BxVee|#_Tn{G6!tOtg`&TmOehg}5wvaEL{9C?M9W>!U}e!Fwm`bWA8 z*9Mjdqkp3xZ>;Dgk(PG;US;BeH^adhOwzfXjjhq_67o@8KT-V@UxB}CQK0#}Bxe*r_A7m{zZ)!&0A0v7Wvtab^%7^pc|SqV{;<<{_;->eIl{Z2mTVWDI)ZRKsL zs^(1Lh$X@6C$ite99ZY{WMJ&_7>0^#2sz7C%U*9kPd3vNZS3yxGM*!`s)!#^TwGNEx(V@}~_WXH|5i>CP@>TUj}1a6_ zntq@2cdP=FhVO|wze*sSF~gyVXGA&%_v6@!&kmj3BV^Ozfdczmo;{|e{vP($X(q3myrE6Fo@rw*Gl@JC zO->BI!x_9N!9^ko^>BnsNMY%kLD03a?~3QZCN)Zb({tM4hD#8~x{pGHJ6pq5F;ST- zU5cXOtS{x)^=wFui(Z-@H!f;ELo{5)YEzVr{2DVZntT0j7*m^=*kfx=T*acB#SiBt zaOEC2Ux}aAhg_3EOUm;TNy*R@XNVTuD5T8L@SrsNDlB(|k?tg7$?-;+wV{HgrS$-# z%z8s1UA+y?A3g1J=?7ykD>p->vg<>Z)mzuajJ698vd=y~kq1yDXq{DYh& z!lP96Q*Y-|2cG+yEr%Chnflb_mlRx+=HKbuDaC~=w@_mr3XRI^G~D}-Czwo^X;u0| z9ymEDDCcH;SB+U?kIZQ;*7p8XZ{f0l9PVJ4JQz6Wslc7dReFUxpV&3_jpvz$wU;=g zs+OL@X`uRBIxRFU&)KIR{kfawdcFr|0k{ycDpyNnxH6x{YPH^0pnPYo#+Odg$Tv06 zyZjOA`aiz8b!=6>$A`D7kF!J)L+)`imu4|N98;Wo{LG~|=|c{JT7Rk! z!_gGQC5PRF15#M^fAe)Z;Sg*U`>~Y#nqEnHfH~1#P~8@sQjtP<*-uJ z=%>rXwwtoh7%LO2!owAsLyW$7t1DXs$ZUCjXbL8qpY)L&equ#u*Fo|KYW4+z4h8)) z0~V$V8*gOla#K&n*IRH&`jnR5g8u2&g4b!ZNYz=Yi1bG7=5sRqcF!AR1XJM#a!f7u79#D5$aStauIrkVVTo@oALT2hKzp6dsO&ZGZ8^|`)KVLJA~e@2&Bn^O;}O}^G< z(nbGXlWbHKdGuhac9B)}xk_Jjrsyy{;y6t_@k#G$f67Q#JtNHa7G;f06RJxQJZVh? z&tfb89hb;AFOq;*w^$YB8V?Jsw_Bi@Go<5x=THi!Vb1XYm-gKL4>T1cgDG2_X23PF z30%)=xX~5uUSaplH%<$b@yD%0IakyaaolZdN+aXnMEKx2DvoXgEfW|}G&SuF1cPvD zGC$6s-2@{&0=LK zSR^916>g$o9e`>|#<#}~ExJ+g`$@v#j5b&Riy(T=oh{@ZY?=rm8%)xZgG8UV#{Mvc zWk2TqUnp3`mKAn~J6gb7bCW~6t;&ZLd3?3x2@AsbDsd_`zTO`3vFPO9(~#?}8M+=n z^hXwpPL2J>XtPIbsa1A8Y*LTKBu`TBA@v~f?otK3kjZ~W`AMQxsTX0cU_x48s9ijZ zcb}*fwoV7IN;naxjDlC&63dWKxZ$NleO=hJhVKtk1L=uIltqNn~pwsjVncvyW^1A zriRV5vlK#=2i1VGDqjGF{n1ZUsn#j@S>#mwe zJM;Aj+EDZLPz|QNVb>6?O-8o-VBIDs6F8z;d9iYvbvzbrdpn>liOv3zTBG$`t;y)$ zx@{6%We_pE)1a-qSyIt0X7MPU`f)jJq0CNPWqbKRhU#>>7%L4?B(98j;wgOaB9@8$ zWs35K-B-4aD^maK*4xUD_S}hMw8KwQpZ9eZL03H=+&N88`{XVfD#-ck(06%TmoZ8#oqXVi^UFV@ifWK9qPMRYN z_-cDtf8Eqn-biRkrqKz!BUeUtpJ{XgqXiH2*$S~=w$qlf=5=;aft~{-#e!{T2v6YP zF5-M)a#$6EkiArY>`iXr3=qKJ?)_FpFA>RPf9>JzRjc9{O_-jY8?6y@H6@oCeWyXT&llpV<`D=1H!o`xCQc}3Zg zc4Y-4(xx@{R-IRq9Z4l_2BRs}^FP3X~-om<)u)C?-8nObD z$=V@!d&6uT^=az z4CV<7ji2C&IN!lomi*^bc&zlQ)048{aHsIIntAddSaB-p9EPAZIG98C{TqUrh9sl-(Ihot^;wM^JDC<*J+Q1xR%3!G6;^AvRQ zPj)XlT4*Xf>{GkAhY|CQ*b?|riSHA85ja>0dU*;iP50w_9489g*>JfiN93vRIwv`2 zg2ER*V{dl%B=>)d1sQgovNaqxs1;Jy