http-parser-0.9.0/0000755000076500000240000000000013642731560014546 5ustar benoitcstaff00000000000000http-parser-0.9.0/.gitignore0000755000076500000240000000033713642725626016552 0ustar benoitcstaff00000000000000*.gem *.swp *.pyc *.pyo *#* *.sw* build dist setuptools-* .svn/* .DS_Store .cache/* .tox/* *.so http_parser/parser.so http_parser.egg-info nohup.out .coverage doc/.sass-cache http_parser/__pycache__ MANIFEST .pytest_cache/ http-parser-0.9.0/LICENSE0000644000076500000240000000206513642731035015553 0ustar benoitcstaff000000000000002011-2020 (c) Benoît Chesneau 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. http-parser-0.9.0/Makefile.ext0000644000076500000240000000063613642725626017020 0ustar benoitcstaff00000000000000# This file is renamed to "Makefile.ext" in release tarballs so that # setup.py won't try to run it. If you want setup.py to run "make" # automatically, rename it back to "Makefile". all: http_parser/parser.c http_parser/parser.c: http_parser/parser.pyx cython -o http_parser.parser.c http_parser/parser.pyx mv http_parser.parser.c http_parser/parser.c clean: rm -f http_parser/parser.c .PHONY: clean all http-parser-0.9.0/NOTICE0000644000076500000240000001247313642731026015456 0ustar benoitcstaff00000000000000http-parser 2011-2020 (c) Benoît Chesneau http-parser is released under the MIT license. See the LICENSE file for the complete license. http-parser.c, http-parser.h under MIT license ---------------------------------------------- Copyright Joyent, Inc. and other Node contributors. All rights reserved. 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. setup.py my_build_ext function under MIT License ------------------------------------------------ Copyright Denis Bilenko and the contributors, http://www.gevent.org 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. util.py - IOrderedDict ---------------------- IOrderedDict is based on collections.OrderedDict module, with insensitive key search support. Under PSF license. Copyright © 2001-2010 Python Software Foundation; All Rights Reserved This LICENSE AGREEMENT is between the Python Software Foundation (“PSF”), and the Individual or Organization (“Licensee”) accessing and otherwise using Python 2.7.1 software in source or binary form and its associated documentation. Subject to the terms and conditions of this License Agreement, PSF hereby grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce, analyze, test, perform and/or display publicly, prepare derivative works, distribute, and otherwise use Python 2.7.1 alone or in any derivative version, provided, however, that PSF’s License Agreement and PSF’s notice of copyright, i.e., “Copyright © 2001-2010 Python Software Foundation; All Rights Reserved” are retained in Python 2.7.1 alone or in any derivative version prepared by Licensee. In the event Licensee prepares a derivative work that is based on or incorporates Python 2.7.1 or any part thereof, and wants to make the derivative work available to others as provided herein, then Licensee hereby agrees to include in any such work a brief summary of the changes made to Python 2.7.1. PSF is making Python 2.7.1 available to Licensee on an “AS IS” basis. PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON 2.7.1 WILL NOT INFRINGE ANY THIRD PARTY RIGHTS. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON 2.7.1 FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 2.7.1, OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF. This License Agreement will automatically terminate upon a material breach of its terms and conditions. Nothing in this License Agreement shall be deemed to create any relationship of agency, partnership, or joint venture between PSF and Licensee. This License Agreement does not grant permission to use PSF trademarks or trade name in a trademark sense to endorse or promote products or services of Licensee, or any third party. By copying, installing or otherwise using Python 2.7.1, Licensee agrees to be bound by the terms and conditions of this License Agreement. py25.IOBase, py25.RawIOBase, py25.BufferedReader, py25.TextIOWrapper: --------------------------------------------------------------------- Partial implementation of io classes from python 2.7. Only read functions have been ported. Under PSF license. Copyright © 2001-2010 Python Software Foundation; All Rights Reserved http-parser-0.9.0/PKG-INFO0000644000076500000240000001321413642731560015644 0ustar benoitcstaff00000000000000Metadata-Version: 1.1 Name: http-parser Version: 0.9.0 Summary: http request/response parser Home-page: http://github.com/benoitc/http-parser Author: Benoit Chesneau Author-email: benoitc@e-engura.com License: MIT Description: http-parser ----------- HTTP request/response parser for Python compatible with Python 2.x (>=2.7), Python 3 and Pypy. If possible a C parser based on http-parser_ from Ryan Dahl will be used. http-parser is under the MIT license. Project url: https://github.com/benoitc/http-parser/ .. image:: https://secure.travis-ci.org/benoitc/http-parser.png?branch=master :alt: Build Status :target: https://travis-ci.org/benoitc/http-parser Requirements: ------------- - Python 2.7 or sup. Pypy latest version. - Cython if you need to rebuild the C code (Not needed for Pypy) Installation ------------ :: $ pip install http-parser Or install from source:: $ git clone git://github.com/benoitc/http-parser.git $ cd http-parser && python setup.py install Note: if you get an error on MacOSX try to install with the following arguments: $ env ARCHFLAGS="-arch i386 -arch x86_64" python setup.py install Usage ----- http-parser provide you **parser.HttpParser** low-level parser in C that you can access in your python program and **http.HttpStream** providing higher-level access to a readable,sequential io.RawIOBase object. To help you in your day work, http-parser provides you 3 kind of readers in the reader module: IterReader to read iterables, StringReader to reads strings and StringIO objects, SocketReader to read sockets or objects with the same api (recv_into needed). You can of course use any io.RawIOBase object. Example of HttpStream +++++++++++++++++++++ ex:: #!/usr/bin/env python import socket from http_parser.http import HttpStream from http_parser.reader import SocketReader def main(): s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) try: s.connect(('gunicorn.org', 80)) s.send("GET / HTTP/1.1\r\nHost: gunicorn.org\r\n\r\n") r = SocketReader(s) p = HttpStream(r) print p.headers() print p.body_file().read() finally: s.close() if __name__ == "__main__": main() Example of HttpParser: ++++++++++++++++++++++ :: #!/usr/bin/env python import socket # try to import C parser then fallback in pure python parser. try: from http_parser.parser import HttpParser except ImportError: from http_parser.pyparser import HttpParser def main(): p = HttpParser() s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) body = [] try: s.connect(('gunicorn.org', 80)) s.send("GET / HTTP/1.1\r\nHost: gunicorn.org\r\n\r\n") while True: data = s.recv(1024) if not data: break recved = len(data) nparsed = p.execute(data, recved) assert nparsed == recved if p.is_headers_complete(): print p.get_headers() if p.is_partial_body(): body.append(p.recv_body()) if p.is_message_complete(): break print "".join(body) finally: s.close() if __name__ == "__main__": main() You can find more docs in the code (or use a doc generator). Copyright --------- 2011-2020 (c) Benoît Chesneau .. http-parser_ https://github.com/ry/http-parser Platform: any Classifier: Development Status :: 4 - Beta Classifier: Environment :: Other Environment Classifier: Intended Audience :: Developers Classifier: License :: OSI Approved :: MIT License Classifier: Operating System :: MacOS :: MacOS X Classifier: Operating System :: POSIX Classifier: Programming Language :: Python Classifier: Programming Language :: Python :: 2 Classifier: Programming Language :: Python :: 2.6 Classifier: Programming Language :: Python :: 2.7 Classifier: Programming Language :: Python :: 3 Classifier: Programming Language :: Python :: 3.2 Classifier: Programming Language :: Python :: 3.3 Classifier: Programming Language :: Python :: 3.4 Classifier: Programming Language :: Python :: 3.5 Classifier: Programming Language :: Python :: 3.6 Classifier: Programming Language :: Python :: 3.7 Classifier: Programming Language :: Python :: 3.8 Classifier: Topic :: Internet Classifier: Topic :: Utilities Classifier: Topic :: Software Development :: Libraries :: Python Modules http-parser-0.9.0/README.rst0000644000076500000240000000653113642731230016234 0ustar benoitcstaff00000000000000http-parser ----------- HTTP request/response parser for Python compatible with Python 2.x (>=2.7), Python 3 and Pypy. If possible a C parser based on http-parser_ from Ryan Dahl will be used. http-parser is under the MIT license. Project url: https://github.com/benoitc/http-parser/ .. image:: https://secure.travis-ci.org/benoitc/http-parser.png?branch=master :alt: Build Status :target: https://travis-ci.org/benoitc/http-parser Requirements: ------------- - Python 2.7 or sup. Pypy latest version. - Cython if you need to rebuild the C code (Not needed for Pypy) Installation ------------ :: $ pip install http-parser Or install from source:: $ git clone git://github.com/benoitc/http-parser.git $ cd http-parser && python setup.py install Note: if you get an error on MacOSX try to install with the following arguments: $ env ARCHFLAGS="-arch i386 -arch x86_64" python setup.py install Usage ----- http-parser provide you **parser.HttpParser** low-level parser in C that you can access in your python program and **http.HttpStream** providing higher-level access to a readable,sequential io.RawIOBase object. To help you in your day work, http-parser provides you 3 kind of readers in the reader module: IterReader to read iterables, StringReader to reads strings and StringIO objects, SocketReader to read sockets or objects with the same api (recv_into needed). You can of course use any io.RawIOBase object. Example of HttpStream +++++++++++++++++++++ ex:: #!/usr/bin/env python import socket from http_parser.http import HttpStream from http_parser.reader import SocketReader def main(): s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) try: s.connect(('gunicorn.org', 80)) s.send("GET / HTTP/1.1\r\nHost: gunicorn.org\r\n\r\n") r = SocketReader(s) p = HttpStream(r) print p.headers() print p.body_file().read() finally: s.close() if __name__ == "__main__": main() Example of HttpParser: ++++++++++++++++++++++ :: #!/usr/bin/env python import socket # try to import C parser then fallback in pure python parser. try: from http_parser.parser import HttpParser except ImportError: from http_parser.pyparser import HttpParser def main(): p = HttpParser() s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) body = [] try: s.connect(('gunicorn.org', 80)) s.send("GET / HTTP/1.1\r\nHost: gunicorn.org\r\n\r\n") while True: data = s.recv(1024) if not data: break recved = len(data) nparsed = p.execute(data, recved) assert nparsed == recved if p.is_headers_complete(): print p.get_headers() if p.is_partial_body(): body.append(p.recv_body()) if p.is_message_complete(): break print "".join(body) finally: s.close() if __name__ == "__main__": main() You can find more docs in the code (or use a doc generator). Copyright --------- 2011-2020 (c) Benoît Chesneau .. http-parser_ https://github.com/ry/http-parser http-parser-0.9.0/THANKS0000644000076500000240000000044113642725626015466 0ustar benoitcstaff00000000000000Benoit Calvez Brian Rosner Christian Wyglendowski Ronny Pfannschmidt Mike Gilbert Ben Pedrick Alan Grow Geert Jansen http-parser-0.9.0/TODO.md0000644000076500000240000000023013642731075015631 0ustar benoitcstaff00000000000000- make the speedup in C optionnal - refactor http_parser: C code should be minimal and all the logic (environ parsing) should be passed to the python.http-parser-0.9.0/examples/0000755000076500000240000000000013642731560016364 5ustar benoitcstaff00000000000000http-parser-0.9.0/examples/httpparser.py0000755000076500000240000000215013642725626021141 0ustar benoitcstaff00000000000000#!/usr/bin/env python import socket try: from http_parser.parser import HttpParser except ImportError: from http_parser.pyparser import HttpParser from http_parser.util import b def main(): p = HttpParser() s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) body = [] header_done = False try: s.connect(('gunicorn.org', 80)) s.send(b("GET / HTTP/1.1\r\nHost: gunicorn.org\r\n\r\n")) while True: data = s.recv(1024) if not data: break recved = len(data) nparsed = p.execute(data, recved) assert nparsed == recved if p.is_headers_complete() and not header_done: print(p.get_headers()) print(p.get_headers()['content-length']) print(p.get_method()) header_done = True if p.is_partial_body(): body.append(p.recv_body()) if p.is_message_complete(): break print(b("").join(body)) finally: s.close() if __name__ == "__main__": main() http-parser-0.9.0/examples/httpparser_from_file.py0000644000076500000240000000072613642725626023167 0ustar benoitcstaff00000000000000#coding=utf-8 ''' Created on 2012-3-24 @author: fengclient ''' from http_parser.pyparser import HttpParser if __name__ == '__main__': rsp = open('d:\\172_response.txt').read() # if your are reading a text file from windows, u may need manually convert \n to \r\n # universal newline support: http://docs.python.org/library/functions.html#open rsp = rsp.replace('\n', '\r\n') p = HttpParser() p.execute(rsp, len(rsp)) print(p.get_headers()) http-parser-0.9.0/examples/httpstream.py0000755000076500000240000000100313642725626021134 0ustar benoitcstaff00000000000000#!/usr/bin/env python import socket from http_parser.http import HttpStream from http_parser.reader import SocketReader from http_parser.util import b def main(): s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) try: s.connect(('gunicorn.org', 80)) s.send(b("GET / HTTP/1.1\r\nHost: gunicorn.org\r\n\r\n")) p = HttpStream(SocketReader(s)) print(p.headers()) print(p.body_file().read()) finally: s.close() if __name__ == "__main__": main() http-parser-0.9.0/examples/test_issue23.py0000755000076500000240000000104613642725626021304 0ustar benoitcstaff00000000000000#!/usr/bin/env python import socket from http_parser.http import HttpStream from http_parser.reader import SocketReader from http_parser.util import b def main(): s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) try: s.connect(('baike.baidu.com', 80)) s.send(b("GET /view/262.htm HTTP/1.1\r\nHost: baike.baidu.com\r\n\r\n")) p = HttpStream(SocketReader(s), decompress=True) print(p.headers()) print(p.body_file().read()) finally: s.close() if __name__ == "__main__": main() http-parser-0.9.0/http_parser/0000755000076500000240000000000013642731560017101 5ustar benoitcstaff00000000000000http-parser-0.9.0/http_parser/__init__.py0000644000076500000240000000031313642730727021213 0ustar benoitcstaff00000000000000# -*- coding: utf-8 - # # This file is part of http_parser released under the MIT license. # See the NOTICE for more information. version_info = (0, 9, 0) __version__ = ".".join(map(str, version_info)) http-parser-0.9.0/http_parser/__pycache__/0000755000076500000240000000000013642731560021311 5ustar benoitcstaff00000000000000http-parser-0.9.0/http_parser/__pycache__/__init__.cpython-37.pyc0000644000076500000240000000030013642731427025472 0ustar benoitcstaff00000000000000B ױ^@sdZdeeeZdS)) r.N) version_infojoinmapstr __version__r r http_parser/__init__.pyshttp-parser-0.9.0/http_parser/__pycache__/_socketio.cpython-37.pyc0000644000076500000240000001007013642730155025714 0ustar benoitcstaff00000000000000B ^"@szdZddlZddlZddlmZmZmZddlmZmZm Z ee fZ ddZ ej dkr\e Z ndd Z Gd d d ejZdS) z( socketio taken from the python3 stdlib N)timeouterrorsocket)EINTREAGAIN EWOULDBLOCKcCs&|t|}t|}||d|<|S)N)recvlen)sockbufdatalrC/Users/benoitc/PycharmProjects/http-parser/http_parser/_socketio.py_recv_into_sock_py26s r)rfinalcCs ||S)N) recv_into)r r rrrrc@sjeZdZdZddZddZddZdd Zd d Zd d Z e ddZ e ddZ ddZ dddZdS)SocketIOzRaw I/O implementation for stream sockets. This class supports the makefile() method on sockets. It provides the raw I/O interface on top of a socket object. cCsZ|dkrtd|tj|||_d|kr6|d7}||_d|k|_d|k|_d|_dS)N)rwrwrbwbrwbzinvalid mode: %rbrrF) ValueErrorio RawIOBase__init___sock_mode_reading_writing_timeout_occurred)selfr moderrrr",s    zSocketIO.__init__c Cs|||jrtdxpy t|j|Stk rHd|_Yq tk r}z&|jd}|t krlw |t krxdSWdd}~XYq Xq WdS)a3Read up to len(b) bytes into the writable buffer *b* and return the number of bytes read. If the socket is non-blocking and no bytes are available, None is returned. If *b* is non-empty, a 0 return value indicates that the connection was shutdown at the other end. z!cannot read from timed out objectTrN) _checkClosed_checkReadabler'IOError_recv_into_sockr#rrargsr_blocking_errnos)r(renrrrreadinto8s"  zSocketIO.readintoc CsX||y |j|Stk rR}z|jdtkr@dSWdd}~XYnXdS)aWrite the given bytes or bytearray object *b* to the socket and return the number of bytes written. This can be less than len(b) if not all data could be written. If the socket is non-blocking and no bytes could be written None is returned. rN)r*_checkWritabler#sendrr.r/)r(rr0rrrwriteRs zSocketIO.writecCs|jo |j S)z2True if the SocketIO is open for reading. )r%closed)r(rrrreadablebszSocketIO.readablecCs|jo |j S)z2True if the SocketIO is open for writing. )r&r6)r(rrrwritablegszSocketIO.writablecCs||jS)z=Return the file descriptor of the underlying socket. )r*r#fileno)r(rrrr9lszSocketIO.filenocCs|js|SdSdS)N)r6r9)r(rrrnamersz SocketIO.namecCs|jS)N)r$)r(rrrr)ysz SocketIO.modecCs |jr dStj|d|_dS)zClose the SocketIO object. This doesn't close the underlying socket, except if all references to it have disappeared. N)r6r r!closer#)r(rrrr<}s zSocketIO.closeNcCs|jrt|dkrdn|dS)z8Internal: raise an ValueError if file is closed NzI/O operation on closed file.)r6r)r(msgrrrr*szSocketIO._checkClosed)N)__name__ __module__ __qualname____doc__r"r2r5r7r8r9propertyr;r)r<r*rrrrrs     r)rAr sysrrrerrnorrrr/r version_infor-r!rrrrrs http-parser-0.9.0/http_parser/__pycache__/http.cpython-37.pyc0000644000076500000240000001556413642730155024731 0ustar benoitcstaff00000000000000B ^@sddlmZmZmZyddlmZWn ek rDddlmZYnXddlm Z ddl m Z m Z dZ dZdZGdddeZGd d d eZGd d d eZGd ddeZdS))DEFAULT_BUFFER_SIZEBufferedReader TextIOWrapper) HttpParser)HttpBodyReader)status_reasons bytes_to_strc@seZdZdZdS) NoMoreDatazZ exception raised when trying to parse headers but we didn't get all data needed. N)__name__ __module__ __qualname____doc__rr>/Users/benoitc/PycharmProjects/http-parser/http_parser/http.pyr sr c@seZdZdZdS) ParserErrorz" error while parsing http request N)r r rrrrrrrsrc@seZdZdZdS) BadStatusLinez# error when status line is invalid N)r r rrrrrrrsrc@seZdZdZedefddZddZddZd d Z d d Z d dZ ddZ ddZ ddZddZddZddZddZddZdd Zd!d"Zd#d$Zd1d&d'Zd2d)d*Zd3d+d,Zd-d.Zd/d0ZeZd%S)4 HttpStreamz An HTTP parser providing higher-level access to a readable, sequential io.RawIOBase object. You can use implementions of http_parser.reader (IterReader, StringReader, SocketReader) or create your own. FcCs|||d|_||_dS)z constructor of HttpStream. :attr stream: an io.RawIOBase object :attr kind: Int, could be 0 to parseonly requests, 1 to parse only responses or 2 if we want to let the parser detect the type. )kind decompressN)parserstream)selfrrr parser_classrrr__init__&s zHttpStream.__init__cCs^|jrdSxJy t|Wn*tk rF|jr:dStdYnX|jrdSqWdS)NzCan't parse headers)ris_headers_completenext StopIterationr )rrrr_check_headers_complete2s    z"HttpStream._check_headers_completecCst|jrdSg}|spxVyt|}||Wn0tk r`|jrNdStd|YnX|rdSqWdS)NT)rrrappendrrjoin)rconddatadrrr_wait_status_lineBs  zHttpStream._wait_status_linecCs||jjS)N)r&rget_url)rrrr _wait_on_urlTszHttpStream._wait_on_urlcCs||jjS)N)r&rget_status_code)rrrr_wait_on_statusWszHttpStream._wait_on_statuscCs||jjS)N)r&r get_method)rrrr_wait_on_methodZszHttpStream._wait_on_methodcCs||jS)z get full url of the request )r(rr')rrrrurl]szHttpStream.urlcCs||jS)zH get path of the request (url without query string and fragment )r(rZget_path)rrrrpathbszHttpStream.pathcCs||jS)z get query string of the url )r(rZget_query_string)rrrr query_stringhszHttpStream.query_stringcCs||jS)z get fragment of the url )r(rZ get_fragment)rrrrfragmentmszHttpStream.fragmentcCs||jS)N)r*rZ get_version)rrrrversionrszHttpStream.versioncCs||jS)z* get status code of a response as integer )r*rr))rrrr status_codevszHttpStream.status_codecCs$|}tt|d}d||fS)z$ return complete status with reason unknownz%s %s)r2rgetint)rr2reasonrrrstatus{szHttpStream.statuscCs||jS)z get HTTP method as string)r,rr+)rrrrmethodszHttpStream.methodcCs||j}|S)z get request/response headers, headers are returned in a OrderedDict that allows you to get value using insensitive keys.)rrZ get_headerscopy)rheadersrrrr:s zHttpStream.headerscCs||jS)z< return True if the connection should be kept alive )rrshould_keep_alive)rrrrr;szHttpStream.should_keep_alivecCs||jS)z9 return True if Transfer-Encoding header value is chunked)rr is_chunked)rrrrr<szHttpStream.is_chunkedNcCs||jS)zy get WSGI environ based on the current request. :attr initial: dict, initial values to fill in environ. )rrZget_wsgi_environ)rinitialrrr wsgi_environszHttpStream.wsgi_environTc CsL||dkrd}|dkr t}t|}t||}|r:|St||||}|S)z return the body as a buffered stream object. If binary is true an io.BufferedReader will be returned, else an io.TextIOWrapper. Nr)rrrrr) r bufferingbinaryencodingerrorsnewlinerawbuftextrrr body_files zHttpStream.body_filecCs|j|||dS)z return body as string )rArBrD)rHread)rrArBrCrDrrr body_stringszHttpStream.body_stringcCs|S)Nr)rrrr__iter__szHttpStream.__iter__cCs|jrttt}|j|}|dkr2td||d=t|}|j ||}||krz|jszt d||t |f|dkrt|S)Nz(nonblocking socket used in blocking codez!nparsed != recved (%s != %s) [%s]r) rZis_message_completer bytearrayrrreadintoIOErrorbytesexecuterr)rbZrecvedZto_parseZnparsedrrr__next__s   zHttpStream.__next__)N)NTNNN)TNNN)r r rr HTTP_BOTHrrrr&r(r*r,r-r.r/r0r1r2r7r8r:r;r<r>rHrJrKrRrrrrrrs6    rN)iorrrZhttp_parser.parserr ImportErrorhttp_parser.pyparserZhttp_parser.readerrZhttp_parser.utilrrrSZ HTTP_RESPONSEZ HTTP_REQUEST Exceptionr rrobjectrrrrrs http-parser-0.9.0/http_parser/__pycache__/pyparser.cpython-37.pyc0000644000076500000240000002706513642730155025616 0ustar benoitcstaff00000000000000B H^F<@sddlZddlZddlZejdkr0ddlmZnddlZddlZddlm Z m Z m Z m Z m Z mZedZedZedZedZdZdZd ZGd d d eZGd d d eZGdddeZGdddeZdS)N))b bytes_to_str IOrderedDictStringIOunquoteMAXSIZEz[A-Z0-9$-_.]{3,20}zHTTP/(\d+).(\d+)z(\d{3})\s*(\w*)z[-()<>@,;:\[\]={} \\"]c@seZdZdZdS)InvalidRequestLinez) error raised when first line is invalid N)__name__ __module__ __qualname____doc__rrB/Users/benoitc/PycharmProjects/http-parser/http_parser/pyparser.pyr sr c@seZdZdZdS) InvalidHeaderz error raised on invalid header N)r r rrrrrrr"src@seZdZdZdS)InvalidChunkSizez2 error raised when we parse an invalid chunk size N)r r rrrrrrr%src@seZdZd:ddZddZddZd d Zd d Zd dZddZ ddZ ddZ ddZ ddZ ddZddZddZdd Zd!d"Zd#d$Zd%d&Zd'd(Zd)d*Zd+d,Zd-d.Zd/d0Zd1d2Zd3d4Zd5d6Zd7d8Zd9S); HttpParserr FcCs||_||_d|_d|_g|_d|_d|_d|_d|_d|_ d|_ d|_ d|_ d|_ t|_t|_d|_g|_d|_d|_d|_d|_d|_d|_d|_d|_d|_d|_dS)NFT)kind decompresserrnoerrstr_buf_version_method _status_code_status_reason_url_path _query_string _fragmentr_headersdict_environ_chunked_body _trailers _partial_body_clen _clen_rest_HttpParser__on_firstline _HttpParser__on_headers_complete_HttpParser__on_message_begin _HttpParser__on_message_complete_HttpParser__decompress_obj!_HttpParser__decompress_first_try)selfrrrrr__init__*s8zHttpParser.__init__cCs|jS)N)r)r3rrr get_versionOszHttpParser.get_versioncCs|jS)N)r)r3rrr get_methodRszHttpParser.get_methodcCs|jS)N)r)r3rrrget_status_codeUszHttpParser.get_status_codecCs|jS)N)r )r3rrrget_urlXszHttpParser.get_urlcCs|jS)N)r!)r3rrrget_path[szHttpParser.get_pathcCs|jS)N)r")r3rrrget_query_string^szHttpParser.get_query_stringcCs|jS)N)r#)r3rrr get_fragmentaszHttpParser.get_fragmentcCs|jS)N)r$)r3rrr get_headersdszHttpParser.get_headerscCs|js dS|j}x*dD]"}d|}||kr||||<qW|dtjdd}|r|j|dd}| t ||dnd|d<|dd dkrd |d <n&|d d d krd |d <nd |d <|S)N)CONTENT_LENGTH CONTENT_TYPE SCRIPT_NAMEzHTTP_%sr?rr ) PATH_INFOr?ZHTTP_X_FORWARDED_PROTOCOLZsslhttpszwsgi.url_schemeZHTTP_X_FORWARDED_SSLonhttp) r.r&copypopgetosenvironr!splitupdaterlower)r3rHkeyhkeyZ script_nameZ path_inforrrget_wsgi_environgs*     zHttpParser.get_wsgi_environcCs td|j}g|_d|_|S)z% return last chunk of the parsed bodyrF)rjoinr(r*)r3bodyrrr recv_bodyszHttpParser.recv_bodycCsjt|}td|j}tt||}|d|||d}}||d|<|s^g|_d|_n|g|_|S)zu Receive the last chunk of the parsed body and store the data in a buffer rather than creating a new string. rNrF)lenrrOr(minr*)r3ZbarraylrPmdatarestrrrrecv_body_intos zHttpParser.recv_body_intocCs.|jdd}dd|dD}d|kS)zH Do we get upgrade header in the request. Useful for websockets connectionrcSsg|] }|qSr)strip).0xrrr sz)HttpParser.is_upgrade..,Zupgrade)r$rFrKrI)r3hconnZ hconn_partsrrr is_upgradeszHttpParser.is_upgradecCs|jS)z. return True if all headers have been parsed. )r.)r3rrris_headers_completeszHttpParser.is_headers_completecCs|jS)z1 return True if a chunk of body have been parsed )r*)r3rrris_partial_bodyszHttpParser.is_partial_bodycCs|jS)z" return True if the parsing start )r/)r3rrris_message_beginszHttpParser.is_message_begincCs|jS)z1 return True if the parsing is done (we get EOF) )r0)r3rrris_message_completeszHttpParser.is_message_completecCs|jS)z9 return True if Transfer-Encoding header value is chunked)r')r3rrr is_chunkedszHttpParser.is_chunkedcCs4|jdd}|dkrdS|dkr*dS|jdkS)z< return True if the connection should be kept alive rYrcloseFz keep-aliveT)r r )r$rFrKr)r3r_rrrshould_keep_alives zHttpParser.should_keep_alivec Cs|dkrd|_|Sd}x|js|td}|dkrJ|j|t|Sd|_|j|d|ttd|j}||d}||dd}td}| |r|g|_n|Sq|j sT|r|j|td}yFtd|j}| |}t |t kr |s |S|t||}Wn4tk rP} zt|_t| |_|Sd} ~ XYnXq|js|jsjd|_|r|j|td}|}|dkr|S|dkr|S|dkrd|_|St||}qdSqWdS)NrTz rr )r0r-findrrappendrRrrO_parse_firstliner._parse_headerstypeboolrINVALID_HEADERrstrrr/ _parse_bodymax) r3rVlengthZ nb_parsedidx first_linerWto_parsereterrrexecutesb            zHttpParser.executec Csyh|jdkrtd|d|d|_|d|_t |d}|j pld|_ |j pxd|_ |jpd|_t|d}|dkrtd|dt|dt|df|_t|dr|j|j |j |j|j|dd dS) Nr rrzinvalid Method: %sr rzInvalid HTTP version: %sr&)r@ QUERY_STRINGRAW_URIREQUEST_METHODSERVER_PROTOCOL)rIrRr METHOD_REr~upperrr urlparseurlsplitpathr!queryr"fragmentr#r}rrrhasattrr&rJ)r3r|rpartsr~rrrry&s,       zHttpParser._parse_request_linec Csx|td}|dkr@|jdkr<|tdkr|ddr>|d}|dr2|dd}||qWd| }||jkrld|j||f}||j|<d| dd}||j|<qdW|jd}|jdd} |dk ryt||_|_Wntk rYnXn| dk|_|jst|_|jd} |jrR| dkr>t dtj!|_"d|_#n| dkrRt |_"||dd} | g|_d|_t| S)Nz rz TFcSsg|]}t|dqS)z )r)r[r|rrrr]Qsz-HttpParser._parse_headers..:zinvalid line %sr z zinvalid header name %s)  rz%s, %szHTTP_%s-_zcontent-lengthztransfer-encodingchunkedzcontent-encodinggzipdeflate)$rhrrrr.rIrRrErrZrstripr HEADER_REsearchendswithlstrip startswithrirOr$replacer&rFrKrr,r+ ValueErrorr'rrzlib decompressobj MAX_WBITSr1r2) r3rVrslinescurrnamevaluerLZclenteencodingrWrrrrkFsh                 zHttpParser._parse_headersc Cs|jdkr"t|jdkr"d|_dS|jstd|j}|jt|8_|jdk r|j sh|j |}nLy|j |}Wn4t j k rt t j |j_ |j |}YnXd|_ d|_|j|g|_|jdkrd|_dStd|j}y||\}}Wn8tk r:}zt|_dt||_dSd}~XYnX|dkrJ|S|dksbt||krfdS|d|||d}}t|dkrt|_d ||_dS|jdk r|j |}d|_|j||ddg|_t|SdS) NrrTrFzinvalid chunk size [%s]r zchunk missing terminator [%s])rrRrr0r'rrOr,r1r2rrerrorrrr*r(ri_parse_chunk_sizer INVALID_CHUNKrror)r3Z body_partrVsizerWrwrrrrpsV        zHttpParser._parse_bodycCs|td}|dkrdS|d|||dd}}|tddd}yt|d}Wntk rzt|YnX|dkr||dS||fS) Nz r)NNr ;r r)rN)rhrrIrZrrr_parse_trailers)r3rVrsr|Z rest_chunk chunk_sizerrrrs zHttpParser._parse_chunk_sizecCs:|td}|ddtdkr6||d||_dS)Nz r z )rhrrkr))r3rVrsrrrrszHttpParser._parse_trailersN)r F)r r rr4r5r6r7r8r9r:r;r<rNrQrXr`rarbrcrdrergrxrjrzryrkrprrrrrrr(s6 % A N=r)rGresys version_info urllib.parseparserrhttp_parser.utilrrrrrrcompilerr}rrr{rnr Exceptionr rrobjectrrrrrs$      http-parser-0.9.0/http_parser/__pycache__/reader.cpython-37.pyc0000644000076500000240000000651013642730155025203 0ustar benoitcstaff00000000000000B ^ @stddlmZmZddlmZddlZGdddeZGdddeZGdd d eZdd l m Z Gd d d e Z dS) )DEFAULT_BUFFER_SIZE RawIOBase)StringIONc@s0eZdZdZddZddZddZdd Zd S) HttpBodyReaderz( Raw implementation to stream http body cCs||_d|_dS)NF) http_streameof)selfrr @/Users/benoitc/PycharmProjects/http-parser/http_parser/reader.py__init__szHttpBodyReader.__init__cCs|jjs|jr0|jjr,|jj|SdS|y |Wntk rXYnXxtt t }|jj |}|dkr|P||d=|jj t||}||krdS|jjs|dkrPq\|jjr\Pq\W|jjsd|_d}tdS|jj|S)NrT)rparseris_message_completeris_partial_bodyrecv_body_into_checkReadable _checkClosedAttributeError bytearrayrstreamreadintoexecutebyteslen)rbbufrecvednparsedr r r rs6     zHttpBodyReader.readintocCs|j p|jjS)N)closedrr r)rr r r readable7szHttpBodyReader.readablecCs|jr dSt|d|_dS)N)rrcloser)rr r r r :s zHttpBodyReader.closeN)__name__ __module__ __qualname____doc__r rrr r r r r r s #rc@s0eZdZdZddZddZddZdd Zd S) IterReaderz* A raw reader implementation for iterable cCst||_d|_dS)N)iter_buffer)riterabler r r r Bs zIterReader.__init__cCs||t|}y\|j}|j|7_tt|j|}|jd||j|d}|_||d|<t|Stk r|dd=dSXdS)Nr)rrrr'nextr(min StopIteration)rrlchunkmdatar r r rFs    zIterReader.readintocCs|j S)N)r)rr r r rVszIterReader.readablecCs|jr dSt|d|_dS)N)rrr r')rr r r r Ys zIterReader.closeN)r!r"r#r$r rrr r r r r r%@s r%c@seZdZdZddZdS) StringReaderzO a raw reader for strings or StringIO.StringIO, cStringIO.StringIO objects cCs*t|tjrt|}n|}t||dS)N) isinstancetypesZ StringTypesrr%r )rstringr)r r r r cs  zStringReader.__init__N)r!r"r#r$r r r r r r1_sr1)SocketIOcseZdZfddZZS) SocketReadercstt|j|dddS)Nrb)mode)superr6r )rsock) __class__r r r mszSocketReader.__init__)r!r"r#r __classcell__r r )r;r r6lsr6) iorrhttp_parser.utilrr3rr%r1Zhttp_parser._socketior5r6r r r r s 3 http-parser-0.9.0/http_parser/__pycache__/util.cpython-37.pyc0000644000076500000240000001703013642730155024715 0ustar benoitcstaff00000000000000B ^W!2@sddlZyddlmZWn ek r8ddlmZYnXejddkrddlmZddZddZ e fZ ddl Z e j Z ejZnddlmZd dZd dZ efZ yddlZej Z ZWn&ek rddl Z e j Z ZYnXGd d d eZyeeWnek red ZYn XedZ[GdddeeZdddddddddddddddd d!d"d#d$d%d&d'd(d)d*d+d,d-d.d/d0d1d2d3d4d5d6d7d8d9d:d;dd?d@dAdB1ZdS)CN)MutableMapping)unquotecCs |dS)Nzlatin-1)encode)sr>/Users/benoitc/PycharmProjects/http-parser/http_parser/util.pybsr cCs t|dS)Nlatin1)str)r rrr bytes_to_strsr cCs|S)Nr)rrrrr scCs|S)Nr)rrrrr #sc@seZdZddZdS)XcCsdS)Nlr)selfrrr__len__1sz X.__len__N)__name__ __module__ __qualname__rrrrrr 0sr ilc@seZdZdZddZddejfddZddejfdd Zejfd d Zd d Z d'ddZ d(ddZ ddZ ddZ d)ddZejZejZejZejZejZejZejZd*ddZddZdd Zed+d!d"Zd#d$Zd%d&ZdS), IOrderedDictz>Dictionary that remembers insertion order with insensitive keycOst|dkrtdt|y |jWnBtk rhdddg|_}d}d}|||<||<i|_YnXi|_|j||dS)zInitialize an ordered dictionary. Signature is the same as for regular dictionaries, but keyword arguments are not recommended because their insertion order is arbitrary. z$expected at most 1 arguments, got %dNr)len TypeError_IOrderedDict__rootAttributeError_IOrderedDict__map_IOrderedDict__lowerupdate)rargskwdsrootPREVNEXTrrr__init__Is   zIOrderedDict.__init__rrcCsb||krD|j}||}|||g||<||<|j|<||j|<|j|}||||dS)z!od.__setitem__(i, y) <==> od[i]=yN)rrrlower)rkeyvaluerr Z dict_setitemrlastrrr __setitem__\s zIOrderedDict.__setitem__cCsR||kr|j|}||||j|}||}||}|||<|||<dS)z od.__delitem__(y) <==> del od[y]N)rpopr"r)rr#rr Z dict_delitemlinkZ link_prevZ link_nextrrr __delitem__hs  zIOrderedDict.__delitem__cCs"||kr|j|}|||S)N)rgetr")rr#Z dict_getitemrrr __getitem__vszIOrderedDict.__getitem__cCs||jkS)N)r"r)rr#rrr __contains__{szIOrderedDict.__contains__ccs2|j}||}x||k r,||V||}qWdS)zod.__iter__() <==> iter(od)N)r)rr KEYrcurrrrr__iter__~s   zIOrderedDict.__iter__ccs2|j}||}x||k r,||V||}qWdS)z#od.__reversed__() <==> reversed(od)N)r)rrr.rr/rrr __reversed__s   zIOrderedDict.__reversed__cs\fddD}jjf}``t}|\__|rPj|f|fSj|ffS)z%Return state information for picklingcsg|]}||gqSrr).0k)rrr sz+IOrderedDict.__reduce__..)rrvarscopy __class__)ritemstmp inst_dictr)rr __reduce__s   zIOrderedDict.__reduce__cCshyDx|jD]}|dd=qW|j|jdg|jdd<|jWntk rXYnXt|dS)z.od.clear() -> None. Remove all items from od.N)rvaluesrclearrdict)rnoderrrr=szIOrderedDict.clearNcCs||kr||S|S)Nr)rr#defaultrrrr*szIOrderedDict.getTcCs6|s tdt|rt|nt|}||}||fS)zod.popitem() -> (k, v), return and remove a (key, value) pair. Pairs are returned in LIFO order if last is true or FIFO order if false. zdictionary is empty)KeyErrornextreversediterr')rr%r#r$rrrpopitems  zIOrderedDict.popitemcCs*|sd|jjfSd|jjt|fS)zod.__repr__() <==> repr(od)z%s()z%s(%r))r7rlistr8)rrrr__repr__szIOrderedDict.__repr__cCs ||S)z!od.copy() -> a shallow copy of od)r7)rrrrr6szIOrderedDict.copycCs |}x|D] }|||<q W|S)zOD.fromkeys(S[, v]) -> New ordered dictionary with keys from S and values equal to v (which defaults to None). r)clsiterabler$dr#rrrfromkeyss  zIOrderedDict.fromkeyscCs>t|tr2t|t|ko0t|t|kSt||S)zod.__eq__(y) <==> od==y. Comparison to another OD is order-sensitive while comparison to a regular mapping is order-insensitive. ) isinstancerrsetr8r>__eq__)rotherrrrrNs zIOrderedDict.__eq__cCs |dS)N)r=)rrrr__del__szIOrderedDict.__del__)rr-)rr-)N)T)N)rrr__doc__r!r>r&r)r+r,r0r1r;r=r*r setdefaultrr'keysr<r8__ne__rErGr6 classmethodrKrNrPrrrrr=s2        rContinuezSwitching ProtocolsZ ProcessingOKZCreatedZAcceptedzNon Authoritative Informationz No Contentz Reset ContentzPartial Contentz Multi StatuszIM UsedzMultiple ChoiceszMoved PermanentlyZFoundz See Otherz Not Modifiedz Use ProxyzTemporary Redirectz Bad RequestZ UnauthorizedzPayment RequiredZ Forbiddenz Not FoundzMethod Not AllowedzNot AcceptablezProxy Authentication RequiredzRequest TimeoutZConflictZGonezLength RequiredzPrecondition FailedzRequest Entity Too LargezRequest URI Too LongzUnsupported Media TypezRequested Range Not SatisfiablezExpectation FailedzUnprocessable EntityZLockedzFailed DependencyzUpgrade RequiredzInternal Server ErrorzNot Implementedz Bad GatewayzService UnavailablezGateway TimeoutzHTTP Version Not SupportedzInsufficient Storagez Not Extended)1defi,i-i.i/i0i1i3iiiiiiiiiiiiiiiiiiiiiiiiiiiiii)syscollections.abcr ImportError collections version_info urllib.parserr r r Z string_typesioStringIOmaxsizeZMAXSIZEurllibZ basestringZ cStringIOBytesIOobjectr r OverflowErrorintr>rstatus_reasonsrrrrs  (http-parser-0.9.0/http_parser/_socketio.py0000644000076500000240000001004213642725626021435 0ustar benoitcstaff00000000000000""" socketio taken from the python3 stdlib """ import io import sys from socket import timeout, error, socket from errno import EINTR, EAGAIN, EWOULDBLOCK _blocking_errnos = EAGAIN, EWOULDBLOCK # python2.6 fixes def _recv_into_sock_py26(sock, buf): data = sock.recv(len(buf)) l = len(data) buf[:l] = data return l if sys.version_info < (2, 7, 0, 'final'): _recv_into_sock = _recv_into_sock_py26 else: _recv_into_sock = lambda sock, buf: sock.recv_into(buf) class SocketIO(io.RawIOBase): """Raw I/O implementation for stream sockets. This class supports the makefile() method on sockets. It provides the raw I/O interface on top of a socket object. """ # One might wonder why not let FileIO do the job instead. There are two # main reasons why FileIO is not adapted: # - it wouldn't work under Windows (where you can't used read() and # write() on a socket handle) # - it wouldn't work with socket timeouts (FileIO would ignore the # timeout and consider the socket non-blocking) # XXX More docs def __init__(self, sock, mode): if mode not in ("r", "w", "rw", "rb", "wb", "rwb"): raise ValueError("invalid mode: %r" % mode) io.RawIOBase.__init__(self) self._sock = sock if "b" not in mode: mode += "b" self._mode = mode self._reading = "r" in mode self._writing = "w" in mode self._timeout_occurred = False def readinto(self, b): """Read up to len(b) bytes into the writable buffer *b* and return the number of bytes read. If the socket is non-blocking and no bytes are available, None is returned. If *b* is non-empty, a 0 return value indicates that the connection was shutdown at the other end. """ self._checkClosed() self._checkReadable() if self._timeout_occurred: raise IOError("cannot read from timed out object") while True: try: return _recv_into_sock(self._sock, b) except timeout: self._timeout_occurred = True raise except error as e: n = e.args[0] if n == EINTR: continue if n in _blocking_errnos: return None raise def write(self, b): """Write the given bytes or bytearray object *b* to the socket and return the number of bytes written. This can be less than len(b) if not all data could be written. If the socket is non-blocking and no bytes could be written None is returned. """ self._checkClosed() self._checkWritable() try: return self._sock.send(b) except error as e: # XXX what about EINTR? if e.args[0] in _blocking_errnos: return None raise def readable(self): """True if the SocketIO is open for reading. """ return self._reading and not self.closed def writable(self): """True if the SocketIO is open for writing. """ return self._writing and not self.closed def fileno(self): """Return the file descriptor of the underlying socket. """ self._checkClosed() return self._sock.fileno() @property def name(self): if not self.closed: return self.fileno() else: return -1 @property def mode(self): return self._mode def close(self): """Close the SocketIO object. This doesn't close the underlying socket, except if all references to it have disappeared. """ if self.closed: return io.RawIOBase.close(self) self._sock = None def _checkClosed(self, msg=None): """Internal: raise an ValueError if file is closed """ if self.closed: raise ValueError("I/O operation on closed file." if msg is None else msg) http-parser-0.9.0/http_parser/http.py0000644000076500000240000001470413642725626020446 0ustar benoitcstaff00000000000000# -*- coding: utf-8 - # # This file is part of http-parser released under the MIT license. # See the NOTICE for more information. from io import DEFAULT_BUFFER_SIZE, BufferedReader, TextIOWrapper try: from http_parser.parser import HttpParser except ImportError: from http_parser.pyparser import HttpParser from http_parser.reader import HttpBodyReader from http_parser.util import status_reasons, bytes_to_str HTTP_BOTH = 2 HTTP_RESPONSE = 1 HTTP_REQUEST = 0 class NoMoreData(Exception): """ exception raised when trying to parse headers but we didn't get all data needed. """ class ParserError(Exception): """ error while parsing http request """ class BadStatusLine(Exception): """ error when status line is invalid """ class HttpStream(object): """ An HTTP parser providing higher-level access to a readable, sequential io.RawIOBase object. You can use implementions of http_parser.reader (IterReader, StringReader, SocketReader) or create your own. """ def __init__(self, stream, kind=HTTP_BOTH, decompress=False, parser_class=HttpParser): """ constructor of HttpStream. :attr stream: an io.RawIOBase object :attr kind: Int, could be 0 to parseonly requests, 1 to parse only responses or 2 if we want to let the parser detect the type. """ self.parser = parser_class(kind=kind, decompress=decompress) self.stream = stream def _check_headers_complete(self): if self.parser.is_headers_complete(): return while True: try: next(self) except StopIteration: if self.parser.is_headers_complete(): return raise NoMoreData("Can't parse headers") if self.parser.is_headers_complete(): return def _wait_status_line(self, cond): if self.parser.is_headers_complete(): return True data = [] if not cond(): while True: try: d = next(self) data.append(d) except StopIteration: if self.parser.is_headers_complete(): return True raise BadStatusLine(b"".join(data)) if cond(): return True return True def _wait_on_url(self): return self._wait_status_line(self.parser.get_url) def _wait_on_status(self): return self._wait_status_line(self.parser.get_status_code) def _wait_on_method(self): return self._wait_status_line(self.parser.get_method) def url(self): """ get full url of the request """ self._wait_on_url() return self.parser.get_url() def path(self): """ get path of the request (url without query string and fragment """ self._wait_on_url() return self.parser.get_path() def query_string(self): """ get query string of the url """ self._wait_on_url() return self.parser.get_query_string() def fragment(self): """ get fragment of the url """ self._wait_on_url() return self.parser.get_fragment() def version(self): self._wait_on_status() return self.parser.get_version() def status_code(self): """ get status code of a response as integer """ self._wait_on_status() return self.parser.get_status_code() def status(self): """ return complete status with reason """ status_code = self.status_code() reason = status_reasons.get(int(status_code), 'unknown') return "%s %s" % (status_code, reason) def method(self): """ get HTTP method as string""" self._wait_on_method() return self.parser.get_method() def headers(self): """ get request/response headers, headers are returned in a OrderedDict that allows you to get value using insensitive keys.""" self._check_headers_complete() headers = self.parser.get_headers() return headers.copy() def should_keep_alive(self): """ return True if the connection should be kept alive """ self._check_headers_complete() return self.parser.should_keep_alive() def is_chunked(self): """ return True if Transfer-Encoding header value is chunked""" self._check_headers_complete() return self.parser.is_chunked() def wsgi_environ(self, initial=None): """ get WSGI environ based on the current request. :attr initial: dict, initial values to fill in environ. """ self._check_headers_complete() return self.parser.get_wsgi_environ() def body_file(self, buffering=None, binary=True, encoding=None, errors=None, newline=None): """ return the body as a buffered stream object. If binary is true an io.BufferedReader will be returned, else an io.TextIOWrapper. """ self._check_headers_complete() if buffering is None: buffering = -1 if buffering < 0: buffering = DEFAULT_BUFFER_SIZE raw = HttpBodyReader(self) buf = BufferedReader(raw, buffering) if binary: return buf text = TextIOWrapper(buf, encoding, errors, newline) return text def body_string(self, binary=True, encoding=None, errors=None, newline=None): """ return body as string """ return self.body_file(binary=binary, encoding=encoding, newline=newline).read() def __iter__(self): return self def __next__(self): if self.parser.is_message_complete(): raise StopIteration # fetch data b = bytearray(DEFAULT_BUFFER_SIZE) # if a nonblocking socket is used # then pep 3116 demands read/readinto to return 0 recved = self.stream.readinto(b) if recved is None: raise IOError('nonblocking socket used in blocking code') del b[recved:] to_parse = bytes(b) # parse data nparsed = self.parser.execute(to_parse, recved) if nparsed != recved and not self.parser.is_message_complete(): raise ParserError("nparsed != recved (%s != %s) [%s]" % (nparsed, recved, bytes_to_str(to_parse))) if recved == 0: raise StopIteration return to_parse next = __next__ http-parser-0.9.0/http_parser/http_parser.c0000644000076500000240000017074413642725626021623 0ustar benoitcstaff00000000000000/* Based on src/http/ngx_http_parse.c from NGINX copyright Igor Sysoev * * Additional changes are licensed under the same terms as NGINX and * copyright Joyent, Inc. and other Node contributors. All rights reserved. * * 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. */ #include "http_parser.h" #include #include #include #include #include #include #ifndef ULLONG_MAX # define ULLONG_MAX ((uint64_t) -1) /* 2^64-1 */ #endif #ifndef MIN # define MIN(a,b) ((a) < (b) ? (a) : (b)) #endif #ifndef ARRAY_SIZE # define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0])) #endif #ifndef BIT_AT # define BIT_AT(a, i) \ (!!((unsigned int) (a)[(unsigned int) (i) >> 3] & \ (1 << ((unsigned int) (i) & 7)))) #endif #ifndef ELEM_AT # define ELEM_AT(a, i, v) ((unsigned int) (i) < ARRAY_SIZE(a) ? (a)[(i)] : (v)) #endif #define SET_ERRNO(e) \ do { \ parser->http_errno = (e); \ } while(0) /* Run the notify callback FOR, returning ER if it fails */ #define CALLBACK_NOTIFY_(FOR, ER) \ do { \ assert(HTTP_PARSER_ERRNO(parser) == HPE_OK); \ \ if (settings->on_##FOR) { \ if (0 != settings->on_##FOR(parser)) { \ SET_ERRNO(HPE_CB_##FOR); \ } \ \ /* We either errored above or got paused; get out */ \ if (HTTP_PARSER_ERRNO(parser) != HPE_OK) { \ return (ER); \ } \ } \ } while (0) /* Run the notify callback FOR and consume the current byte */ #define CALLBACK_NOTIFY(FOR) CALLBACK_NOTIFY_(FOR, p - data + 1) /* Run the notify callback FOR and don't consume the current byte */ #define CALLBACK_NOTIFY_NOADVANCE(FOR) CALLBACK_NOTIFY_(FOR, p - data) /* Run data callback FOR with LEN bytes, returning ER if it fails */ #define CALLBACK_DATA_(FOR, LEN, ER) \ do { \ assert(HTTP_PARSER_ERRNO(parser) == HPE_OK); \ \ if (FOR##_mark) { \ if (settings->on_##FOR) { \ if (0 != settings->on_##FOR(parser, FOR##_mark, (LEN))) { \ SET_ERRNO(HPE_CB_##FOR); \ } \ \ /* We either errored above or got paused; get out */ \ if (HTTP_PARSER_ERRNO(parser) != HPE_OK) { \ return (ER); \ } \ } \ FOR##_mark = NULL; \ } \ } while (0) /* Run the data callback FOR and consume the current byte */ #define CALLBACK_DATA(FOR) \ CALLBACK_DATA_(FOR, p - FOR##_mark, p - data + 1) /* Run the data callback FOR and don't consume the current byte */ #define CALLBACK_DATA_NOADVANCE(FOR) \ CALLBACK_DATA_(FOR, p - FOR##_mark, p - data) /* Set the mark FOR; non-destructive if mark is already set */ #define MARK(FOR) \ do { \ if (!FOR##_mark) { \ FOR##_mark = p; \ } \ } while (0) #define PROXY_CONNECTION "proxy-connection" #define CONNECTION "connection" #define CONTENT_LENGTH "content-length" #define TRANSFER_ENCODING "transfer-encoding" #define UPGRADE "upgrade" #define CHUNKED "chunked" #define KEEP_ALIVE "keep-alive" #define CLOSE "close" static const char *method_strings[] = { #define XX(num, name, string) #string, HTTP_METHOD_MAP(XX) #undef XX }; /* Tokens as defined by rfc 2616. Also lowercases them. * token = 1* * separators = "(" | ")" | "<" | ">" | "@" * | "," | ";" | ":" | "\" | <"> * | "/" | "[" | "]" | "?" | "=" * | "{" | "}" | SP | HT */ static const char tokens[256] = { /* 0 nul 1 soh 2 stx 3 etx 4 eot 5 enq 6 ack 7 bel */ 0, 0, 0, 0, 0, 0, 0, 0, /* 8 bs 9 ht 10 nl 11 vt 12 np 13 cr 14 so 15 si */ 0, 0, 0, 0, 0, 0, 0, 0, /* 16 dle 17 dc1 18 dc2 19 dc3 20 dc4 21 nak 22 syn 23 etb */ 0, 0, 0, 0, 0, 0, 0, 0, /* 24 can 25 em 26 sub 27 esc 28 fs 29 gs 30 rs 31 us */ 0, 0, 0, 0, 0, 0, 0, 0, /* 32 sp 33 ! 34 " 35 # 36 $ 37 % 38 & 39 ' */ 0, '!', 0, '#', '$', '%', '&', '\'', /* 40 ( 41 ) 42 * 43 + 44 , 45 - 46 . 47 / */ 0, 0, '*', '+', 0, '-', '.', 0, /* 48 0 49 1 50 2 51 3 52 4 53 5 54 6 55 7 */ '0', '1', '2', '3', '4', '5', '6', '7', /* 56 8 57 9 58 : 59 ; 60 < 61 = 62 > 63 ? */ '8', '9', 0, 0, 0, 0, 0, 0, /* 64 @ 65 A 66 B 67 C 68 D 69 E 70 F 71 G */ 0, 'a', 'b', 'c', 'd', 'e', 'f', 'g', /* 72 H 73 I 74 J 75 K 76 L 77 M 78 N 79 O */ 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', /* 80 P 81 Q 82 R 83 S 84 T 85 U 86 V 87 W */ 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', /* 88 X 89 Y 90 Z 91 [ 92 \ 93 ] 94 ^ 95 _ */ 'x', 'y', 'z', 0, 0, 0, '^', '_', /* 96 ` 97 a 98 b 99 c 100 d 101 e 102 f 103 g */ '`', 'a', 'b', 'c', 'd', 'e', 'f', 'g', /* 104 h 105 i 106 j 107 k 108 l 109 m 110 n 111 o */ 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', /* 112 p 113 q 114 r 115 s 116 t 117 u 118 v 119 w */ 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', /* 120 x 121 y 122 z 123 { 124 | 125 } 126 ~ 127 del */ 'x', 'y', 'z', 0, '|', 0, '~', 0 }; static const int8_t unhex[256] = {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 , 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,-1,-1,-1,-1,-1,-1 ,-1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1 ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 ,-1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1 ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 }; #if HTTP_PARSER_STRICT # define T(v) 0 #else # define T(v) v #endif static const uint8_t normal_url_char[32] = { /* 0 nul 1 soh 2 stx 3 etx 4 eot 5 enq 6 ack 7 bel */ 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0, /* 8 bs 9 ht 10 nl 11 vt 12 np 13 cr 14 so 15 si */ 0 | T(2) | 0 | 0 | T(16) | 0 | 0 | 0, /* 16 dle 17 dc1 18 dc2 19 dc3 20 dc4 21 nak 22 syn 23 etb */ 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0, /* 24 can 25 em 26 sub 27 esc 28 fs 29 gs 30 rs 31 us */ 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0, /* 32 sp 33 ! 34 " 35 # 36 $ 37 % 38 & 39 ' */ 0 | 2 | 4 | 0 | 16 | 32 | 64 | 128, /* 40 ( 41 ) 42 * 43 + 44 , 45 - 46 . 47 / */ 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128, /* 48 0 49 1 50 2 51 3 52 4 53 5 54 6 55 7 */ 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128, /* 56 8 57 9 58 : 59 ; 60 < 61 = 62 > 63 ? */ 1 | 2 | 4 | 8 | 16 | 32 | 64 | 0, /* 64 @ 65 A 66 B 67 C 68 D 69 E 70 F 71 G */ 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128, /* 72 H 73 I 74 J 75 K 76 L 77 M 78 N 79 O */ 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128, /* 80 P 81 Q 82 R 83 S 84 T 85 U 86 V 87 W */ 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128, /* 88 X 89 Y 90 Z 91 [ 92 \ 93 ] 94 ^ 95 _ */ 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128, /* 96 ` 97 a 98 b 99 c 100 d 101 e 102 f 103 g */ 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128, /* 104 h 105 i 106 j 107 k 108 l 109 m 110 n 111 o */ 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128, /* 112 p 113 q 114 r 115 s 116 t 117 u 118 v 119 w */ 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128, /* 120 x 121 y 122 z 123 { 124 | 125 } 126 ~ 127 del */ 1 | 2 | 4 | 8 | 16 | 32 | 64 | 0, }; #undef T enum state { s_dead = 1 /* important that this is > 0 */ , s_start_req_or_res , s_res_or_resp_H , s_start_res , s_res_H , s_res_HT , s_res_HTT , s_res_HTTP , s_res_first_http_major , s_res_http_major , s_res_first_http_minor , s_res_http_minor , s_res_first_status_code , s_res_status_code , s_res_status , s_res_line_almost_done , s_start_req , s_req_method , s_req_spaces_before_url , s_req_schema , s_req_schema_slash , s_req_schema_slash_slash , s_req_server_start , s_req_server , s_req_server_with_at , s_req_path , s_req_query_string_start , s_req_query_string , s_req_fragment_start , s_req_fragment , s_req_http_start , s_req_http_H , s_req_http_HT , s_req_http_HTT , s_req_http_HTTP , s_req_first_http_major , s_req_http_major , s_req_first_http_minor , s_req_http_minor , s_req_line_almost_done , s_header_field_start , s_header_field , s_header_value_start , s_header_value , s_header_value_lws , s_header_almost_done , s_chunk_size_start , s_chunk_size , s_chunk_parameters , s_chunk_size_almost_done , s_headers_almost_done , s_headers_done /* Important: 's_headers_done' must be the last 'header' state. All * states beyond this must be 'body' states. It is used for overflow * checking. See the PARSING_HEADER() macro. */ , s_chunk_data , s_chunk_data_almost_done , s_chunk_data_done , s_body_identity , s_body_identity_eof , s_message_done }; #define PARSING_HEADER(state) (state <= s_headers_done) enum header_states { h_general = 0 , h_C , h_CO , h_CON , h_matching_connection , h_matching_proxy_connection , h_matching_content_length , h_matching_transfer_encoding , h_matching_upgrade , h_connection , h_content_length , h_transfer_encoding , h_upgrade , h_matching_transfer_encoding_chunked , h_matching_connection_keep_alive , h_matching_connection_close , h_transfer_encoding_chunked , h_connection_keep_alive , h_connection_close }; enum http_host_state { s_http_host_dead = 1 , s_http_userinfo_start , s_http_userinfo , s_http_host_start , s_http_host_v6_start , s_http_host , s_http_host_v6 , s_http_host_v6_end , s_http_host_port_start , s_http_host_port }; /* Macros for character classes; depends on strict-mode */ #define CR '\r' #define LF '\n' #define LOWER(c) (unsigned char)(c | 0x20) #define IS_ALPHA(c) (LOWER(c) >= 'a' && LOWER(c) <= 'z') #define IS_NUM(c) ((c) >= '0' && (c) <= '9') #define IS_ALPHANUM(c) (IS_ALPHA(c) || IS_NUM(c)) #define IS_HEX(c) (IS_NUM(c) || (LOWER(c) >= 'a' && LOWER(c) <= 'f')) #define IS_MARK(c) ((c) == '-' || (c) == '_' || (c) == '.' || \ (c) == '!' || (c) == '~' || (c) == '*' || (c) == '\'' || (c) == '(' || \ (c) == ')') #define IS_USERINFO_CHAR(c) (IS_ALPHANUM(c) || IS_MARK(c) || (c) == '%' || \ (c) == ';' || (c) == ':' || (c) == '&' || (c) == '=' || (c) == '+' || \ (c) == '$' || (c) == ',') #if HTTP_PARSER_STRICT #define TOKEN(c) (tokens[(unsigned char)c]) #define IS_URL_CHAR(c) (BIT_AT(normal_url_char, (unsigned char)c)) #define IS_HOST_CHAR(c) (IS_ALPHANUM(c) || (c) == '.' || (c) == '-') #else #define TOKEN(c) ((c == ' ') ? ' ' : tokens[(unsigned char)c]) #define IS_URL_CHAR(c) \ (BIT_AT(normal_url_char, (unsigned char)c) || ((c) & 0x80)) #define IS_HOST_CHAR(c) \ (IS_ALPHANUM(c) || (c) == '.' || (c) == '-' || (c) == '_') #endif #define start_state (parser->type == HTTP_REQUEST ? s_start_req : s_start_res) #if HTTP_PARSER_STRICT # define STRICT_CHECK(cond) \ do { \ if (cond) { \ SET_ERRNO(HPE_STRICT); \ goto error; \ } \ } while (0) # define NEW_MESSAGE() (http_should_keep_alive(parser) ? start_state : s_dead) #else # define STRICT_CHECK(cond) # define NEW_MESSAGE() start_state #endif /* Map errno values to strings for human-readable output */ #define HTTP_STRERROR_GEN(n, s) { "HPE_" #n, s }, static struct { const char *name; const char *description; } http_strerror_tab[] = { HTTP_ERRNO_MAP(HTTP_STRERROR_GEN) }; #undef HTTP_STRERROR_GEN int http_message_needs_eof(const http_parser *parser); /* Our URL parser. * * This is designed to be shared by http_parser_execute() for URL validation, * hence it has a state transition + byte-for-byte interface. In addition, it * is meant to be embedded in http_parser_parse_url(), which does the dirty * work of turning state transitions URL components for its API. * * This function should only be invoked with non-space characters. It is * assumed that the caller cares about (and can detect) the transition between * URL and non-URL states by looking for these. */ static enum state parse_url_char(enum state s, const char ch) { if (ch == ' ' || ch == '\r' || ch == '\n') { return s_dead; } #if HTTP_PARSER_STRICT if (ch == '\t' || ch == '\f') { return s_dead; } #endif switch (s) { case s_req_spaces_before_url: /* Proxied requests are followed by scheme of an absolute URI (alpha). * All methods except CONNECT are followed by '/' or '*'. */ if (ch == '/' || ch == '*') { return s_req_path; } if (IS_ALPHA(ch)) { return s_req_schema; } break; case s_req_schema: if (IS_ALPHA(ch)) { return s; } if (ch == ':') { return s_req_schema_slash; } break; case s_req_schema_slash: if (ch == '/') { return s_req_schema_slash_slash; } break; case s_req_schema_slash_slash: if (ch == '/') { return s_req_server_start; } break; case s_req_server_with_at: if (ch == '@') { return s_dead; } /* FALLTHROUGH */ case s_req_server_start: case s_req_server: if (ch == '/') { return s_req_path; } if (ch == '?') { return s_req_query_string_start; } if (ch == '@') { return s_req_server_with_at; } if (IS_USERINFO_CHAR(ch) || ch == '[' || ch == ']') { return s_req_server; } break; case s_req_path: if (IS_URL_CHAR(ch)) { return s; } switch (ch) { case '?': return s_req_query_string_start; case '#': return s_req_fragment_start; } break; case s_req_query_string_start: case s_req_query_string: if (IS_URL_CHAR(ch)) { return s_req_query_string; } switch (ch) { case '?': /* allow extra '?' in query string */ return s_req_query_string; case '#': return s_req_fragment_start; } break; case s_req_fragment_start: if (IS_URL_CHAR(ch)) { return s_req_fragment; } switch (ch) { case '?': return s_req_fragment; case '#': return s; } break; case s_req_fragment: if (IS_URL_CHAR(ch)) { return s; } switch (ch) { case '?': case '#': return s; } break; default: break; } /* We should never fall out of the switch above unless there's an error */ return s_dead; } size_t http_parser_execute (http_parser *parser, const http_parser_settings *settings, const char *data, size_t len) { char c, ch; int8_t unhex_val; const char *p = data; const char *header_field_mark = 0; const char *header_value_mark = 0; const char *url_mark = 0; const char *body_mark = 0; /* We're in an error state. Don't bother doing anything. */ if (HTTP_PARSER_ERRNO(parser) != HPE_OK) { return 0; } if (len == 0) { switch (parser->state) { case s_body_identity_eof: /* Use of CALLBACK_NOTIFY() here would erroneously return 1 byte read if * we got paused. */ CALLBACK_NOTIFY_NOADVANCE(message_complete); return 0; case s_dead: case s_start_req_or_res: case s_start_res: case s_start_req: return 0; default: SET_ERRNO(HPE_INVALID_EOF_STATE); return 1; } } if (parser->state == s_header_field) header_field_mark = data; if (parser->state == s_header_value) header_value_mark = data; switch (parser->state) { case s_req_path: case s_req_schema: case s_req_schema_slash: case s_req_schema_slash_slash: case s_req_server_start: case s_req_server: case s_req_server_with_at: case s_req_query_string_start: case s_req_query_string: case s_req_fragment_start: case s_req_fragment: url_mark = data; break; } for (p=data; p != data + len; p++) { ch = *p; if (PARSING_HEADER(parser->state)) { ++parser->nread; /* Buffer overflow attack */ if (parser->nread > HTTP_MAX_HEADER_SIZE) { SET_ERRNO(HPE_HEADER_OVERFLOW); goto error; } } reexecute_byte: switch (parser->state) { case s_dead: /* this state is used after a 'Connection: close' message * the parser will error out if it reads another message */ if (ch == CR || ch == LF) break; SET_ERRNO(HPE_CLOSED_CONNECTION); goto error; case s_start_req_or_res: { if (ch == CR || ch == LF) break; parser->flags = 0; parser->content_length = ULLONG_MAX; if (ch == 'H') { parser->state = s_res_or_resp_H; CALLBACK_NOTIFY(message_begin); } else { parser->type = HTTP_REQUEST; parser->state = s_start_req; goto reexecute_byte; } break; } case s_res_or_resp_H: if (ch == 'T') { parser->type = HTTP_RESPONSE; parser->state = s_res_HT; } else { if (ch != 'E') { SET_ERRNO(HPE_INVALID_CONSTANT); goto error; } parser->type = HTTP_REQUEST; parser->method = HTTP_HEAD; parser->index = 2; parser->state = s_req_method; } break; case s_start_res: { parser->flags = 0; parser->content_length = ULLONG_MAX; switch (ch) { case 'H': parser->state = s_res_H; break; case CR: case LF: break; default: SET_ERRNO(HPE_INVALID_CONSTANT); goto error; } CALLBACK_NOTIFY(message_begin); break; } case s_res_H: STRICT_CHECK(ch != 'T'); parser->state = s_res_HT; break; case s_res_HT: STRICT_CHECK(ch != 'T'); parser->state = s_res_HTT; break; case s_res_HTT: STRICT_CHECK(ch != 'P'); parser->state = s_res_HTTP; break; case s_res_HTTP: STRICT_CHECK(ch != '/'); parser->state = s_res_first_http_major; break; case s_res_first_http_major: if (ch < '0' || ch > '9') { SET_ERRNO(HPE_INVALID_VERSION); goto error; } parser->http_major = ch - '0'; parser->state = s_res_http_major; break; /* major HTTP version or dot */ case s_res_http_major: { if (ch == '.') { parser->state = s_res_first_http_minor; break; } if (!IS_NUM(ch)) { SET_ERRNO(HPE_INVALID_VERSION); goto error; } parser->http_major *= 10; parser->http_major += ch - '0'; if (parser->http_major > 999) { SET_ERRNO(HPE_INVALID_VERSION); goto error; } break; } /* first digit of minor HTTP version */ case s_res_first_http_minor: if (!IS_NUM(ch)) { SET_ERRNO(HPE_INVALID_VERSION); goto error; } parser->http_minor = ch - '0'; parser->state = s_res_http_minor; break; /* minor HTTP version or end of request line */ case s_res_http_minor: { if (ch == ' ') { parser->state = s_res_first_status_code; break; } if (!IS_NUM(ch)) { SET_ERRNO(HPE_INVALID_VERSION); goto error; } parser->http_minor *= 10; parser->http_minor += ch - '0'; if (parser->http_minor > 999) { SET_ERRNO(HPE_INVALID_VERSION); goto error; } break; } case s_res_first_status_code: { if (!IS_NUM(ch)) { if (ch == ' ') { break; } SET_ERRNO(HPE_INVALID_STATUS); goto error; } parser->status_code = ch - '0'; parser->state = s_res_status_code; break; } case s_res_status_code: { if (!IS_NUM(ch)) { switch (ch) { case ' ': parser->state = s_res_status; break; case CR: parser->state = s_res_line_almost_done; break; case LF: parser->state = s_header_field_start; break; default: SET_ERRNO(HPE_INVALID_STATUS); goto error; } break; } parser->status_code *= 10; parser->status_code += ch - '0'; if (parser->status_code > 999) { SET_ERRNO(HPE_INVALID_STATUS); goto error; } break; } case s_res_status: /* the human readable status. e.g. "NOT FOUND" * we are not humans so just ignore this */ if (ch == CR) { parser->state = s_res_line_almost_done; break; } if (ch == LF) { parser->state = s_header_field_start; break; } break; case s_res_line_almost_done: STRICT_CHECK(ch != LF); parser->state = s_header_field_start; CALLBACK_NOTIFY(status_complete); break; case s_start_req: { if (ch == CR || ch == LF) break; parser->flags = 0; parser->content_length = ULLONG_MAX; if (!IS_ALPHA(ch)) { SET_ERRNO(HPE_INVALID_METHOD); goto error; } parser->method = (enum http_method) 0; parser->index = 1; switch (ch) { case 'C': parser->method = HTTP_CONNECT; /* or COPY, CHECKOUT */ break; case 'D': parser->method = HTTP_DELETE; break; case 'G': parser->method = HTTP_GET; break; case 'H': parser->method = HTTP_HEAD; break; case 'L': parser->method = HTTP_LOCK; break; case 'M': parser->method = HTTP_MKCOL; /* or MOVE, MKACTIVITY, MERGE, M-SEARCH */ break; case 'N': parser->method = HTTP_NOTIFY; break; case 'O': parser->method = HTTP_OPTIONS; break; case 'P': parser->method = HTTP_POST; /* or PROPFIND|PROPPATCH|PUT|PATCH|PURGE */ break; case 'R': parser->method = HTTP_REPORT; break; case 'S': parser->method = HTTP_SUBSCRIBE; /* or SEARCH */ break; case 'T': parser->method = HTTP_TRACE; break; case 'U': parser->method = HTTP_UNLOCK; /* or UNSUBSCRIBE */ break; default: SET_ERRNO(HPE_INVALID_METHOD); goto error; } parser->state = s_req_method; CALLBACK_NOTIFY(message_begin); break; } case s_req_method: { const char *matcher; if (ch == '\0') { SET_ERRNO(HPE_INVALID_METHOD); goto error; } matcher = method_strings[parser->method]; if (ch == ' ' && matcher[parser->index] == '\0') { parser->state = s_req_spaces_before_url; } else if (ch == matcher[parser->index]) { ; /* nada */ } else if (parser->method == HTTP_CONNECT) { if (parser->index == 1 && ch == 'H') { parser->method = HTTP_CHECKOUT; } else if (parser->index == 2 && ch == 'P') { parser->method = HTTP_COPY; } else { SET_ERRNO(HPE_INVALID_METHOD); goto error; } } else if (parser->method == HTTP_MKCOL) { if (parser->index == 1 && ch == 'O') { parser->method = HTTP_MOVE; } else if (parser->index == 1 && ch == 'E') { parser->method = HTTP_MERGE; } else if (parser->index == 1 && ch == '-') { parser->method = HTTP_MSEARCH; } else if (parser->index == 2 && ch == 'A') { parser->method = HTTP_MKACTIVITY; } else { SET_ERRNO(HPE_INVALID_METHOD); goto error; } } else if (parser->method == HTTP_SUBSCRIBE) { if (parser->index == 1 && ch == 'E') { parser->method = HTTP_SEARCH; } else { SET_ERRNO(HPE_INVALID_METHOD); goto error; } } else if (parser->index == 1 && parser->method == HTTP_POST) { if (ch == 'R') { parser->method = HTTP_PROPFIND; /* or HTTP_PROPPATCH */ } else if (ch == 'U') { parser->method = HTTP_PUT; /* or HTTP_PURGE */ } else if (ch == 'A') { parser->method = HTTP_PATCH; } else { SET_ERRNO(HPE_INVALID_METHOD); goto error; } } else if (parser->index == 2) { if (parser->method == HTTP_PUT) { if (ch == 'R') { parser->method = HTTP_PURGE; } else { SET_ERRNO(HPE_INVALID_METHOD); goto error; } } else if (parser->method == HTTP_UNLOCK) { if (ch == 'S') { parser->method = HTTP_UNSUBSCRIBE; } else { SET_ERRNO(HPE_INVALID_METHOD); goto error; } } else { SET_ERRNO(HPE_INVALID_METHOD); goto error; } } else if (parser->index == 4 && parser->method == HTTP_PROPFIND && ch == 'P') { parser->method = HTTP_PROPPATCH; } else { SET_ERRNO(HPE_INVALID_METHOD); goto error; } ++parser->index; break; } case s_req_spaces_before_url: { if (ch == ' ') break; MARK(url); if (parser->method == HTTP_CONNECT) { parser->state = s_req_server_start; } parser->state = parse_url_char((enum state)parser->state, ch); if (parser->state == s_dead) { SET_ERRNO(HPE_INVALID_URL); goto error; } break; } case s_req_schema: case s_req_schema_slash: case s_req_schema_slash_slash: case s_req_server_start: { switch (ch) { /* No whitespace allowed here */ case ' ': case CR: case LF: SET_ERRNO(HPE_INVALID_URL); goto error; default: parser->state = parse_url_char((enum state)parser->state, ch); if (parser->state == s_dead) { SET_ERRNO(HPE_INVALID_URL); goto error; } } break; } case s_req_server: case s_req_server_with_at: case s_req_path: case s_req_query_string_start: case s_req_query_string: case s_req_fragment_start: case s_req_fragment: { switch (ch) { case ' ': parser->state = s_req_http_start; CALLBACK_DATA(url); break; case CR: case LF: parser->http_major = 0; parser->http_minor = 9; parser->state = (ch == CR) ? s_req_line_almost_done : s_header_field_start; CALLBACK_DATA(url); break; default: parser->state = parse_url_char((enum state)parser->state, ch); if (parser->state == s_dead) { SET_ERRNO(HPE_INVALID_URL); goto error; } } break; } case s_req_http_start: switch (ch) { case 'H': parser->state = s_req_http_H; break; case ' ': break; default: SET_ERRNO(HPE_INVALID_CONSTANT); goto error; } break; case s_req_http_H: STRICT_CHECK(ch != 'T'); parser->state = s_req_http_HT; break; case s_req_http_HT: STRICT_CHECK(ch != 'T'); parser->state = s_req_http_HTT; break; case s_req_http_HTT: STRICT_CHECK(ch != 'P'); parser->state = s_req_http_HTTP; break; case s_req_http_HTTP: STRICT_CHECK(ch != '/'); parser->state = s_req_first_http_major; break; /* first digit of major HTTP version */ case s_req_first_http_major: if (ch < '1' || ch > '9') { SET_ERRNO(HPE_INVALID_VERSION); goto error; } parser->http_major = ch - '0'; parser->state = s_req_http_major; break; /* major HTTP version or dot */ case s_req_http_major: { if (ch == '.') { parser->state = s_req_first_http_minor; break; } if (!IS_NUM(ch)) { SET_ERRNO(HPE_INVALID_VERSION); goto error; } parser->http_major *= 10; parser->http_major += ch - '0'; if (parser->http_major > 999) { SET_ERRNO(HPE_INVALID_VERSION); goto error; } break; } /* first digit of minor HTTP version */ case s_req_first_http_minor: if (!IS_NUM(ch)) { SET_ERRNO(HPE_INVALID_VERSION); goto error; } parser->http_minor = ch - '0'; parser->state = s_req_http_minor; break; /* minor HTTP version or end of request line */ case s_req_http_minor: { if (ch == CR) { parser->state = s_req_line_almost_done; break; } if (ch == LF) { parser->state = s_header_field_start; break; } /* XXX allow spaces after digit? */ if (!IS_NUM(ch)) { SET_ERRNO(HPE_INVALID_VERSION); goto error; } parser->http_minor *= 10; parser->http_minor += ch - '0'; if (parser->http_minor > 999) { SET_ERRNO(HPE_INVALID_VERSION); goto error; } break; } /* end of request line */ case s_req_line_almost_done: { if (ch != LF) { SET_ERRNO(HPE_LF_EXPECTED); goto error; } parser->state = s_header_field_start; break; } case s_header_field_start: { if (ch == CR) { parser->state = s_headers_almost_done; break; } if (ch == LF) { /* they might be just sending \n instead of \r\n so this would be * the second \n to denote the end of headers*/ parser->state = s_headers_almost_done; goto reexecute_byte; } c = TOKEN(ch); if (!c) { SET_ERRNO(HPE_INVALID_HEADER_TOKEN); goto error; } MARK(header_field); parser->index = 0; parser->state = s_header_field; switch (c) { case 'c': parser->header_state = h_C; break; case 'p': parser->header_state = h_matching_proxy_connection; break; case 't': parser->header_state = h_matching_transfer_encoding; break; case 'u': parser->header_state = h_matching_upgrade; break; default: parser->header_state = h_general; break; } break; } case s_header_field: { c = TOKEN(ch); if (c) { switch (parser->header_state) { case h_general: break; case h_C: parser->index++; parser->header_state = (c == 'o' ? h_CO : h_general); break; case h_CO: parser->index++; parser->header_state = (c == 'n' ? h_CON : h_general); break; case h_CON: parser->index++; switch (c) { case 'n': parser->header_state = h_matching_connection; break; case 't': parser->header_state = h_matching_content_length; break; default: parser->header_state = h_general; break; } break; /* connection */ case h_matching_connection: parser->index++; if (parser->index > sizeof(CONNECTION)-1 || c != CONNECTION[parser->index]) { parser->header_state = h_general; } else if (parser->index == sizeof(CONNECTION)-2) { parser->header_state = h_connection; } break; /* proxy-connection */ case h_matching_proxy_connection: parser->index++; if (parser->index > sizeof(PROXY_CONNECTION)-1 || c != PROXY_CONNECTION[parser->index]) { parser->header_state = h_general; } else if (parser->index == sizeof(PROXY_CONNECTION)-2) { parser->header_state = h_connection; } break; /* content-length */ case h_matching_content_length: parser->index++; if (parser->index > sizeof(CONTENT_LENGTH)-1 || c != CONTENT_LENGTH[parser->index]) { parser->header_state = h_general; } else if (parser->index == sizeof(CONTENT_LENGTH)-2) { parser->header_state = h_content_length; } break; /* transfer-encoding */ case h_matching_transfer_encoding: parser->index++; if (parser->index > sizeof(TRANSFER_ENCODING)-1 || c != TRANSFER_ENCODING[parser->index]) { parser->header_state = h_general; } else if (parser->index == sizeof(TRANSFER_ENCODING)-2) { parser->header_state = h_transfer_encoding; } break; /* upgrade */ case h_matching_upgrade: parser->index++; if (parser->index > sizeof(UPGRADE)-1 || c != UPGRADE[parser->index]) { parser->header_state = h_general; } else if (parser->index == sizeof(UPGRADE)-2) { parser->header_state = h_upgrade; } break; case h_connection: case h_content_length: case h_transfer_encoding: case h_upgrade: if (ch != ' ') parser->header_state = h_general; break; default: assert(0 && "Unknown header_state"); break; } break; } if (ch == ':') { parser->state = s_header_value_start; CALLBACK_DATA(header_field); break; } if (ch == CR) { parser->state = s_header_almost_done; CALLBACK_DATA(header_field); break; } if (ch == LF) { parser->state = s_header_field_start; CALLBACK_DATA(header_field); break; } SET_ERRNO(HPE_INVALID_HEADER_TOKEN); goto error; } case s_header_value_start: { if (ch == ' ' || ch == '\t') break; MARK(header_value); parser->state = s_header_value; parser->index = 0; if (ch == CR) { parser->header_state = h_general; parser->state = s_header_almost_done; CALLBACK_DATA(header_value); break; } if (ch == LF) { parser->state = s_header_field_start; CALLBACK_DATA(header_value); break; } c = LOWER(ch); switch (parser->header_state) { case h_upgrade: parser->flags |= F_UPGRADE; parser->header_state = h_general; break; case h_transfer_encoding: /* looking for 'Transfer-Encoding: chunked' */ if ('c' == c) { parser->header_state = h_matching_transfer_encoding_chunked; } else { parser->header_state = h_general; } break; case h_content_length: if (!IS_NUM(ch)) { SET_ERRNO(HPE_INVALID_CONTENT_LENGTH); goto error; } parser->content_length = ch - '0'; break; case h_connection: /* looking for 'Connection: keep-alive' */ if (c == 'k') { parser->header_state = h_matching_connection_keep_alive; /* looking for 'Connection: close' */ } else if (c == 'c') { parser->header_state = h_matching_connection_close; } else { parser->header_state = h_general; } break; default: parser->header_state = h_general; break; } break; } case s_header_value: { if (ch == CR) { parser->state = s_header_almost_done; CALLBACK_DATA(header_value); break; } if (ch == LF) { parser->state = s_header_almost_done; CALLBACK_DATA_NOADVANCE(header_value); goto reexecute_byte; } c = LOWER(ch); switch (parser->header_state) { case h_general: break; case h_connection: case h_transfer_encoding: assert(0 && "Shouldn't get here."); break; case h_content_length: { uint64_t t; if (ch == ' ') break; if (!IS_NUM(ch)) { SET_ERRNO(HPE_INVALID_CONTENT_LENGTH); goto error; } t = parser->content_length; t *= 10; t += ch - '0'; /* Overflow? */ if (t < parser->content_length || t == ULLONG_MAX) { SET_ERRNO(HPE_INVALID_CONTENT_LENGTH); goto error; } parser->content_length = t; break; } /* Transfer-Encoding: chunked */ case h_matching_transfer_encoding_chunked: parser->index++; if (parser->index > sizeof(CHUNKED)-1 || c != CHUNKED[parser->index]) { parser->header_state = h_general; } else if (parser->index == sizeof(CHUNKED)-2) { parser->header_state = h_transfer_encoding_chunked; } break; /* looking for 'Connection: keep-alive' */ case h_matching_connection_keep_alive: parser->index++; if (parser->index > sizeof(KEEP_ALIVE)-1 || c != KEEP_ALIVE[parser->index]) { parser->header_state = h_general; } else if (parser->index == sizeof(KEEP_ALIVE)-2) { parser->header_state = h_connection_keep_alive; } break; /* looking for 'Connection: close' */ case h_matching_connection_close: parser->index++; if (parser->index > sizeof(CLOSE)-1 || c != CLOSE[parser->index]) { parser->header_state = h_general; } else if (parser->index == sizeof(CLOSE)-2) { parser->header_state = h_connection_close; } break; case h_transfer_encoding_chunked: case h_connection_keep_alive: case h_connection_close: if (ch != ' ') parser->header_state = h_general; break; default: parser->state = s_header_value; parser->header_state = h_general; break; } break; } case s_header_almost_done: { STRICT_CHECK(ch != LF); parser->state = s_header_value_lws; switch (parser->header_state) { case h_connection_keep_alive: parser->flags |= F_CONNECTION_KEEP_ALIVE; break; case h_connection_close: parser->flags |= F_CONNECTION_CLOSE; break; case h_transfer_encoding_chunked: parser->flags |= F_CHUNKED; break; default: break; } break; } case s_header_value_lws: { if (ch == ' ' || ch == '\t') parser->state = s_header_value_start; else { parser->state = s_header_field_start; goto reexecute_byte; } break; } case s_headers_almost_done: { STRICT_CHECK(ch != LF); if (parser->flags & F_TRAILING) { /* End of a chunked request */ parser->state = NEW_MESSAGE(); CALLBACK_NOTIFY(message_complete); break; } parser->state = s_headers_done; /* Set this here so that on_headers_complete() callbacks can see it */ parser->upgrade = (parser->flags & F_UPGRADE || parser->method == HTTP_CONNECT); /* Here we call the headers_complete callback. This is somewhat * different than other callbacks because if the user returns 1, we * will interpret that as saying that this message has no body. This * is needed for the annoying case of receiving a response to a HEAD * request. * * We'd like to use CALLBACK_NOTIFY_NOADVANCE() here but we cannot, so * we have to simulate it by handling a change in errno below. */ if (settings->on_headers_complete) { switch (settings->on_headers_complete(parser)) { case 0: break; case 1: parser->flags |= F_SKIPBODY; break; default: SET_ERRNO(HPE_CB_headers_complete); return p - data; /* Error */ } } if (HTTP_PARSER_ERRNO(parser) != HPE_OK) { return p - data; } goto reexecute_byte; } case s_headers_done: { STRICT_CHECK(ch != LF); parser->nread = 0; /* Exit, the rest of the connect is in a different protocol. */ if (parser->upgrade) { parser->state = NEW_MESSAGE(); CALLBACK_NOTIFY(message_complete); return (p - data) + 1; } if (parser->flags & F_SKIPBODY) { parser->state = NEW_MESSAGE(); CALLBACK_NOTIFY(message_complete); } else if (parser->flags & F_CHUNKED) { /* chunked encoding - ignore Content-Length header */ parser->state = s_chunk_size_start; } else { if (parser->content_length == 0) { /* Content-Length header given but zero: Content-Length: 0\r\n */ parser->state = NEW_MESSAGE(); CALLBACK_NOTIFY(message_complete); } else if (parser->content_length != ULLONG_MAX) { /* Content-Length header given and non-zero */ parser->state = s_body_identity; } else { if (parser->type == HTTP_REQUEST || !http_message_needs_eof(parser)) { /* Assume content-length 0 - read the next */ parser->state = NEW_MESSAGE(); CALLBACK_NOTIFY(message_complete); } else { /* Read body until EOF */ parser->state = s_body_identity_eof; } } } break; } case s_body_identity: { uint64_t to_read = MIN(parser->content_length, (uint64_t) ((data + len) - p)); assert(parser->content_length != 0 && parser->content_length != ULLONG_MAX); /* The difference between advancing content_length and p is because * the latter will automaticaly advance on the next loop iteration. * Further, if content_length ends up at 0, we want to see the last * byte again for our message complete callback. */ MARK(body); parser->content_length -= to_read; p += to_read - 1; if (parser->content_length == 0) { parser->state = s_message_done; /* Mimic CALLBACK_DATA_NOADVANCE() but with one extra byte. * * The alternative to doing this is to wait for the next byte to * trigger the data callback, just as in every other case. The * problem with this is that this makes it difficult for the test * harness to distinguish between complete-on-EOF and * complete-on-length. It's not clear that this distinction is * important for applications, but let's keep it for now. */ CALLBACK_DATA_(body, p - body_mark + 1, p - data); goto reexecute_byte; } break; } /* read until EOF */ case s_body_identity_eof: MARK(body); p = data + len - 1; break; case s_message_done: parser->state = NEW_MESSAGE(); CALLBACK_NOTIFY(message_complete); break; case s_chunk_size_start: { assert(parser->nread == 1); assert(parser->flags & F_CHUNKED); unhex_val = unhex[(unsigned char)ch]; if (unhex_val == -1) { SET_ERRNO(HPE_INVALID_CHUNK_SIZE); goto error; } parser->content_length = unhex_val; parser->state = s_chunk_size; break; } case s_chunk_size: { uint64_t t; assert(parser->flags & F_CHUNKED); if (ch == CR) { parser->state = s_chunk_size_almost_done; break; } unhex_val = unhex[(unsigned char)ch]; if (unhex_val == -1) { if (ch == ';' || ch == ' ') { parser->state = s_chunk_parameters; break; } SET_ERRNO(HPE_INVALID_CHUNK_SIZE); goto error; } t = parser->content_length; t *= 16; t += unhex_val; /* Overflow? */ if (t < parser->content_length || t == ULLONG_MAX) { SET_ERRNO(HPE_INVALID_CONTENT_LENGTH); goto error; } parser->content_length = t; break; } case s_chunk_parameters: { assert(parser->flags & F_CHUNKED); /* just ignore this shit. TODO check for overflow */ if (ch == CR) { parser->state = s_chunk_size_almost_done; break; } break; } case s_chunk_size_almost_done: { assert(parser->flags & F_CHUNKED); STRICT_CHECK(ch != LF); parser->nread = 0; if (parser->content_length == 0) { parser->flags |= F_TRAILING; parser->state = s_header_field_start; } else { parser->state = s_chunk_data; } break; } case s_chunk_data: { uint64_t to_read = MIN(parser->content_length, (uint64_t) ((data + len) - p)); assert(parser->flags & F_CHUNKED); assert(parser->content_length != 0 && parser->content_length != ULLONG_MAX); /* See the explanation in s_body_identity for why the content * length and data pointers are managed this way. */ MARK(body); parser->content_length -= to_read; p += to_read - 1; if (parser->content_length == 0) { parser->state = s_chunk_data_almost_done; } break; } case s_chunk_data_almost_done: assert(parser->flags & F_CHUNKED); assert(parser->content_length == 0); STRICT_CHECK(ch != CR); parser->state = s_chunk_data_done; CALLBACK_DATA(body); break; case s_chunk_data_done: assert(parser->flags & F_CHUNKED); STRICT_CHECK(ch != LF); parser->nread = 0; parser->state = s_chunk_size_start; break; default: assert(0 && "unhandled state"); SET_ERRNO(HPE_INVALID_INTERNAL_STATE); goto error; } } /* Run callbacks for any marks that we have leftover after we ran our of * bytes. There should be at most one of these set, so it's OK to invoke * them in series (unset marks will not result in callbacks). * * We use the NOADVANCE() variety of callbacks here because 'p' has already * overflowed 'data' and this allows us to correct for the off-by-one that * we'd otherwise have (since CALLBACK_DATA() is meant to be run with a 'p' * value that's in-bounds). */ assert(((header_field_mark ? 1 : 0) + (header_value_mark ? 1 : 0) + (url_mark ? 1 : 0) + (body_mark ? 1 : 0)) <= 1); CALLBACK_DATA_NOADVANCE(header_field); CALLBACK_DATA_NOADVANCE(header_value); CALLBACK_DATA_NOADVANCE(url); CALLBACK_DATA_NOADVANCE(body); return len; error: if (HTTP_PARSER_ERRNO(parser) == HPE_OK) { SET_ERRNO(HPE_UNKNOWN); } return (p - data); } /* Does the parser need to see an EOF to find the end of the message? */ int http_message_needs_eof (const http_parser *parser) { if (parser->type == HTTP_REQUEST) { return 0; } /* See RFC 2616 section 4.4 */ if (parser->status_code / 100 == 1 || /* 1xx e.g. Continue */ parser->status_code == 204 || /* No Content */ parser->status_code == 304 || /* Not Modified */ parser->flags & F_SKIPBODY) { /* response to a HEAD request */ return 0; } if ((parser->flags & F_CHUNKED) || parser->content_length != ULLONG_MAX) { return 0; } return 1; } int http_should_keep_alive (const http_parser *parser) { if (parser->http_major > 0 && parser->http_minor > 0) { /* HTTP/1.1 */ if (parser->flags & F_CONNECTION_CLOSE) { return 0; } } else { /* HTTP/1.0 or earlier */ if (!(parser->flags & F_CONNECTION_KEEP_ALIVE)) { return 0; } } return !http_message_needs_eof(parser); } const char * http_method_str (enum http_method m) { return ELEM_AT(method_strings, m, ""); } void http_parser_init (http_parser *parser, enum http_parser_type t) { void *data = parser->data; /* preserve application data */ memset(parser, 0, sizeof(*parser)); parser->data = data; parser->type = t; parser->state = (t == HTTP_REQUEST ? s_start_req : (t == HTTP_RESPONSE ? s_start_res : s_start_req_or_res)); parser->http_errno = HPE_OK; } const char * http_errno_name(enum http_errno err) { assert(err < (sizeof(http_strerror_tab)/sizeof(http_strerror_tab[0]))); return http_strerror_tab[err].name; } const char * http_errno_description(enum http_errno err) { assert(err < (sizeof(http_strerror_tab)/sizeof(http_strerror_tab[0]))); return http_strerror_tab[err].description; } static enum http_host_state http_parse_host_char(enum http_host_state s, const char ch) { switch(s) { case s_http_userinfo: case s_http_userinfo_start: if (ch == '@') { return s_http_host_start; } if (IS_USERINFO_CHAR(ch)) { return s_http_userinfo; } break; case s_http_host_start: if (ch == '[') { return s_http_host_v6_start; } if (IS_HOST_CHAR(ch)) { return s_http_host; } break; case s_http_host: if (IS_HOST_CHAR(ch)) { return s_http_host; } /* FALLTHROUGH */ case s_http_host_v6_end: if (ch == ':') { return s_http_host_port_start; } break; case s_http_host_v6: if (ch == ']') { return s_http_host_v6_end; } /* FALLTHROUGH */ case s_http_host_v6_start: if (IS_HEX(ch) || ch == ':' || ch == '.') { return s_http_host_v6; } break; case s_http_host_port: case s_http_host_port_start: if (IS_NUM(ch)) { return s_http_host_port; } break; default: break; } return s_http_host_dead; } static int http_parse_host(const char * buf, struct http_parser_url *u, int found_at) { enum http_host_state s; const char *p; size_t buflen = u->field_data[UF_HOST].off + u->field_data[UF_HOST].len; u->field_data[UF_HOST].len = 0; s = found_at ? s_http_userinfo_start : s_http_host_start; for (p = buf + u->field_data[UF_HOST].off; p < buf + buflen; p++) { enum http_host_state new_s = http_parse_host_char(s, *p); if (new_s == s_http_host_dead) { return 1; } switch(new_s) { case s_http_host: if (s != s_http_host) { u->field_data[UF_HOST].off = p - buf; } u->field_data[UF_HOST].len++; break; case s_http_host_v6: if (s != s_http_host_v6) { u->field_data[UF_HOST].off = p - buf; } u->field_data[UF_HOST].len++; break; case s_http_host_port: if (s != s_http_host_port) { u->field_data[UF_PORT].off = p - buf; u->field_data[UF_PORT].len = 0; u->field_set |= (1 << UF_PORT); } u->field_data[UF_PORT].len++; break; case s_http_userinfo: if (s != s_http_userinfo) { u->field_data[UF_USERINFO].off = p - buf ; u->field_data[UF_USERINFO].len = 0; u->field_set |= (1 << UF_USERINFO); } u->field_data[UF_USERINFO].len++; break; default: break; } s = new_s; } /* Make sure we don't end somewhere unexpected */ switch (s) { case s_http_host_start: case s_http_host_v6_start: case s_http_host_v6: case s_http_host_port_start: case s_http_userinfo: case s_http_userinfo_start: return 1; default: break; } return 0; } int http_parser_parse_url(const char *buf, size_t buflen, int is_connect, struct http_parser_url *u) { enum state s; const char *p; enum http_parser_url_fields uf, old_uf; int found_at = 0; u->port = u->field_set = 0; s = is_connect ? s_req_server_start : s_req_spaces_before_url; uf = old_uf = UF_MAX; for (p = buf; p < buf + buflen; p++) { s = parse_url_char(s, *p); /* Figure out the next field that we're operating on */ switch (s) { case s_dead: return 1; /* Skip delimeters */ case s_req_schema_slash: case s_req_schema_slash_slash: case s_req_server_start: case s_req_query_string_start: case s_req_fragment_start: continue; case s_req_schema: uf = UF_SCHEMA; break; case s_req_server_with_at: found_at = 1; /* FALLTROUGH */ case s_req_server: uf = UF_HOST; break; case s_req_path: uf = UF_PATH; break; case s_req_query_string: uf = UF_QUERY; break; case s_req_fragment: uf = UF_FRAGMENT; break; default: assert(!"Unexpected state"); return 1; } /* Nothing's changed; soldier on */ if (uf == old_uf) { u->field_data[uf].len++; continue; } u->field_data[uf].off = p - buf; u->field_data[uf].len = 1; u->field_set |= (1 << uf); old_uf = uf; } /* host must be present if there is a schema */ /* parsing http:///toto will fail */ if ((u->field_set & ((1 << UF_SCHEMA) | (1 << UF_HOST))) != 0) { if (http_parse_host(buf, u, found_at) != 0) { return 1; } } /* CONNECT requests can only contain "hostname:port" */ if (is_connect && u->field_set != ((1 << UF_HOST)|(1 << UF_PORT))) { return 1; } if (u->field_set & (1 << UF_PORT)) { /* Don't bother with endp; we've already validated the string */ unsigned long v = strtoul(buf + u->field_data[UF_PORT].off, NULL, 10); /* Ports have a max value of 2^16 */ if (v > 0xffff) { return 1; } u->port = (uint16_t) v; } return 0; } void http_parser_pause(http_parser *parser, int paused) { /* Users should only be pausing/unpausing a parser that is not in an error * state. In non-debug builds, there's not much that we can do about this * other than ignore it. */ if (HTTP_PARSER_ERRNO(parser) == HPE_OK || HTTP_PARSER_ERRNO(parser) == HPE_PAUSED) { SET_ERRNO((paused) ? HPE_PAUSED : HPE_OK); } else { assert(0 && "Attempting to pause parser in error state"); } } int http_body_is_final(const struct http_parser *parser) { return parser->state == s_message_done; } unsigned long http_parser_version(void) { return HTTP_PARSER_VERSION_MAJOR * 0x10000 | HTTP_PARSER_VERSION_MINOR * 0x00100 | HTTP_PARSER_VERSION_PATCH * 0x00001; } http-parser-0.9.0/http_parser/http_parser.gyp0000644000076500000240000000544713642725626022175 0ustar benoitcstaff00000000000000# This file is used with the GYP meta build system. # http://code.google.com/p/gyp/ # To build try this: # svn co http://gyp.googlecode.com/svn/trunk gyp # ./gyp/gyp -f make --depth=`pwd` http_parser.gyp # ./out/Debug/test { 'target_defaults': { 'default_configuration': 'Debug', 'configurations': { # TODO: hoist these out and put them somewhere common, because # RuntimeLibrary MUST MATCH across the entire project 'Debug': { 'defines': [ 'DEBUG', '_DEBUG' ], 'cflags': [ '-Wall', '-Wextra', '-O0', '-g', '-ftrapv' ], 'msvs_settings': { 'VCCLCompilerTool': { 'RuntimeLibrary': 1, # static debug }, }, }, 'Release': { 'defines': [ 'NDEBUG' ], 'cflags': [ '-Wall', '-Wextra', '-O3' ], 'msvs_settings': { 'VCCLCompilerTool': { 'RuntimeLibrary': 0, # static release }, }, } }, 'msvs_settings': { 'VCCLCompilerTool': { }, 'VCLibrarianTool': { }, 'VCLinkerTool': { 'GenerateDebugInformation': 'true', }, }, 'conditions': [ ['OS == "win"', { 'defines': [ 'WIN32' ], }] ], }, 'targets': [ { 'target_name': 'http_parser', 'type': 'static_library', 'include_dirs': [ '.' ], 'direct_dependent_settings': { 'defines': [ 'HTTP_PARSER_STRICT=0' ], 'include_dirs': [ '.' ], }, 'defines': [ 'HTTP_PARSER_STRICT=0' ], 'sources': [ './http_parser.c', ], 'conditions': [ ['OS=="win"', { 'msvs_settings': { 'VCCLCompilerTool': { # Compile as C++. http_parser.c is actually C99, but C++ is # close enough in this case. 'CompileAs': 2, }, }, }] ], }, { 'target_name': 'http_parser_strict', 'type': 'static_library', 'include_dirs': [ '.' ], 'direct_dependent_settings': { 'defines': [ 'HTTP_PARSER_STRICT=1' ], 'include_dirs': [ '.' ], }, 'defines': [ 'HTTP_PARSER_STRICT=1' ], 'sources': [ './http_parser.c', ], 'conditions': [ ['OS=="win"', { 'msvs_settings': { 'VCCLCompilerTool': { # Compile as C++. http_parser.c is actually C99, but C++ is # close enough in this case. 'CompileAs': 2, }, }, }] ], }, { 'target_name': 'test-nonstrict', 'type': 'executable', 'dependencies': [ 'http_parser' ], 'sources': [ 'test.c' ] }, { 'target_name': 'test-strict', 'type': 'executable', 'dependencies': [ 'http_parser_strict' ], 'sources': [ 'test.c' ] } ] } http-parser-0.9.0/http_parser/http_parser.h0000644000076500000240000002725113642725626021622 0ustar benoitcstaff00000000000000/* Copyright Joyent, Inc. and other Node contributors. All rights reserved. * * 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. */ #ifndef http_parser_h #define http_parser_h #ifdef __cplusplus extern "C" { #endif /* Also update SONAME in the Makefile whenever you change these. */ #define HTTP_PARSER_VERSION_MAJOR 2 #define HTTP_PARSER_VERSION_MINOR 1 #define HTTP_PARSER_VERSION_PATCH 0 #include #if defined(_WIN32) && !defined(__MINGW32__) && (!defined(_MSC_VER) || _MSC_VER<1600) #include #include typedef __int8 int8_t; typedef unsigned __int8 uint8_t; typedef __int16 int16_t; typedef unsigned __int16 uint16_t; typedef __int32 int32_t; typedef unsigned __int32 uint32_t; typedef __int64 int64_t; typedef unsigned __int64 uint64_t; #else #include #endif /* Compile with -DHTTP_PARSER_STRICT=0 to make less checks, but run * faster */ #ifndef HTTP_PARSER_STRICT # define HTTP_PARSER_STRICT 1 #endif /* Maximium header size allowed */ #define HTTP_MAX_HEADER_SIZE (80*1024) typedef struct http_parser http_parser; typedef struct http_parser_settings http_parser_settings; /* Callbacks should return non-zero to indicate an error. The parser will * then halt execution. * * The one exception is on_headers_complete. In a HTTP_RESPONSE parser * returning '1' from on_headers_complete will tell the parser that it * should not expect a body. This is used when receiving a response to a * HEAD request which may contain 'Content-Length' or 'Transfer-Encoding: * chunked' headers that indicate the presence of a body. * * http_data_cb does not return data chunks. It will be call arbitrarally * many times for each string. E.G. you might get 10 callbacks for "on_url" * each providing just a few characters more data. */ typedef int (*http_data_cb) (http_parser*, const char *at, size_t length); typedef int (*http_cb) (http_parser*); /* Request Methods */ #define HTTP_METHOD_MAP(XX) \ XX(0, DELETE, DELETE) \ XX(1, GET, GET) \ XX(2, HEAD, HEAD) \ XX(3, POST, POST) \ XX(4, PUT, PUT) \ /* pathological */ \ XX(5, CONNECT, CONNECT) \ XX(6, OPTIONS, OPTIONS) \ XX(7, TRACE, TRACE) \ /* webdav */ \ XX(8, COPY, COPY) \ XX(9, LOCK, LOCK) \ XX(10, MKCOL, MKCOL) \ XX(11, MOVE, MOVE) \ XX(12, PROPFIND, PROPFIND) \ XX(13, PROPPATCH, PROPPATCH) \ XX(14, SEARCH, SEARCH) \ XX(15, UNLOCK, UNLOCK) \ /* subversion */ \ XX(16, REPORT, REPORT) \ XX(17, MKACTIVITY, MKACTIVITY) \ XX(18, CHECKOUT, CHECKOUT) \ XX(19, MERGE, MERGE) \ /* upnp */ \ XX(20, MSEARCH, M-SEARCH) \ XX(21, NOTIFY, NOTIFY) \ XX(22, SUBSCRIBE, SUBSCRIBE) \ XX(23, UNSUBSCRIBE, UNSUBSCRIBE) \ /* RFC-5789 */ \ XX(24, PATCH, PATCH) \ XX(25, PURGE, PURGE) \ enum http_method { #define XX(num, name, string) HTTP_##name = num, HTTP_METHOD_MAP(XX) #undef XX }; enum http_parser_type { HTTP_REQUEST, HTTP_RESPONSE, HTTP_BOTH }; /* Flag values for http_parser.flags field */ enum flags { F_CHUNKED = 1 << 0 , F_CONNECTION_KEEP_ALIVE = 1 << 1 , F_CONNECTION_CLOSE = 1 << 2 , F_TRAILING = 1 << 3 , F_UPGRADE = 1 << 4 , F_SKIPBODY = 1 << 5 }; /* Map for errno-related constants * * The provided argument should be a macro that takes 2 arguments. */ #define HTTP_ERRNO_MAP(XX) \ /* No error */ \ XX(OK, "success") \ \ /* Callback-related errors */ \ XX(CB_message_begin, "the on_message_begin callback failed") \ XX(CB_status_complete, "the on_status_complete callback failed") \ XX(CB_url, "the on_url callback failed") \ XX(CB_header_field, "the on_header_field callback failed") \ XX(CB_header_value, "the on_header_value callback failed") \ XX(CB_headers_complete, "the on_headers_complete callback failed") \ XX(CB_body, "the on_body callback failed") \ XX(CB_message_complete, "the on_message_complete callback failed") \ \ /* Parsing-related errors */ \ XX(INVALID_EOF_STATE, "stream ended at an unexpected time") \ XX(HEADER_OVERFLOW, \ "too many header bytes seen; overflow detected") \ XX(CLOSED_CONNECTION, \ "data received after completed connection: close message") \ XX(INVALID_VERSION, "invalid HTTP version") \ XX(INVALID_STATUS, "invalid HTTP status code") \ XX(INVALID_METHOD, "invalid HTTP method") \ XX(INVALID_URL, "invalid URL") \ XX(INVALID_HOST, "invalid host") \ XX(INVALID_PORT, "invalid port") \ XX(INVALID_PATH, "invalid path") \ XX(INVALID_QUERY_STRING, "invalid query string") \ XX(INVALID_FRAGMENT, "invalid fragment") \ XX(LF_EXPECTED, "LF character expected") \ XX(INVALID_HEADER_TOKEN, "invalid character in header") \ XX(INVALID_CONTENT_LENGTH, \ "invalid character in content-length header") \ XX(INVALID_CHUNK_SIZE, \ "invalid character in chunk size header") \ XX(INVALID_CONSTANT, "invalid constant string") \ XX(INVALID_INTERNAL_STATE, "encountered unexpected internal state")\ XX(STRICT, "strict mode assertion failed") \ XX(PAUSED, "parser is paused") \ XX(UNKNOWN, "an unknown error occurred") /* Define HPE_* values for each errno value above */ #define HTTP_ERRNO_GEN(n, s) HPE_##n, enum http_errno { HTTP_ERRNO_MAP(HTTP_ERRNO_GEN) }; #undef HTTP_ERRNO_GEN /* Get an http_errno value from an http_parser */ #define HTTP_PARSER_ERRNO(p) ((enum http_errno) (p)->http_errno) struct http_parser { /** PRIVATE **/ unsigned char type : 2; /* enum http_parser_type */ unsigned char flags : 6; /* F_* values from 'flags' enum; semi-public */ unsigned char state; /* enum state from http_parser.c */ unsigned char header_state; /* enum header_state from http_parser.c */ unsigned char index; /* index into current matcher */ uint32_t nread; /* # bytes read in various scenarios */ uint64_t content_length; /* # bytes in body (0 if no Content-Length header) */ /** READ-ONLY **/ unsigned short http_major; unsigned short http_minor; unsigned short status_code; /* responses only */ unsigned char method; /* requests only */ unsigned char http_errno : 7; /* 1 = Upgrade header was present and the parser has exited because of that. * 0 = No upgrade header present. * Should be checked when http_parser_execute() returns in addition to * error checking. */ unsigned char upgrade : 1; /** PUBLIC **/ void *data; /* A pointer to get hook to the "connection" or "socket" object */ }; struct http_parser_settings { http_cb on_message_begin; http_data_cb on_url; http_cb on_status_complete; http_data_cb on_header_field; http_data_cb on_header_value; http_cb on_headers_complete; http_data_cb on_body; http_cb on_message_complete; }; enum http_parser_url_fields { UF_SCHEMA = 0 , UF_HOST = 1 , UF_PORT = 2 , UF_PATH = 3 , UF_QUERY = 4 , UF_FRAGMENT = 5 , UF_USERINFO = 6 , UF_MAX = 7 }; /* Result structure for http_parser_parse_url(). * * Callers should index into field_data[] with UF_* values iff field_set * has the relevant (1 << UF_*) bit set. As a courtesy to clients (and * because we probably have padding left over), we convert any port to * a uint16_t. */ struct http_parser_url { uint16_t field_set; /* Bitmask of (1 << UF_*) values */ uint16_t port; /* Converted UF_PORT string */ struct { uint16_t off; /* Offset into buffer in which field starts */ uint16_t len; /* Length of run in buffer */ } field_data[UF_MAX]; }; /* Returns the library version. Bits 16-23 contain the major version number, * bits 8-15 the minor version number and bits 0-7 the patch level. * Usage example: * * unsigned long version = http_parser_version(); * unsigned major = (version >> 16) & 255; * unsigned minor = (version >> 8) & 255; * unsigned patch = version & 255; * printf("http_parser v%u.%u.%u\n", major, minor, version); */ unsigned long http_parser_version(void); void http_parser_init(http_parser *parser, enum http_parser_type type); size_t http_parser_execute(http_parser *parser, const http_parser_settings *settings, const char *data, size_t len); /* If http_should_keep_alive() in the on_headers_complete or * on_message_complete callback returns 0, then this should be * the last message on the connection. * If you are the server, respond with the "Connection: close" header. * If you are the client, close the connection. */ int http_should_keep_alive(const http_parser *parser); /* Returns a string version of the HTTP method. */ const char *http_method_str(enum http_method m); /* Return a string name of the given error */ const char *http_errno_name(enum http_errno err); /* Return a string description of the given error */ const char *http_errno_description(enum http_errno err); /* Parse a URL; return nonzero on failure */ int http_parser_parse_url(const char *buf, size_t buflen, int is_connect, struct http_parser_url *u); /* Pause or un-pause the parser; a nonzero value pauses */ void http_parser_pause(http_parser *parser, int paused); /* Checks if this is the final chunk of the body. */ int http_body_is_final(const http_parser *parser); #ifdef __cplusplus } #endif #endif http-parser-0.9.0/http_parser/parser.c0000644000076500000240000166307413642726000020553 0ustar benoitcstaff00000000000000/* Generated by Cython 0.29.16 */ #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 < 0x03030000) #error Cython requires Python 2.6+ or Python 3.3+. #else #define CYTHON_ABI "0_29_16" #define CYTHON_HEX_VERSION 0x001D10F0 #define CYTHON_FUTURE_DIVISION 0 #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 #define __PYX_COMMA , #ifndef HAVE_LONG_LONG #if 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_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #if PY_VERSION_HEX < 0x03050000 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #elif !defined(CYTHON_USE_ASYNC_SLOTS) #define CYTHON_USE_ASYNC_SLOTS 1 #endif #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 #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 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_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #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 #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 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_VERSION_HEX < 0x02070000 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #elif !defined(CYTHON_USE_PYTYPE_LOOKUP) #define CYTHON_USE_PYTYPE_LOOKUP 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 #ifndef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000) #endif #ifndef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1) #endif #ifndef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1) #endif #ifndef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3) #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 #ifdef SIZEOF_VOID_P enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) }; #endif #endif #ifndef __has_attribute #define __has_attribute(x) 0 #endif #ifndef __has_cpp_attribute #define __has_cpp_attribute(x) 0 #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) #ifdef _MSC_VER #ifndef _MSC_STDINT_H_ #if _MSC_VER < 1300 typedef unsigned char uint8_t; typedef unsigned int uint32_t; #else typedef unsigned __int8 uint8_t; typedef unsigned __int32 uint32_t; #endif #endif #else #include #endif #ifndef CYTHON_FALLTHROUGH #if defined(__cplusplus) && __cplusplus >= 201103L #if __has_cpp_attribute(fallthrough) #define CYTHON_FALLTHROUGH [[fallthrough]] #elif __has_cpp_attribute(clang::fallthrough) #define CYTHON_FALLTHROUGH [[clang::fallthrough]] #elif __has_cpp_attribute(gnu::fallthrough) #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] #endif #endif #ifndef CYTHON_FALLTHROUGH #if __has_attribute(fallthrough) #define CYTHON_FALLTHROUGH __attribute__((fallthrough)) #else #define CYTHON_FALLTHROUGH #endif #endif #if defined(__clang__ ) && defined(__apple_build_version__) #if __apple_build_version__ < 7000000 #undef CYTHON_FALLTHROUGH #define CYTHON_FALLTHROUGH #endif #endif #endif #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 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" #if PY_VERSION_HEX >= 0x030800A4 && PY_VERSION_HEX < 0x030800B2 #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a, 0, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #else #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) #endif #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_STACKLESS #define METH_STACKLESS 0 #endif #if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL) #ifndef METH_FASTCALL #define METH_FASTCALL 0x80 #endif typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs); typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames); #else #define __Pyx_PyCFunctionFast _PyCFunctionFast #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords #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 | METH_KEYWORDS | METH_STACKLESS))))) #else #define __Pyx_PyFastCFunction_Check(func) 0 #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_CPYTHON && PY_VERSION_HEX < 0x030400A1 #define PyMem_RawMalloc(n) PyMem_Malloc(n) #define PyMem_RawRealloc(p, n) PyMem_Realloc(p, n) #define PyMem_RawFree(p) PyMem_Free(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 #if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000 #define __Pyx_PyThreadState_Current PyThreadState_GET() #elif PY_VERSION_HEX >= 0x03060000 #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() #elif PY_VERSION_HEX >= 0x03000000 #define __Pyx_PyThreadState_Current PyThreadState_GET() #else #define __Pyx_PyThreadState_Current _PyThreadState_Current #endif #if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) #include "pythread.h" #define Py_tss_NEEDS_INIT 0 typedef int Py_tss_t; static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) { *key = PyThread_create_key(); return 0; } static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) { Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t)); *key = Py_tss_NEEDS_INIT; return key; } static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) { PyObject_Free(key); } static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) { return *key != Py_tss_NEEDS_INIT; } static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) { PyThread_delete_key(*key); *key = Py_tss_NEEDS_INIT; } static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) { return PyThread_set_key_value(*key, value); } static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { return PyThread_get_key_value(*key); } #endif #if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized) #define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) #else #define __Pyx_PyDict_NewPresized(n) PyDict_New() #endif #if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION #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 #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS #define __Pyx_PyDict_GetItemStr(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) #else #define __Pyx_PyDict_GetItemStr(dict, name) PyDict_GetItem(dict, name) #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 #define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) #define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? 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 #ifndef PyObject_Unicode #define PyObject_Unicode PyObject_Str #endif #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 #if CYTHON_ASSUME_SAFE_MACROS #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) #else #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) #endif #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) : (Py_INCREF(func), 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 #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) #endif #else #define __Pyx_PyType_AsAsync(obj) NULL #endif #ifndef __Pyx_PyAsyncMethodsStruct typedef struct { unaryfunc am_await; unaryfunc am_aiter; unaryfunc am_anext; } __Pyx_PyAsyncMethodsStruct; #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; \ } #ifndef __PYX_EXTERN_C #ifdef __cplusplus #define __PYX_EXTERN_C extern "C" #else #define __PYX_EXTERN_C extern #endif #endif #define __PYX_HAVE__http_parser__parser #define __PYX_HAVE_API__http_parser__parser /* Early includes */ #include #include #include "pyversion_compat.h" #include #include "pythread.h" #include "http_parser.h" #ifdef _OPENMP #include #endif /* _OPENMP */ #if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_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_UTF8 0 #define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8) #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))) ) static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { return (size_t) i < (size_t) limit; } #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) #define __Pyx_sst_abs(value) ((Py_ssize_t)_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 const char* __Pyx_PyObject_AsString(PyObject*); static CYTHON_INLINE const 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_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) #define __Pyx_PyObject_AsWritableString(s) ((char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsWritableSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsUString(s) ((const 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) 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); } #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) static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b); static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*); static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); #define __Pyx_PySequence_Tuple(obj)\ (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj)) 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) + 1); 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 CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } static PyObject *__pyx_m = NULL; static PyObject *__pyx_d; static PyObject *__pyx_b; static PyObject *__pyx_cython_runtime = NULL; 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[] = { "http_parser/parser.pyx", "stringsource", "type.pxd", "bool.pxd", "complex.pxd", }; /*--- Type declarations ---*/ struct __pyx_obj_11http_parser_6parser_HttpParser; /* "http_parser/parser.pyx":193 * self._last_was_value = False * * cdef class HttpParser: # <<<<<<<<<<<<<< * """ Low level HTTP parser. """ * */ struct __pyx_obj_11http_parser_6parser_HttpParser { PyObject_HEAD struct http_parser _parser; struct http_parser_settings _settings; PyObject *_data; PyObject *_path; PyObject *_query_string; PyObject *_fragment; PyObject *_parsed_url; }; /* --- 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); #else #define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) #endif /* GetBuiltinName.proto */ static PyObject *__Pyx_GetBuiltinName(PyObject *name); /* PyDictVersioning.proto */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS #define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1) #define __PYX_GET_DICT_VERSION(dict) (((PyDictObject*)(dict))->ma_version_tag) #define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\ (version_var) = __PYX_GET_DICT_VERSION(dict);\ (cache_var) = (value); #define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\ static PY_UINT64_T __pyx_dict_version = 0;\ static PyObject *__pyx_dict_cached_value = NULL;\ if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\ (VAR) = __pyx_dict_cached_value;\ } else {\ (VAR) = __pyx_dict_cached_value = (LOOKUP);\ __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\ }\ } static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj); static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj); static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version); #else #define __PYX_GET_DICT_VERSION(dict) (0) #define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var) #define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) (VAR) = (LOOKUP); #endif /* GetModuleGlobalName.proto */ #if CYTHON_USE_DICT_VERSIONS #define __Pyx_GetModuleGlobalName(var, name) {\ static PY_UINT64_T __pyx_dict_version = 0;\ static PyObject *__pyx_dict_cached_value = NULL;\ (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\ (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\ __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ } #define __Pyx_GetModuleGlobalNameUncached(var, name) {\ PY_UINT64_T __pyx_dict_version;\ PyObject *__pyx_dict_cached_value;\ (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ } static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); #else #define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name) #define __Pyx_GetModuleGlobalNameUncached(var, name) (var) = __Pyx__GetModuleGlobalName(name) static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); #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, Py_ssize_t nargs, PyObject *kwargs); #else #define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs) #endif #define __Pyx_BUILD_ASSERT_EXPR(cond)\ (sizeof(char [1 - 2*!(cond)]) - 1) #ifndef Py_MEMBER_SIZE #define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) #endif static size_t __pyx_pyframe_localsplus_offset = 0; #include "frameobject.h" #define __Pxy_PyFrame_Initialize_Offsets()\ ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\ (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus))) #define __Pyx_PyFrame_GetLocalsplus(frame)\ (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) #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 /* PyObjectCall2Args.proto */ static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2); /* 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); /* 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); #else #define __Pyx_PyObject_DelAttrStr(o,n) PyObject_DelAttr(o,n) #define __Pyx_PyObject_SetAttrStr(o,n,v) PyObject_SetAttr(o,n,v) #endif /* PyThreadStateGet.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; #define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; #define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type #else #define __Pyx_PyThreadState_declare #define __Pyx_PyThreadState_assign #define __Pyx_PyErr_Occurred() PyErr_Occurred() #endif /* PyErrFetchRestore.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) #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); #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) #else #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) #endif #else #define __Pyx_PyErr_Clear() PyErr_Clear() #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) #define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) #define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetchInState(tstate, 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 /* WriteUnraisableException.proto */ static void __Pyx_WriteUnraisable(const char *name, int clineno, int lineno, const char *filename, int full_traceback, int nogil); /* PySequenceContains.proto */ static CYTHON_INLINE int __Pyx_PySequence_ContainsTF(PyObject* item, PyObject* seq, int eq) { int result = PySequence_Contains(seq, item); return unlikely(result < 0) ? result : (result == (eq == Py_EQ)); } /* 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 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); /* ObjectGetItem.proto */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key); #else #define __Pyx_PyObject_GetItem(obj, key) PyObject_GetItem(obj, key) #endif /* IncludeStringH.proto */ #include /* BytesEquals.proto */ static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); /* UnicodeEquals.proto */ static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); /* StrEquals.proto */ #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyString_Equals __Pyx_PyUnicode_Equals #else #define __Pyx_PyString_Equals __Pyx_PyBytes_Equals #endif /* PyIntBinop.proto */ #if !CYTHON_COMPILING_IN_PYPY static PyObject* __Pyx_PyInt_AddCObj(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check); #else #define __Pyx_PyInt_AddCObj(op1, op2, intval, inplace, zerodivision_check)\ (inplace ? PyNumber_InPlaceAdd(op1, op2) : PyNumber_Add(op1, op2)) #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 /* GetTopmostException.proto */ #if CYTHON_USE_EXC_INFO_STACK static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); #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 /* FastTypeChecks.proto */ #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); #else #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) #define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) #define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) #endif #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) /* 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 /* 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 /* PyObjectGetMethod.proto */ static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method); /* 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); /* 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); /* PyIntCompare.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_EqObjC(PyObject *op1, PyObject *op2, long intval, long inplace); /* 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); /* 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 /* UnpackUnboundCMethod.proto */ typedef struct { PyObject *type; PyObject **method_name; PyCFunction func; PyObject *method; int flag; } __Pyx_CachedCFunction; /* CallUnboundCMethod1.proto */ static PyObject* __Pyx__CallUnboundCMethod1(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg); #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_CallUnboundCMethod1(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg); #else #define __Pyx_CallUnboundCMethod1(cfunc, self, arg) __Pyx__CallUnboundCMethod1(cfunc, self, arg) #endif /* SliceObject.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice( PyObject* obj, Py_ssize_t cstart, Py_ssize_t cstop, PyObject** py_start, PyObject** py_stop, PyObject** py_slice, int has_cstart, int has_cstop, int wraparound); /* SliceObject.proto */ #define __Pyx_PyObject_DelSlice(obj, cstart, cstop, py_start, py_stop, py_slice, has_cstart, has_cstop, wraparound)\ __Pyx_PyObject_SetSlice(obj, (PyObject*)NULL, cstart, cstop, py_start, py_stop, py_slice, has_cstart, has_cstop, wraparound) static CYTHON_INLINE int __Pyx_PyObject_SetSlice( PyObject* obj, PyObject* value, Py_ssize_t cstart, Py_ssize_t cstop, PyObject** py_start, PyObject** py_stop, PyObject** py_slice, int has_cstart, int has_cstop, int wraparound); /* PyObject_GenericGetAttrNoDict.proto */ #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name); #else #define __Pyx_PyObject_GenericGetAttrNoDict PyObject_GenericGetAttr #endif /* PyObject_GenericGetAttr.proto */ #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name); #else #define __Pyx_PyObject_GenericGetAttr PyObject_GenericGetAttr #endif /* SetupReduce.proto */ static int __Pyx_setup_reduce(PyObject* type_obj); /* TypeImport.proto */ #ifndef __PYX_HAVE_RT_ImportType_proto #define __PYX_HAVE_RT_ImportType_proto enum __Pyx_ImportType_CheckSize { __Pyx_ImportType_CheckSize_Error = 0, __Pyx_ImportType_CheckSize_Warn = 1, __Pyx_ImportType_CheckSize_Ignore = 2 }; static PyTypeObject *__Pyx_ImportType(PyObject* module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size); #endif /* Import.proto */ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); /* ImportFrom.proto */ static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); /* 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 /* CalculateMetaclass.proto */ static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases); /* FetchCommonType.proto */ static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type); /* CythonFunction.proto */ #define __Pyx_CyFunction_USED 1 #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; size_t defaults_size; // used by FusedFunction for copying defaults 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_Check(obj) (__Pyx_TypeCheck(obj, __pyx_CyFunctionType)) #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); /* SetNameInClass.proto */ #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 #define __Pyx_SetNameInClass(ns, name, value)\ (likely(PyDict_CheckExact(ns)) ? _PyDict_SetItem_KnownHash(ns, name, value, ((PyASCIIObject *) name)->hash) : PyObject_SetItem(ns, name, value)) #elif CYTHON_COMPILING_IN_CPYTHON #define __Pyx_SetNameInClass(ns, name, value)\ (likely(PyDict_CheckExact(ns)) ? PyDict_SetItem(ns, name, value) : PyObject_SetItem(ns, name, value)) #else #define __Pyx_SetNameInClass(ns, name, value) PyObject_SetItem(ns, name, value) #endif /* 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); /* CLineInTraceback.proto */ #ifdef CYTHON_CLINE_IN_TRACEBACK #define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) #else static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); #endif /* 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_enum__http_errno(enum http_errno value); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_char(unsigned char value); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_short(unsigned short value); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_char(char value); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); /* CIntFromPy.proto */ static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE enum http_errno __Pyx_PyInt_As_enum__http_errno(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); /* Module declarations from 'libc.string' */ /* Module declarations from 'libc.stdlib' */ /* Module declarations from 'cpython.version' */ /* Module declarations from '__builtin__' */ /* Module declarations from 'cpython.type' */ static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0; /* Module declarations from 'libc.stdio' */ /* Module declarations from 'cpython.object' */ /* Module declarations from 'cpython.ref' */ /* Module declarations from 'cpython.exc' */ /* Module declarations from 'cpython.module' */ /* Module declarations from 'cpython.mem' */ /* Module declarations from 'cpython.tuple' */ /* Module declarations from 'cpython.list' */ /* Module declarations from 'cpython.sequence' */ /* Module declarations from 'cpython.mapping' */ /* Module declarations from 'cpython.iterator' */ /* Module declarations from 'cpython.number' */ /* Module declarations from 'cpython.int' */ /* Module declarations from '__builtin__' */ /* Module declarations from 'cpython.bool' */ static PyTypeObject *__pyx_ptype_7cpython_4bool_bool = 0; /* Module declarations from 'cpython.long' */ /* Module declarations from 'cpython.float' */ /* Module declarations from '__builtin__' */ /* Module declarations from 'cpython.complex' */ static PyTypeObject *__pyx_ptype_7cpython_7complex_complex = 0; /* Module declarations from 'cpython.string' */ /* Module declarations from 'cpython.unicode' */ /* Module declarations from 'cpython.dict' */ /* Module declarations from 'cpython.instance' */ /* Module declarations from 'cpython.function' */ /* Module declarations from 'cpython.method' */ /* Module declarations from 'cpython.weakref' */ /* Module declarations from 'cpython.getargs' */ /* Module declarations from 'cpython.pythread' */ /* Module declarations from 'cpython.pystate' */ /* Module declarations from 'cpython.cobject' */ /* Module declarations from 'cpython.oldbuffer' */ /* Module declarations from 'cpython.set' */ /* Module declarations from 'cpython.buffer' */ /* Module declarations from 'cpython.bytes' */ /* Module declarations from 'cpython.pycapsule' */ /* Module declarations from 'cpython' */ /* Module declarations from 'http_parser.parser' */ static PyTypeObject *__pyx_ptype_11http_parser_6parser_HttpParser = 0; static int __pyx_f_11http_parser_6parser_on_url_cb(struct http_parser *, char *, size_t); /*proto*/ static int __pyx_f_11http_parser_6parser_on_header_field_cb(struct http_parser *, char *, size_t); /*proto*/ static int __pyx_f_11http_parser_6parser_on_header_value_cb(struct http_parser *, char *, size_t); /*proto*/ static int __pyx_f_11http_parser_6parser_on_headers_complete_cb(struct http_parser *); /*proto*/ static int __pyx_f_11http_parser_6parser_on_message_begin_cb(struct http_parser *); /*proto*/ static int __pyx_f_11http_parser_6parser_on_body_cb(struct http_parser *, char *, size_t); /*proto*/ static int __pyx_f_11http_parser_6parser_on_message_complete_cb(struct http_parser *); /*proto*/ #define __Pyx_MODULE_NAME "http_parser.parser" extern int __pyx_module_is_main_http_parser__parser; int __pyx_module_is_main_http_parser__parser = 0; /* Implementation of 'http_parser.parser' */ static PyObject *__pyx_builtin_ImportError; static PyObject *__pyx_builtin_object; static PyObject *__pyx_builtin_ValueError; static PyObject *__pyx_builtin_map; static PyObject *__pyx_builtin_TypeError; static const char __pyx_k_[] = ""; static const char __pyx_k_b[] = "b"; static const char __pyx_k__4[] = "-"; static const char __pyx_k__5[] = "_"; static const char __pyx_k__7[] = "."; static const char __pyx_k_os[] = "os"; static const char __pyx_k_doc[] = "__doc__"; static const char __pyx_k_get[] = "get"; static const char __pyx_k_map[] = "map"; static const char __pyx_k_s_s[] = "%s, %s"; static const char __pyx_k_url[] = "url"; static const char __pyx_k_body[] = "body"; static const char __pyx_k_data[] = "data"; static const char __pyx_k_gzip[] = "gzip"; static const char __pyx_k_init[] = "__init__"; static const char __pyx_k_join[] = "join"; static const char __pyx_k_kind[] = "kind"; static const char __pyx_k_main[] = "__main__"; static const char __pyx_k_name[] = "__name__"; static const char __pyx_k_path[] = "path"; static const char __pyx_k_self[] = "self"; static const char __pyx_k_test[] = "__test__"; static const char __pyx_k_zlib[] = "zlib"; static const char __pyx_k_errno[] = "errno"; static const char __pyx_k_error[] = "error"; static const char __pyx_k_items[] = "items"; static const char __pyx_k_lower[] = "lower"; static const char __pyx_k_query[] = "query"; static const char __pyx_k_s_s_2[] = "%s %s"; static const char __pyx_k_split[] = "split"; static const char __pyx_k_upper[] = "upper"; static const char __pyx_k_HTTP_s[] = "HTTP/%s"; static const char __pyx_k_append[] = "append"; static const char __pyx_k_import[] = "__import__"; static const char __pyx_k_length[] = "length"; static const char __pyx_k_module[] = "__module__"; static const char __pyx_k_object[] = "object"; static const char __pyx_k_reduce[] = "__reduce__"; static const char __pyx_k_update[] = "update"; static const char __pyx_k_HTTP__s[] = "HTTP_%s"; static const char __pyx_k_RAW_URI[] = "RAW_URI"; static const char __pyx_k_chunked[] = "chunked"; static const char __pyx_k_deflate[] = "deflate"; static const char __pyx_k_environ[] = "environ"; static const char __pyx_k_get_url[] = "get_url"; static const char __pyx_k_headers[] = "headers"; static const char __pyx_k_prepare[] = "__prepare__"; static const char __pyx_k_replace[] = "replace"; static const char __pyx_k_unquote[] = "unquote"; static const char __pyx_k_fragment[] = "fragment"; static const char __pyx_k_getstate[] = "__getstate__"; static const char __pyx_k_qualname[] = "__qualname__"; static const char __pyx_k_setstate[] = "__setstate__"; static const char __pyx_k_urlparse[] = "urlparse"; static const char __pyx_k_urlsplit[] = "urlsplit"; static const char __pyx_k_MAX_WBITS[] = "MAX_WBITS"; static const char __pyx_k_PATH_INFO[] = "PATH_INFO"; static const char __pyx_k_TypeError[] = "TypeError"; static const char __pyx_k_metaclass[] = "__metaclass__"; static const char __pyx_k_reduce_ex[] = "__reduce_ex__"; static const char __pyx_k_HttpParser[] = "HttpParser"; static const char __pyx_k_ParserData[] = "_ParserData"; static const char __pyx_k_ValueError[] = "ValueError"; static const char __pyx_k_decompress[] = "decompress"; static const char __pyx_k_get_method[] = "get_method"; static const char __pyx_k_last_field[] = "_last_field"; static const char __pyx_k_ImportError[] = "ImportError"; static const char __pyx_k_SCRIPT_NAME[] = "SCRIPT_NAME"; static const char __pyx_k_get_version[] = "get_version"; static const char __pyx_k_header_only[] = "header_only"; static const char __pyx_k_CONTENT_TYPE[] = "CONTENT-TYPE"; static const char __pyx_k_IOrderedDict[] = "IOrderedDict"; static const char __pyx_k_QUERY_STRING[] = "QUERY_STRING"; static const char __pyx_k_bytes_to_str[] = "bytes_to_str"; static const char __pyx_k_partial_body[] = "partial_body"; static const char __pyx_k_urllib_parse[] = "urllib.parse"; static const char __pyx_k_decompressobj[] = "decompressobj"; static const char __pyx_k_message_begin[] = "message_begin"; static const char __pyx_k_reduce_cython[] = "__reduce_cython__"; static const char __pyx_k_CONTENT_LENGTH[] = "CONTENT-LENGTH"; static const char __pyx_k_CONTENT_TYPE_2[] = "CONTENT_TYPE"; static const char __pyx_k_REQUEST_METHOD[] = "REQUEST_METHOD"; static const char __pyx_k_get_errno_name[] = "get_errno_name"; static const char __pyx_k_last_was_value[] = "_last_was_value"; static const char __pyx_k_SERVER_PROTOCOL[] = "SERVER_PROTOCOL"; static const char __pyx_k_maybe_parse_url[] = "maybe_parse_url"; static const char __pyx_k_setstate_cython[] = "__setstate_cython__"; static const char __pyx_k_CONTENT_LENGTH_2[] = "CONTENT_LENGTH"; static const char __pyx_k_content_encoding[] = "content-encoding"; static const char __pyx_k_headers_complete[] = "headers_complete"; static const char __pyx_k_http_parser_util[] = "http_parser.util"; static const char __pyx_k_message_complete[] = "message_complete"; static const char __pyx_k_ParserData___init[] = "_ParserData.__init__"; static const char __pyx_k_transfer_encoding[] = "transfer-encoding"; static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; static const char __pyx_k_errno_out_of_range[] = "errno out of range"; static const char __pyx_k_http_parser_parser[] = "http_parser.parser"; static const char __pyx_k_decompress_first_try[] = "_decompress_first_try"; static const char __pyx_k_get_errno_description[] = "get_errno_description"; static const char __pyx_k_http_parser_parser_pyx[] = "http_parser/parser.pyx"; static const char __pyx_k_self__parser_self__settings_cann[] = "self._parser,self._settings cannot be converted to a Python object for pickling"; static PyObject *__pyx_kp_s_; static PyObject *__pyx_kp_s_CONTENT_LENGTH; static PyObject *__pyx_n_s_CONTENT_LENGTH_2; static PyObject *__pyx_kp_s_CONTENT_TYPE; static PyObject *__pyx_n_s_CONTENT_TYPE_2; static PyObject *__pyx_kp_s_HTTP__s; static PyObject *__pyx_kp_s_HTTP_s; static PyObject *__pyx_n_s_HttpParser; static PyObject *__pyx_n_s_IOrderedDict; static PyObject *__pyx_n_s_ImportError; static PyObject *__pyx_n_s_MAX_WBITS; static PyObject *__pyx_n_s_PATH_INFO; static PyObject *__pyx_n_s_ParserData; static PyObject *__pyx_n_s_ParserData___init; static PyObject *__pyx_n_s_QUERY_STRING; static PyObject *__pyx_n_s_RAW_URI; static PyObject *__pyx_n_s_REQUEST_METHOD; static PyObject *__pyx_n_s_SCRIPT_NAME; static PyObject *__pyx_n_s_SERVER_PROTOCOL; static PyObject *__pyx_n_s_TypeError; static PyObject *__pyx_n_s_ValueError; static PyObject *__pyx_kp_s__4; static PyObject *__pyx_n_s__5; static PyObject *__pyx_kp_s__7; static PyObject *__pyx_n_s_append; static PyObject *__pyx_n_s_b; static PyObject *__pyx_n_s_body; static PyObject *__pyx_n_s_bytes_to_str; static PyObject *__pyx_n_s_chunked; static PyObject *__pyx_n_s_cline_in_traceback; static PyObject *__pyx_kp_s_content_encoding; static PyObject *__pyx_n_s_data; static PyObject *__pyx_n_s_decompress; static PyObject *__pyx_n_s_decompress_first_try; static PyObject *__pyx_n_s_decompressobj; static PyObject *__pyx_n_s_deflate; static PyObject *__pyx_n_s_doc; static PyObject *__pyx_n_s_environ; static PyObject *__pyx_n_s_errno; static PyObject *__pyx_kp_s_errno_out_of_range; static PyObject *__pyx_n_s_error; static PyObject *__pyx_n_s_fragment; static PyObject *__pyx_n_s_get; static PyObject *__pyx_n_s_get_errno_description; static PyObject *__pyx_n_s_get_errno_name; static PyObject *__pyx_n_s_get_method; static PyObject *__pyx_n_s_get_url; static PyObject *__pyx_n_s_get_version; static PyObject *__pyx_n_s_getstate; static PyObject *__pyx_n_s_gzip; static PyObject *__pyx_n_s_header_only; static PyObject *__pyx_n_s_headers; static PyObject *__pyx_n_s_headers_complete; static PyObject *__pyx_n_s_http_parser_parser; static PyObject *__pyx_kp_s_http_parser_parser_pyx; static PyObject *__pyx_n_s_http_parser_util; static PyObject *__pyx_n_s_import; static PyObject *__pyx_n_s_init; static PyObject *__pyx_n_s_items; static PyObject *__pyx_n_s_join; static PyObject *__pyx_n_s_kind; static PyObject *__pyx_n_s_last_field; static PyObject *__pyx_n_s_last_was_value; static PyObject *__pyx_n_s_length; static PyObject *__pyx_n_s_lower; static PyObject *__pyx_n_s_main; static PyObject *__pyx_n_s_map; static PyObject *__pyx_n_s_maybe_parse_url; static PyObject *__pyx_n_s_message_begin; static PyObject *__pyx_n_s_message_complete; static PyObject *__pyx_n_s_metaclass; static PyObject *__pyx_n_s_module; static PyObject *__pyx_n_s_name; static PyObject *__pyx_n_s_object; static PyObject *__pyx_n_s_os; static PyObject *__pyx_n_s_partial_body; static PyObject *__pyx_n_s_path; static PyObject *__pyx_n_s_prepare; static PyObject *__pyx_n_s_qualname; static PyObject *__pyx_n_s_query; static PyObject *__pyx_n_s_reduce; static PyObject *__pyx_n_s_reduce_cython; static PyObject *__pyx_n_s_reduce_ex; static PyObject *__pyx_n_s_replace; static PyObject *__pyx_kp_s_s_s; static PyObject *__pyx_kp_s_s_s_2; static PyObject *__pyx_n_s_self; static PyObject *__pyx_kp_s_self__parser_self__settings_cann; static PyObject *__pyx_n_s_setstate; static PyObject *__pyx_n_s_setstate_cython; static PyObject *__pyx_n_s_split; static PyObject *__pyx_n_s_test; static PyObject *__pyx_kp_s_transfer_encoding; static PyObject *__pyx_n_s_unquote; static PyObject *__pyx_n_s_update; static PyObject *__pyx_n_s_upper; static PyObject *__pyx_n_s_url; static PyObject *__pyx_n_s_urllib_parse; static PyObject *__pyx_n_s_urlparse; static PyObject *__pyx_n_s_urlsplit; static PyObject *__pyx_n_s_zlib; static PyObject *__pyx_pf_11http_parser_6parser_get_errno_name(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_errno); /* proto */ static PyObject *__pyx_pf_11http_parser_6parser_2get_errno_description(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_errno); /* proto */ static PyObject *__pyx_pf_11http_parser_6parser_11_ParserData___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_decompress, PyObject *__pyx_v_header_only); /* proto */ static int __pyx_pf_11http_parser_6parser_10HttpParser___init__(struct __pyx_obj_11http_parser_6parser_HttpParser *__pyx_v_self, PyObject *__pyx_v_kind, PyObject *__pyx_v_decompress, PyObject *__pyx_v_header_only); /* proto */ static PyObject *__pyx_pf_11http_parser_6parser_10HttpParser_2execute(struct __pyx_obj_11http_parser_6parser_HttpParser *__pyx_v_self, char *__pyx_v_data, size_t __pyx_v_length); /* proto */ static PyObject *__pyx_pf_11http_parser_6parser_10HttpParser_4get_errno(struct __pyx_obj_11http_parser_6parser_HttpParser *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_11http_parser_6parser_10HttpParser_6get_version(struct __pyx_obj_11http_parser_6parser_HttpParser *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_11http_parser_6parser_10HttpParser_8get_method(struct __pyx_obj_11http_parser_6parser_HttpParser *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_11http_parser_6parser_10HttpParser_10get_status_code(struct __pyx_obj_11http_parser_6parser_HttpParser *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_11http_parser_6parser_10HttpParser_12get_url(struct __pyx_obj_11http_parser_6parser_HttpParser *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_11http_parser_6parser_10HttpParser_14maybe_parse_url(struct __pyx_obj_11http_parser_6parser_HttpParser *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_11http_parser_6parser_10HttpParser_16get_path(struct __pyx_obj_11http_parser_6parser_HttpParser *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_11http_parser_6parser_10HttpParser_18get_query_string(struct __pyx_obj_11http_parser_6parser_HttpParser *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_11http_parser_6parser_10HttpParser_20get_fragment(struct __pyx_obj_11http_parser_6parser_HttpParser *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_11http_parser_6parser_10HttpParser_22get_headers(struct __pyx_obj_11http_parser_6parser_HttpParser *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_11http_parser_6parser_10HttpParser_24get_wsgi_environ(struct __pyx_obj_11http_parser_6parser_HttpParser *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_11http_parser_6parser_10HttpParser_26recv_body(struct __pyx_obj_11http_parser_6parser_HttpParser *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_11http_parser_6parser_10HttpParser_28recv_body_into(struct __pyx_obj_11http_parser_6parser_HttpParser *__pyx_v_self, PyObject *__pyx_v_barray); /* proto */ static PyObject *__pyx_pf_11http_parser_6parser_10HttpParser_30is_upgrade(struct __pyx_obj_11http_parser_6parser_HttpParser *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_11http_parser_6parser_10HttpParser_32is_headers_complete(struct __pyx_obj_11http_parser_6parser_HttpParser *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_11http_parser_6parser_10HttpParser_34is_partial_body(struct __pyx_obj_11http_parser_6parser_HttpParser *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_11http_parser_6parser_10HttpParser_36is_message_begin(struct __pyx_obj_11http_parser_6parser_HttpParser *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_11http_parser_6parser_10HttpParser_38is_message_complete(struct __pyx_obj_11http_parser_6parser_HttpParser *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_11http_parser_6parser_10HttpParser_40is_chunked(struct __pyx_obj_11http_parser_6parser_HttpParser *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_11http_parser_6parser_10HttpParser_42should_keep_alive(struct __pyx_obj_11http_parser_6parser_HttpParser *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_11http_parser_6parser_10HttpParser_44__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_11http_parser_6parser_HttpParser *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_11http_parser_6parser_10HttpParser_46__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_11http_parser_6parser_HttpParser *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ static PyObject *__pyx_tp_new_11http_parser_6parser_HttpParser(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_update = {0, &__pyx_n_s_update, 0, 0, 0}; static PyObject *__pyx_int_0; static PyObject *__pyx_int_1; static PyObject *__pyx_int_2; static PyObject *__pyx_int_16; static PyObject *__pyx_tuple__2; static PyObject *__pyx_tuple__3; static PyObject *__pyx_tuple__6; static PyObject *__pyx_tuple__8; static PyObject *__pyx_tuple__9; static PyObject *__pyx_tuple__10; static PyObject *__pyx_tuple__11; static PyObject *__pyx_tuple__13; static PyObject *__pyx_tuple__15; static PyObject *__pyx_tuple__16; static PyObject *__pyx_tuple__18; static PyObject *__pyx_codeobj__12; static PyObject *__pyx_codeobj__14; static PyObject *__pyx_codeobj__17; /* Late includes */ /* "http_parser/parser.pyx":75 * * * cdef int on_url_cb(http_parser *parser, char *at, # <<<<<<<<<<<<<< * size_t length): * res = parser.data */ static int __pyx_f_11http_parser_6parser_on_url_cb(struct http_parser *__pyx_v_parser, char *__pyx_v_at, size_t __pyx_v_length) { PyObject *__pyx_v_res = NULL; 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; __Pyx_RefNannySetupContext("on_url_cb", 0); /* "http_parser/parser.pyx":77 * cdef int on_url_cb(http_parser *parser, char *at, * size_t length): * res = parser.data # <<<<<<<<<<<<<< * res.url += bytes_to_str(PyBytes_FromStringAndSize(at, length)) * return 0 */ __pyx_t_1 = ((PyObject *)__pyx_v_parser->data); __Pyx_INCREF(__pyx_t_1); __pyx_v_res = __pyx_t_1; __pyx_t_1 = 0; /* "http_parser/parser.pyx":78 * size_t length): * res = parser.data * res.url += bytes_to_str(PyBytes_FromStringAndSize(at, length)) # <<<<<<<<<<<<<< * return 0 * */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_res, __pyx_n_s_url); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 78, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_bytes_to_str); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 78, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyBytes_FromStringAndSize(__pyx_v_at, __pyx_v_length); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 78, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = NULL; 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_2 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_5, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; 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 = PyNumber_InPlaceAdd(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 78, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (__Pyx_PyObject_SetAttrStr(__pyx_v_res, __pyx_n_s_url, __pyx_t_3) < 0) __PYX_ERR(0, 78, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "http_parser/parser.pyx":79 * res = parser.data * res.url += bytes_to_str(PyBytes_FromStringAndSize(at, length)) * return 0 # <<<<<<<<<<<<<< * * cdef int on_header_field_cb(http_parser *parser, char *at, */ __pyx_r = 0; goto __pyx_L0; /* "http_parser/parser.pyx":75 * * * cdef int on_url_cb(http_parser *parser, char *at, # <<<<<<<<<<<<<< * size_t length): * res = parser.data */ /* 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_WriteUnraisable("http_parser.parser.on_url_cb", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_res); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "http_parser/parser.pyx":81 * return 0 * * cdef int on_header_field_cb(http_parser *parser, char *at, # <<<<<<<<<<<<<< * size_t length): * header_field = PyBytes_FromStringAndSize(at, length) */ static int __pyx_f_11http_parser_6parser_on_header_field_cb(struct http_parser *__pyx_v_parser, char *__pyx_v_at, size_t __pyx_v_length) { PyObject *__pyx_v_header_field = NULL; PyObject *__pyx_v_res = NULL; int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; __Pyx_RefNannySetupContext("on_header_field_cb", 0); /* "http_parser/parser.pyx":83 * cdef int on_header_field_cb(http_parser *parser, char *at, * size_t length): * header_field = PyBytes_FromStringAndSize(at, length) # <<<<<<<<<<<<<< * res = parser.data * */ __pyx_t_1 = PyBytes_FromStringAndSize(__pyx_v_at, __pyx_v_length); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 83, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_header_field = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "http_parser/parser.pyx":84 * size_t length): * header_field = PyBytes_FromStringAndSize(at, length) * res = parser.data # <<<<<<<<<<<<<< * * if res._last_was_value: */ __pyx_t_1 = ((PyObject *)__pyx_v_parser->data); __Pyx_INCREF(__pyx_t_1); __pyx_v_res = __pyx_t_1; __pyx_t_1 = 0; /* "http_parser/parser.pyx":86 * res = parser.data * * if res._last_was_value: # <<<<<<<<<<<<<< * res._last_field = "" * res._last_field += bytes_to_str(header_field) */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_res, __pyx_n_s_last_was_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 86, __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, 86, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_2) { /* "http_parser/parser.pyx":87 * * if res._last_was_value: * res._last_field = "" # <<<<<<<<<<<<<< * res._last_field += bytes_to_str(header_field) * res._last_was_value = False */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_res, __pyx_n_s_last_field, __pyx_kp_s_) < 0) __PYX_ERR(0, 87, __pyx_L1_error) /* "http_parser/parser.pyx":86 * res = parser.data * * if res._last_was_value: # <<<<<<<<<<<<<< * res._last_field = "" * res._last_field += bytes_to_str(header_field) */ } /* "http_parser/parser.pyx":88 * if res._last_was_value: * res._last_field = "" * res._last_field += bytes_to_str(header_field) # <<<<<<<<<<<<<< * res._last_was_value = False * return 0 */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_res, __pyx_n_s_last_field); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 88, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_bytes_to_str); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 88, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = NULL; 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_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_v_header_field) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_header_field); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 88, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = PyNumber_InPlaceAdd(__pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 88, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__Pyx_PyObject_SetAttrStr(__pyx_v_res, __pyx_n_s_last_field, __pyx_t_4) < 0) __PYX_ERR(0, 88, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "http_parser/parser.pyx":89 * res._last_field = "" * res._last_field += bytes_to_str(header_field) * res._last_was_value = False # <<<<<<<<<<<<<< * return 0 * */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_res, __pyx_n_s_last_was_value, Py_False) < 0) __PYX_ERR(0, 89, __pyx_L1_error) /* "http_parser/parser.pyx":90 * res._last_field += bytes_to_str(header_field) * res._last_was_value = False * return 0 # <<<<<<<<<<<<<< * * cdef int on_header_value_cb(http_parser *parser, char *at, */ __pyx_r = 0; goto __pyx_L0; /* "http_parser/parser.pyx":81 * return 0 * * cdef int on_header_field_cb(http_parser *parser, char *at, # <<<<<<<<<<<<<< * size_t length): * header_field = PyBytes_FromStringAndSize(at, length) */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_WriteUnraisable("http_parser.parser.on_header_field_cb", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_header_field); __Pyx_XDECREF(__pyx_v_res); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "http_parser/parser.pyx":92 * return 0 * * cdef int on_header_value_cb(http_parser *parser, char *at, # <<<<<<<<<<<<<< * size_t length): * res = parser.data */ static int __pyx_f_11http_parser_6parser_on_header_value_cb(struct http_parser *__pyx_v_parser, char *__pyx_v_at, size_t __pyx_v_length) { PyObject *__pyx_v_res = NULL; PyObject *__pyx_v_header_value = NULL; PyObject *__pyx_v_hval = NULL; 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("on_header_value_cb", 0); /* "http_parser/parser.pyx":94 * cdef int on_header_value_cb(http_parser *parser, char *at, * size_t length): * res = parser.data # <<<<<<<<<<<<<< * header_value = bytes_to_str(PyBytes_FromStringAndSize(at, length)) * */ __pyx_t_1 = ((PyObject *)__pyx_v_parser->data); __Pyx_INCREF(__pyx_t_1); __pyx_v_res = __pyx_t_1; __pyx_t_1 = 0; /* "http_parser/parser.pyx":95 * size_t length): * res = parser.data * header_value = bytes_to_str(PyBytes_FromStringAndSize(at, length)) # <<<<<<<<<<<<<< * * if res._last_field in res.headers: */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_bytes_to_str); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 95, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyBytes_FromStringAndSize(__pyx_v_at, __pyx_v_length); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 95, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __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); } } __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 95, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_header_value = __pyx_t_1; __pyx_t_1 = 0; /* "http_parser/parser.pyx":97 * header_value = bytes_to_str(PyBytes_FromStringAndSize(at, length)) * * if res._last_field in res.headers: # <<<<<<<<<<<<<< * hval = res.headers[res._last_field] * if not res._last_was_value: */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_res, __pyx_n_s_last_field); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 97, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_res, __pyx_n_s_headers); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 97, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_5 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_t_2, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 97, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_6 = (__pyx_t_5 != 0); if (__pyx_t_6) { /* "http_parser/parser.pyx":98 * * if res._last_field in res.headers: * hval = res.headers[res._last_field] # <<<<<<<<<<<<<< * if not res._last_was_value: * header_value = "%s, %s" % (hval, header_value) */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_res, __pyx_n_s_headers); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 98, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_res, __pyx_n_s_last_field); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 98, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 98, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_hval = __pyx_t_3; __pyx_t_3 = 0; /* "http_parser/parser.pyx":99 * if res._last_field in res.headers: * hval = res.headers[res._last_field] * if not res._last_was_value: # <<<<<<<<<<<<<< * header_value = "%s, %s" % (hval, header_value) * else: */ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_res, __pyx_n_s_last_was_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 99, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 99, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_5 = ((!__pyx_t_6) != 0); if (__pyx_t_5) { /* "http_parser/parser.pyx":100 * hval = res.headers[res._last_field] * if not res._last_was_value: * header_value = "%s, %s" % (hval, header_value) # <<<<<<<<<<<<<< * else: * header_value = "%s %s" % (hval, header_value) */ __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 100, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_v_hval); __Pyx_GIVEREF(__pyx_v_hval); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_hval); __Pyx_INCREF(__pyx_v_header_value); __Pyx_GIVEREF(__pyx_v_header_value); PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_header_value); __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_s_s, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 100, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF_SET(__pyx_v_header_value, __pyx_t_1); __pyx_t_1 = 0; /* "http_parser/parser.pyx":99 * if res._last_field in res.headers: * hval = res.headers[res._last_field] * if not res._last_was_value: # <<<<<<<<<<<<<< * header_value = "%s, %s" % (hval, header_value) * else: */ goto __pyx_L4; } /* "http_parser/parser.pyx":102 * header_value = "%s, %s" % (hval, header_value) * else: * header_value = "%s %s" % (hval, header_value) # <<<<<<<<<<<<<< * * # add to headers */ /*else*/ { __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 102, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_v_hval); __Pyx_GIVEREF(__pyx_v_hval); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_hval); __Pyx_INCREF(__pyx_v_header_value); __Pyx_GIVEREF(__pyx_v_header_value); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_header_value); __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_s_s_2, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 102, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF_SET(__pyx_v_header_value, __pyx_t_3); __pyx_t_3 = 0; } __pyx_L4:; /* "http_parser/parser.pyx":97 * header_value = bytes_to_str(PyBytes_FromStringAndSize(at, length)) * * if res._last_field in res.headers: # <<<<<<<<<<<<<< * hval = res.headers[res._last_field] * if not res._last_was_value: */ } /* "http_parser/parser.pyx":105 * * # add to headers * res.headers[res._last_field] = header_value # <<<<<<<<<<<<<< * res._last_was_value = True * return 0 */ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_res, __pyx_n_s_headers); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 105, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_res, __pyx_n_s_last_field); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 105, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (unlikely(PyObject_SetItem(__pyx_t_3, __pyx_t_1, __pyx_v_header_value) < 0)) __PYX_ERR(0, 105, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "http_parser/parser.pyx":106 * # add to headers * res.headers[res._last_field] = header_value * res._last_was_value = True # <<<<<<<<<<<<<< * return 0 * */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_res, __pyx_n_s_last_was_value, Py_True) < 0) __PYX_ERR(0, 106, __pyx_L1_error) /* "http_parser/parser.pyx":107 * res.headers[res._last_field] = header_value * res._last_was_value = True * return 0 # <<<<<<<<<<<<<< * * cdef int on_headers_complete_cb(http_parser *parser): */ __pyx_r = 0; goto __pyx_L0; /* "http_parser/parser.pyx":92 * return 0 * * cdef int on_header_value_cb(http_parser *parser, char *at, # <<<<<<<<<<<<<< * size_t length): * res = parser.data */ /* 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("http_parser.parser.on_header_value_cb", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_res); __Pyx_XDECREF(__pyx_v_header_value); __Pyx_XDECREF(__pyx_v_hval); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "http_parser/parser.pyx":109 * return 0 * * cdef int on_headers_complete_cb(http_parser *parser): # <<<<<<<<<<<<<< * res = parser.data * res.headers_complete = True */ static int __pyx_f_11http_parser_6parser_on_headers_complete_cb(struct http_parser *__pyx_v_parser) { PyObject *__pyx_v_res = NULL; PyObject *__pyx_v_encoding = NULL; int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; 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("on_headers_complete_cb", 0); /* "http_parser/parser.pyx":110 * * cdef int on_headers_complete_cb(http_parser *parser): * res = parser.data # <<<<<<<<<<<<<< * res.headers_complete = True * */ __pyx_t_1 = ((PyObject *)__pyx_v_parser->data); __Pyx_INCREF(__pyx_t_1); __pyx_v_res = __pyx_t_1; __pyx_t_1 = 0; /* "http_parser/parser.pyx":111 * cdef int on_headers_complete_cb(http_parser *parser): * res = parser.data * res.headers_complete = True # <<<<<<<<<<<<<< * * if res.decompress: */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_res, __pyx_n_s_headers_complete, Py_True) < 0) __PYX_ERR(0, 111, __pyx_L1_error) /* "http_parser/parser.pyx":113 * res.headers_complete = True * * if res.decompress: # <<<<<<<<<<<<<< * encoding = res.headers.get('content-encoding') * if encoding == 'gzip': */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_res, __pyx_n_s_decompress); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 113, __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, 113, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_2) { /* "http_parser/parser.pyx":114 * * if res.decompress: * encoding = res.headers.get('content-encoding') # <<<<<<<<<<<<<< * if encoding == 'gzip': * res.decompressobj = zlib.decompressobj(16+zlib.MAX_WBITS) */ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_res, __pyx_n_s_headers); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 114, __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, 114, __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 && 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); } } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_3, __pyx_kp_s_content_encoding) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_kp_s_content_encoding); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 114, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v_encoding = __pyx_t_1; __pyx_t_1 = 0; /* "http_parser/parser.pyx":115 * if res.decompress: * encoding = res.headers.get('content-encoding') * if encoding == 'gzip': # <<<<<<<<<<<<<< * res.decompressobj = zlib.decompressobj(16+zlib.MAX_WBITS) * res._decompress_first_try = False */ __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_v_encoding, __pyx_n_s_gzip, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 115, __pyx_L1_error) if (__pyx_t_2) { /* "http_parser/parser.pyx":116 * encoding = res.headers.get('content-encoding') * if encoding == 'gzip': * res.decompressobj = zlib.decompressobj(16+zlib.MAX_WBITS) # <<<<<<<<<<<<<< * res._decompress_first_try = False * del res.headers['content-encoding'] */ __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_zlib); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 116, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_decompressobj); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 116, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_zlib); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 116, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_MAX_WBITS); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 116, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyInt_AddCObj(__pyx_int_16, __pyx_t_5, 16, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 116, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = NULL; 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_1 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_5, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 116, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__Pyx_PyObject_SetAttrStr(__pyx_v_res, __pyx_n_s_decompressobj, __pyx_t_1) < 0) __PYX_ERR(0, 116, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "http_parser/parser.pyx":117 * if encoding == 'gzip': * res.decompressobj = zlib.decompressobj(16+zlib.MAX_WBITS) * res._decompress_first_try = False # <<<<<<<<<<<<<< * del res.headers['content-encoding'] * elif encoding == 'deflate': */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_res, __pyx_n_s_decompress_first_try, Py_False) < 0) __PYX_ERR(0, 117, __pyx_L1_error) /* "http_parser/parser.pyx":118 * res.decompressobj = zlib.decompressobj(16+zlib.MAX_WBITS) * res._decompress_first_try = False * del res.headers['content-encoding'] # <<<<<<<<<<<<<< * elif encoding == 'deflate': * res.decompressobj = zlib.decompressobj() */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_res, __pyx_n_s_headers); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 118, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (unlikely(PyObject_DelItem(__pyx_t_1, __pyx_kp_s_content_encoding) < 0)) __PYX_ERR(0, 118, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "http_parser/parser.pyx":115 * if res.decompress: * encoding = res.headers.get('content-encoding') * if encoding == 'gzip': # <<<<<<<<<<<<<< * res.decompressobj = zlib.decompressobj(16+zlib.MAX_WBITS) * res._decompress_first_try = False */ goto __pyx_L4; } /* "http_parser/parser.pyx":119 * res._decompress_first_try = False * del res.headers['content-encoding'] * elif encoding == 'deflate': # <<<<<<<<<<<<<< * res.decompressobj = zlib.decompressobj() * del res.headers['content-encoding'] */ __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_v_encoding, __pyx_n_s_deflate, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 119, __pyx_L1_error) if (__pyx_t_2) { /* "http_parser/parser.pyx":120 * del res.headers['content-encoding'] * elif encoding == 'deflate': * res.decompressobj = zlib.decompressobj() # <<<<<<<<<<<<<< * del res.headers['content-encoding'] * else: */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_zlib); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_decompressobj); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 120, __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); } } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_4); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__Pyx_PyObject_SetAttrStr(__pyx_v_res, __pyx_n_s_decompressobj, __pyx_t_1) < 0) __PYX_ERR(0, 120, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "http_parser/parser.pyx":121 * elif encoding == 'deflate': * res.decompressobj = zlib.decompressobj() * del res.headers['content-encoding'] # <<<<<<<<<<<<<< * else: * res.decompress = False */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_res, __pyx_n_s_headers); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 121, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (unlikely(PyObject_DelItem(__pyx_t_1, __pyx_kp_s_content_encoding) < 0)) __PYX_ERR(0, 121, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "http_parser/parser.pyx":119 * res._decompress_first_try = False * del res.headers['content-encoding'] * elif encoding == 'deflate': # <<<<<<<<<<<<<< * res.decompressobj = zlib.decompressobj() * del res.headers['content-encoding'] */ goto __pyx_L4; } /* "http_parser/parser.pyx":123 * del res.headers['content-encoding'] * else: * res.decompress = False # <<<<<<<<<<<<<< * * return res.header_only and 1 or 0 */ /*else*/ { if (__Pyx_PyObject_SetAttrStr(__pyx_v_res, __pyx_n_s_decompress, Py_False) < 0) __PYX_ERR(0, 123, __pyx_L1_error) } __pyx_L4:; /* "http_parser/parser.pyx":113 * res.headers_complete = True * * if res.decompress: # <<<<<<<<<<<<<< * encoding = res.headers.get('content-encoding') * if encoding == 'gzip': */ } /* "http_parser/parser.pyx":125 * res.decompress = False * * return res.header_only and 1 or 0 # <<<<<<<<<<<<<< * * cdef int on_message_begin_cb(http_parser *parser): */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_res, __pyx_n_s_header_only); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 125, __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, 125, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (!__pyx_t_2) { goto __pyx_L6_next_or; } else { } if (!1) { } else { __pyx_t_6 = 1; goto __pyx_L5_bool_binop_done; } __pyx_L6_next_or:; __pyx_t_6 = 0; __pyx_L5_bool_binop_done:; __pyx_r = __pyx_t_6; goto __pyx_L0; /* "http_parser/parser.pyx":109 * return 0 * * cdef int on_headers_complete_cb(http_parser *parser): # <<<<<<<<<<<<<< * res = parser.data * res.headers_complete = True */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_WriteUnraisable("http_parser.parser.on_headers_complete_cb", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_res); __Pyx_XDECREF(__pyx_v_encoding); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "http_parser/parser.pyx":127 * return res.header_only and 1 or 0 * * cdef int on_message_begin_cb(http_parser *parser): # <<<<<<<<<<<<<< * res = parser.data * res.message_begin = True */ static int __pyx_f_11http_parser_6parser_on_message_begin_cb(struct http_parser *__pyx_v_parser) { PyObject *__pyx_v_res = NULL; int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("on_message_begin_cb", 0); /* "http_parser/parser.pyx":128 * * cdef int on_message_begin_cb(http_parser *parser): * res = parser.data # <<<<<<<<<<<<<< * res.message_begin = True * return 0 */ __pyx_t_1 = ((PyObject *)__pyx_v_parser->data); __Pyx_INCREF(__pyx_t_1); __pyx_v_res = __pyx_t_1; __pyx_t_1 = 0; /* "http_parser/parser.pyx":129 * cdef int on_message_begin_cb(http_parser *parser): * res = parser.data * res.message_begin = True # <<<<<<<<<<<<<< * return 0 * */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_res, __pyx_n_s_message_begin, Py_True) < 0) __PYX_ERR(0, 129, __pyx_L1_error) /* "http_parser/parser.pyx":130 * res = parser.data * res.message_begin = True * return 0 # <<<<<<<<<<<<<< * * cdef int on_body_cb(http_parser *parser, char *at, */ __pyx_r = 0; goto __pyx_L0; /* "http_parser/parser.pyx":127 * return res.header_only and 1 or 0 * * cdef int on_message_begin_cb(http_parser *parser): # <<<<<<<<<<<<<< * res = parser.data * res.message_begin = True */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_WriteUnraisable("http_parser.parser.on_message_begin_cb", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_res); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "http_parser/parser.pyx":132 * return 0 * * cdef int on_body_cb(http_parser *parser, char *at, # <<<<<<<<<<<<<< * size_t length): * res = parser.data */ static int __pyx_f_11http_parser_6parser_on_body_cb(struct http_parser *__pyx_v_parser, char *__pyx_v_at, size_t __pyx_v_length) { PyObject *__pyx_v_res = NULL; PyObject *__pyx_v_value = NULL; int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; 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; int __pyx_t_11; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; int __pyx_t_14; __Pyx_RefNannySetupContext("on_body_cb", 0); /* "http_parser/parser.pyx":134 * cdef int on_body_cb(http_parser *parser, char *at, * size_t length): * res = parser.data # <<<<<<<<<<<<<< * value = PyBytes_FromStringAndSize(at, length) * */ __pyx_t_1 = ((PyObject *)__pyx_v_parser->data); __Pyx_INCREF(__pyx_t_1); __pyx_v_res = __pyx_t_1; __pyx_t_1 = 0; /* "http_parser/parser.pyx":135 * size_t length): * res = parser.data * value = PyBytes_FromStringAndSize(at, length) # <<<<<<<<<<<<<< * * res.partial_body = True */ __pyx_t_1 = PyBytes_FromStringAndSize(__pyx_v_at, __pyx_v_length); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 135, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_value = __pyx_t_1; __pyx_t_1 = 0; /* "http_parser/parser.pyx":137 * value = PyBytes_FromStringAndSize(at, length) * * res.partial_body = True # <<<<<<<<<<<<<< * * # decompress the value if needed */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_res, __pyx_n_s_partial_body, Py_True) < 0) __PYX_ERR(0, 137, __pyx_L1_error) /* "http_parser/parser.pyx":140 * * # decompress the value if needed * if res.decompress: # <<<<<<<<<<<<<< * if not res._decompress_first_try: * value = res.decompressobj.decompress(value) */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_res, __pyx_n_s_decompress); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 140, __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, 140, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_2) { /* "http_parser/parser.pyx":141 * # decompress the value if needed * if res.decompress: * if not res._decompress_first_try: # <<<<<<<<<<<<<< * value = res.decompressobj.decompress(value) * else: */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_res, __pyx_n_s_decompress_first_try); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 141, __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, 141, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = ((!__pyx_t_2) != 0); if (__pyx_t_3) { /* "http_parser/parser.pyx":142 * if res.decompress: * if not res._decompress_first_try: * value = res.decompressobj.decompress(value) # <<<<<<<<<<<<<< * else: * try: */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_res, __pyx_n_s_decompressobj); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 142, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_decompress); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 142, __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 && likely(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); } } __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_4, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_value); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 142, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF_SET(__pyx_v_value, __pyx_t_1); __pyx_t_1 = 0; /* "http_parser/parser.pyx":141 * # decompress the value if needed * if res.decompress: * if not res._decompress_first_try: # <<<<<<<<<<<<<< * value = res.decompressobj.decompress(value) * else: */ goto __pyx_L4; } /* "http_parser/parser.pyx":144 * value = res.decompressobj.decompress(value) * else: * try: # <<<<<<<<<<<<<< * value = res.decompressobj.decompress(value) * except zlib.error: */ /*else*/ { { __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:*/ { /* "http_parser/parser.pyx":145 * else: * try: * value = res.decompressobj.decompress(value) # <<<<<<<<<<<<<< * except zlib.error: * res.decompressobj = zlib.decompressobj(-zlib.MAX_WBITS) */ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_res, __pyx_n_s_decompressobj); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 145, __pyx_L5_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_decompress); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 145, __pyx_L5_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __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); } } __pyx_t_1 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_value); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 145, __pyx_L5_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF_SET(__pyx_v_value, __pyx_t_1); __pyx_t_1 = 0; /* "http_parser/parser.pyx":144 * value = res.decompressobj.decompress(value) * else: * try: # <<<<<<<<<<<<<< * value = res.decompressobj.decompress(value) * except zlib.error: */ } __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_L5_error:; __Pyx_XDECREF(__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; /* "http_parser/parser.pyx":146 * try: * value = res.decompressobj.decompress(value) * except zlib.error: # <<<<<<<<<<<<<< * res.decompressobj = zlib.decompressobj(-zlib.MAX_WBITS) * value = res.decompressobj.decompress(value) */ __Pyx_ErrFetch(&__pyx_t_1, &__pyx_t_4, &__pyx_t_5); __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_zlib); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 146, __pyx_L7_except_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_error); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 146, __pyx_L7_except_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_t_11 = __Pyx_PyErr_GivenExceptionMatches(__pyx_t_1, __pyx_t_10); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_ErrRestore(__pyx_t_1, __pyx_t_4, __pyx_t_5); __pyx_t_1 = 0; __pyx_t_4 = 0; __pyx_t_5 = 0; if (__pyx_t_11) { __Pyx_AddTraceback("http_parser.parser.on_body_cb", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_4, &__pyx_t_1) < 0) __PYX_ERR(0, 146, __pyx_L7_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_1); /* "http_parser/parser.pyx":147 * value = res.decompressobj.decompress(value) * except zlib.error: * res.decompressobj = zlib.decompressobj(-zlib.MAX_WBITS) # <<<<<<<<<<<<<< * value = res.decompressobj.decompress(value) * res._decompress_first_try = False */ __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_zlib); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 147, __pyx_L7_except_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_decompressobj); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 147, __pyx_L7_except_error) __Pyx_GOTREF(__pyx_t_12); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_zlib); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 147, __pyx_L7_except_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_MAX_WBITS); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 147, __pyx_L7_except_error) __Pyx_GOTREF(__pyx_t_13); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_t_9 = PyNumber_Negative(__pyx_t_13); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 147, __pyx_L7_except_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __pyx_t_13 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(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); } } __pyx_t_10 = (__pyx_t_13) ? __Pyx_PyObject_Call2Args(__pyx_t_12, __pyx_t_13, __pyx_t_9) : __Pyx_PyObject_CallOneArg(__pyx_t_12, __pyx_t_9); __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 147, __pyx_L7_except_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; if (__Pyx_PyObject_SetAttrStr(__pyx_v_res, __pyx_n_s_decompressobj, __pyx_t_10) < 0) __PYX_ERR(0, 147, __pyx_L7_except_error) __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; /* "http_parser/parser.pyx":148 * except zlib.error: * res.decompressobj = zlib.decompressobj(-zlib.MAX_WBITS) * value = res.decompressobj.decompress(value) # <<<<<<<<<<<<<< * res._decompress_first_try = False * */ __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_res, __pyx_n_s_decompressobj); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 148, __pyx_L7_except_error) __Pyx_GOTREF(__pyx_t_12); __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_12, __pyx_n_s_decompress); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 148, __pyx_L7_except_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_t_12 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_9))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_9); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_9, function); } } __pyx_t_10 = (__pyx_t_12) ? __Pyx_PyObject_Call2Args(__pyx_t_9, __pyx_t_12, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_v_value); __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 148, __pyx_L7_except_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF_SET(__pyx_v_value, __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; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; goto __pyx_L6_exception_handled; } goto __pyx_L7_except_error; __pyx_L7_except_error:; /* "http_parser/parser.pyx":144 * value = res.decompressobj.decompress(value) * else: * try: # <<<<<<<<<<<<<< * value = res.decompressobj.decompress(value) * except zlib.error: */ __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_L6_exception_handled:; __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:; } /* "http_parser/parser.pyx":149 * res.decompressobj = zlib.decompressobj(-zlib.MAX_WBITS) * value = res.decompressobj.decompress(value) * res._decompress_first_try = False # <<<<<<<<<<<<<< * * res.body.append(value) */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_res, __pyx_n_s_decompress_first_try, Py_False) < 0) __PYX_ERR(0, 149, __pyx_L1_error) } __pyx_L4:; /* "http_parser/parser.pyx":140 * * # decompress the value if needed * if res.decompress: # <<<<<<<<<<<<<< * if not res._decompress_first_try: * value = res.decompressobj.decompress(value) */ } /* "http_parser/parser.pyx":151 * res._decompress_first_try = False * * res.body.append(value) # <<<<<<<<<<<<<< * return 0 * */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_res, __pyx_n_s_body); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 151, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_14 = __Pyx_PyObject_Append(__pyx_t_1, __pyx_v_value); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(0, 151, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "http_parser/parser.pyx":152 * * res.body.append(value) * return 0 # <<<<<<<<<<<<<< * * cdef int on_message_complete_cb(http_parser *parser): */ __pyx_r = 0; goto __pyx_L0; /* "http_parser/parser.pyx":132 * return 0 * * cdef int on_body_cb(http_parser *parser, char *at, # <<<<<<<<<<<<<< * size_t length): * res = parser.data */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_9); __Pyx_XDECREF(__pyx_t_10); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_13); __Pyx_WriteUnraisable("http_parser.parser.on_body_cb", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_res); __Pyx_XDECREF(__pyx_v_value); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "http_parser/parser.pyx":154 * return 0 * * cdef int on_message_complete_cb(http_parser *parser): # <<<<<<<<<<<<<< * res = parser.data * res.message_complete = True */ static int __pyx_f_11http_parser_6parser_on_message_complete_cb(struct http_parser *__pyx_v_parser) { PyObject *__pyx_v_res = NULL; int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("on_message_complete_cb", 0); /* "http_parser/parser.pyx":155 * * cdef int on_message_complete_cb(http_parser *parser): * res = parser.data # <<<<<<<<<<<<<< * res.message_complete = True * return 0 */ __pyx_t_1 = ((PyObject *)__pyx_v_parser->data); __Pyx_INCREF(__pyx_t_1); __pyx_v_res = __pyx_t_1; __pyx_t_1 = 0; /* "http_parser/parser.pyx":156 * cdef int on_message_complete_cb(http_parser *parser): * res = parser.data * res.message_complete = True # <<<<<<<<<<<<<< * return 0 * */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_res, __pyx_n_s_message_complete, Py_True) < 0) __PYX_ERR(0, 156, __pyx_L1_error) /* "http_parser/parser.pyx":157 * res = parser.data * res.message_complete = True * return 0 # <<<<<<<<<<<<<< * * */ __pyx_r = 0; goto __pyx_L0; /* "http_parser/parser.pyx":154 * return 0 * * cdef int on_message_complete_cb(http_parser *parser): # <<<<<<<<<<<<<< * res = parser.data * res.message_complete = True */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_WriteUnraisable("http_parser.parser.on_message_complete_cb", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_res); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "http_parser/parser.pyx":160 * * * def get_errno_name(errno): # <<<<<<<<<<<<<< * if not HPE_OK <= errno <= HPE_UNKNOWN: * raise ValueError('errno out of range') */ /* Python wrapper */ static PyObject *__pyx_pw_11http_parser_6parser_1get_errno_name(PyObject *__pyx_self, PyObject *__pyx_v_errno); /*proto*/ static PyMethodDef __pyx_mdef_11http_parser_6parser_1get_errno_name = {"get_errno_name", (PyCFunction)__pyx_pw_11http_parser_6parser_1get_errno_name, METH_O, 0}; static PyObject *__pyx_pw_11http_parser_6parser_1get_errno_name(PyObject *__pyx_self, PyObject *__pyx_v_errno) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_errno_name (wrapper)", 0); __pyx_r = __pyx_pf_11http_parser_6parser_get_errno_name(__pyx_self, ((PyObject *)__pyx_v_errno)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_11http_parser_6parser_get_errno_name(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_errno) { 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; int __pyx_t_5; enum http_errno __pyx_t_6; __Pyx_RefNannySetupContext("get_errno_name", 0); /* "http_parser/parser.pyx":161 * * def get_errno_name(errno): * if not HPE_OK <= errno <= HPE_UNKNOWN: # <<<<<<<<<<<<<< * raise ValueError('errno out of range') * return http_errno_name(errno) */ __pyx_t_1 = __Pyx_PyInt_From_enum__http_errno(HPE_OK); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 161, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyObject_RichCompare(__pyx_t_1, __pyx_v_errno, Py_LE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 161, __pyx_L1_error) if (__Pyx_PyObject_IsTrue(__pyx_t_2)) { __Pyx_DECREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyInt_From_enum__http_errno(HPE_UNKNOWN); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 161, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = PyObject_RichCompare(__pyx_v_errno, __pyx_t_3, Py_LE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 161, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 161, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_5 = ((!__pyx_t_4) != 0); if (unlikely(__pyx_t_5)) { /* "http_parser/parser.pyx":162 * def get_errno_name(errno): * if not HPE_OK <= errno <= HPE_UNKNOWN: * raise ValueError('errno out of range') # <<<<<<<<<<<<<< * return http_errno_name(errno) * */ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 162, __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, 162, __pyx_L1_error) /* "http_parser/parser.pyx":161 * * def get_errno_name(errno): * if not HPE_OK <= errno <= HPE_UNKNOWN: # <<<<<<<<<<<<<< * raise ValueError('errno out of range') * return http_errno_name(errno) */ } /* "http_parser/parser.pyx":163 * if not HPE_OK <= errno <= HPE_UNKNOWN: * raise ValueError('errno out of range') * return http_errno_name(errno) # <<<<<<<<<<<<<< * * def get_errno_description(errno): */ __Pyx_XDECREF(__pyx_r); __pyx_t_6 = ((enum http_errno)__Pyx_PyInt_As_enum__http_errno(__pyx_v_errno)); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 163, __pyx_L1_error) __pyx_t_2 = __Pyx_PyBytes_FromString(http_errno_name(((enum http_errno)__pyx_t_6))); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 163, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "http_parser/parser.pyx":160 * * * def get_errno_name(errno): # <<<<<<<<<<<<<< * if not HPE_OK <= errno <= HPE_UNKNOWN: * raise ValueError('errno out of range') */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("http_parser.parser.get_errno_name", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "http_parser/parser.pyx":165 * return http_errno_name(errno) * * def get_errno_description(errno): # <<<<<<<<<<<<<< * if not HPE_OK <= errno <= HPE_UNKNOWN: * raise ValueError('errno out of range') */ /* Python wrapper */ static PyObject *__pyx_pw_11http_parser_6parser_3get_errno_description(PyObject *__pyx_self, PyObject *__pyx_v_errno); /*proto*/ static PyMethodDef __pyx_mdef_11http_parser_6parser_3get_errno_description = {"get_errno_description", (PyCFunction)__pyx_pw_11http_parser_6parser_3get_errno_description, METH_O, 0}; static PyObject *__pyx_pw_11http_parser_6parser_3get_errno_description(PyObject *__pyx_self, PyObject *__pyx_v_errno) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_errno_description (wrapper)", 0); __pyx_r = __pyx_pf_11http_parser_6parser_2get_errno_description(__pyx_self, ((PyObject *)__pyx_v_errno)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_11http_parser_6parser_2get_errno_description(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_errno) { 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; int __pyx_t_5; enum http_errno __pyx_t_6; __Pyx_RefNannySetupContext("get_errno_description", 0); /* "http_parser/parser.pyx":166 * * def get_errno_description(errno): * if not HPE_OK <= errno <= HPE_UNKNOWN: # <<<<<<<<<<<<<< * raise ValueError('errno out of range') * return http_errno_description(errno) */ __pyx_t_1 = __Pyx_PyInt_From_enum__http_errno(HPE_OK); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 166, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyObject_RichCompare(__pyx_t_1, __pyx_v_errno, Py_LE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 166, __pyx_L1_error) if (__Pyx_PyObject_IsTrue(__pyx_t_2)) { __Pyx_DECREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyInt_From_enum__http_errno(HPE_UNKNOWN); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 166, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = PyObject_RichCompare(__pyx_v_errno, __pyx_t_3, Py_LE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 166, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 166, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_5 = ((!__pyx_t_4) != 0); if (unlikely(__pyx_t_5)) { /* "http_parser/parser.pyx":167 * def get_errno_description(errno): * if not HPE_OK <= errno <= HPE_UNKNOWN: * raise ValueError('errno out of range') # <<<<<<<<<<<<<< * return http_errno_description(errno) * */ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 167, __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, 167, __pyx_L1_error) /* "http_parser/parser.pyx":166 * * def get_errno_description(errno): * if not HPE_OK <= errno <= HPE_UNKNOWN: # <<<<<<<<<<<<<< * raise ValueError('errno out of range') * return http_errno_description(errno) */ } /* "http_parser/parser.pyx":168 * if not HPE_OK <= errno <= HPE_UNKNOWN: * raise ValueError('errno out of range') * return http_errno_description(errno) # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __pyx_t_6 = ((enum http_errno)__Pyx_PyInt_As_enum__http_errno(__pyx_v_errno)); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 168, __pyx_L1_error) __pyx_t_2 = __Pyx_PyBytes_FromString(http_errno_description(((enum http_errno)__pyx_t_6))); 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; /* "http_parser/parser.pyx":165 * return http_errno_name(errno) * * def get_errno_description(errno): # <<<<<<<<<<<<<< * if not HPE_OK <= errno <= HPE_UNKNOWN: * raise ValueError('errno out of range') */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("http_parser.parser.get_errno_description", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "http_parser/parser.pyx":173 * class _ParserData(object): * * def __init__(self, decompress=False, header_only=False): # <<<<<<<<<<<<<< * self.url = "" * self.body = [] */ /* Python wrapper */ static PyObject *__pyx_pw_11http_parser_6parser_11_ParserData_1__init__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyMethodDef __pyx_mdef_11http_parser_6parser_11_ParserData_1__init__ = {"__init__", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_11http_parser_6parser_11_ParserData_1__init__, METH_VARARGS|METH_KEYWORDS, 0}; static PyObject *__pyx_pw_11http_parser_6parser_11_ParserData_1__init__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_self = 0; PyObject *__pyx_v_decompress = 0; PyObject *__pyx_v_header_only = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_decompress,&__pyx_n_s_header_only,0}; PyObject* values[3] = {0,0,0}; values[1] = ((PyObject *)((PyObject *)Py_False)); values[2] = ((PyObject *)((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 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_self)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_decompress); if (value) { values[1] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_header_only); 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, 173, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_self = values[0]; __pyx_v_decompress = values[1]; __pyx_v_header_only = 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, 173, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("http_parser.parser._ParserData.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_11http_parser_6parser_11_ParserData___init__(__pyx_self, __pyx_v_self, __pyx_v_decompress, __pyx_v_header_only); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_11http_parser_6parser_11_ParserData___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_decompress, PyObject *__pyx_v_header_only) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; __Pyx_RefNannySetupContext("__init__", 0); /* "http_parser/parser.pyx":174 * * def __init__(self, decompress=False, header_only=False): * self.url = "" # <<<<<<<<<<<<<< * self.body = [] * self.headers = IOrderedDict() */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_url, __pyx_kp_s_) < 0) __PYX_ERR(0, 174, __pyx_L1_error) /* "http_parser/parser.pyx":175 * def __init__(self, decompress=False, header_only=False): * self.url = "" * self.body = [] # <<<<<<<<<<<<<< * self.headers = IOrderedDict() * self.header_only = header_only */ __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 175, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_body, __pyx_t_1) < 0) __PYX_ERR(0, 175, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "http_parser/parser.pyx":176 * self.url = "" * self.body = [] * self.headers = IOrderedDict() # <<<<<<<<<<<<<< * self.header_only = header_only * */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_IOrderedDict); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 176, __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); } } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 176, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_headers, __pyx_t_1) < 0) __PYX_ERR(0, 176, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "http_parser/parser.pyx":177 * self.body = [] * self.headers = IOrderedDict() * self.header_only = header_only # <<<<<<<<<<<<<< * * self.decompress = decompress */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_header_only, __pyx_v_header_only) < 0) __PYX_ERR(0, 177, __pyx_L1_error) /* "http_parser/parser.pyx":179 * self.header_only = header_only * * self.decompress = decompress # <<<<<<<<<<<<<< * self.decompressobj = None * self._decompress_first_try = True */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_decompress, __pyx_v_decompress) < 0) __PYX_ERR(0, 179, __pyx_L1_error) /* "http_parser/parser.pyx":180 * * self.decompress = decompress * self.decompressobj = None # <<<<<<<<<<<<<< * self._decompress_first_try = True * */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_decompressobj, Py_None) < 0) __PYX_ERR(0, 180, __pyx_L1_error) /* "http_parser/parser.pyx":181 * self.decompress = decompress * self.decompressobj = None * self._decompress_first_try = True # <<<<<<<<<<<<<< * * self.chunked = False */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_decompress_first_try, Py_True) < 0) __PYX_ERR(0, 181, __pyx_L1_error) /* "http_parser/parser.pyx":183 * self._decompress_first_try = True * * self.chunked = False # <<<<<<<<<<<<<< * * self.headers_complete = False */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_chunked, Py_False) < 0) __PYX_ERR(0, 183, __pyx_L1_error) /* "http_parser/parser.pyx":185 * self.chunked = False * * self.headers_complete = False # <<<<<<<<<<<<<< * self.partial_body = False * self.message_begin = False */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_headers_complete, Py_False) < 0) __PYX_ERR(0, 185, __pyx_L1_error) /* "http_parser/parser.pyx":186 * * self.headers_complete = False * self.partial_body = False # <<<<<<<<<<<<<< * self.message_begin = False * self.message_complete = False */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_partial_body, Py_False) < 0) __PYX_ERR(0, 186, __pyx_L1_error) /* "http_parser/parser.pyx":187 * self.headers_complete = False * self.partial_body = False * self.message_begin = False # <<<<<<<<<<<<<< * self.message_complete = False * */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_message_begin, Py_False) < 0) __PYX_ERR(0, 187, __pyx_L1_error) /* "http_parser/parser.pyx":188 * self.partial_body = False * self.message_begin = False * self.message_complete = False # <<<<<<<<<<<<<< * * self._last_field = "" */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_message_complete, Py_False) < 0) __PYX_ERR(0, 188, __pyx_L1_error) /* "http_parser/parser.pyx":190 * self.message_complete = False * * self._last_field = "" # <<<<<<<<<<<<<< * self._last_was_value = False * */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_last_field, __pyx_kp_s_) < 0) __PYX_ERR(0, 190, __pyx_L1_error) /* "http_parser/parser.pyx":191 * * self._last_field = "" * self._last_was_value = False # <<<<<<<<<<<<<< * * cdef class HttpParser: */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_last_was_value, Py_False) < 0) __PYX_ERR(0, 191, __pyx_L1_error) /* "http_parser/parser.pyx":173 * class _ParserData(object): * * def __init__(self, decompress=False, header_only=False): # <<<<<<<<<<<<<< * self.url = "" * self.body = [] */ /* 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_AddTraceback("http_parser.parser._ParserData.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "http_parser/parser.pyx":205 * cdef object _parsed_url * * def __init__(self, kind=2, decompress=False, header_only=False): # <<<<<<<<<<<<<< * """ constructor of HttpParser object. * : */ /* Python wrapper */ static int __pyx_pw_11http_parser_6parser_10HttpParser_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_11http_parser_6parser_10HttpParser___init__[] = " constructor of HttpParser object.\n :\n attr kind: Int, could be 0 to parseonly requests,\n 1 to parse only responses or 2 if we want to let\n the parser detect the type.\n "; #if CYTHON_COMPILING_IN_CPYTHON struct wrapperbase __pyx_wrapperbase_11http_parser_6parser_10HttpParser___init__; #endif static int __pyx_pw_11http_parser_6parser_10HttpParser_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_kind = 0; PyObject *__pyx_v_decompress = 0; PyObject *__pyx_v_header_only = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_kind,&__pyx_n_s_decompress,&__pyx_n_s_header_only,0}; PyObject* values[3] = {0,0,0}; values[0] = ((PyObject *)__pyx_int_2); values[1] = ((PyObject *)Py_False); values[2] = ((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 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; 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 = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_kind); if (value) { values[0] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_decompress); if (value) { values[1] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_header_only); 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, 205, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_kind = values[0]; __pyx_v_decompress = values[1]; __pyx_v_header_only = values[2]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__init__", 0, 0, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 205, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("http_parser.parser.HttpParser.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return -1; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_11http_parser_6parser_10HttpParser___init__(((struct __pyx_obj_11http_parser_6parser_HttpParser *)__pyx_v_self), __pyx_v_kind, __pyx_v_decompress, __pyx_v_header_only); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_11http_parser_6parser_10HttpParser___init__(struct __pyx_obj_11http_parser_6parser_HttpParser *__pyx_v_self, PyObject *__pyx_v_kind, PyObject *__pyx_v_decompress, PyObject *__pyx_v_header_only) { enum http_parser_type __pyx_v_parser_type; int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; __Pyx_RefNannySetupContext("__init__", 0); /* "http_parser/parser.pyx":214 * * # set parser type * if kind == 2: # <<<<<<<<<<<<<< * parser_type = HTTP_BOTH * elif kind == 1: */ __pyx_t_1 = __Pyx_PyInt_EqObjC(__pyx_v_kind, __pyx_int_2, 2, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 214, __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, 214, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_2) { /* "http_parser/parser.pyx":215 * # set parser type * if kind == 2: * parser_type = HTTP_BOTH # <<<<<<<<<<<<<< * elif kind == 1: * parser_type = HTTP_RESPONSE */ __pyx_v_parser_type = HTTP_BOTH; /* "http_parser/parser.pyx":214 * * # set parser type * if kind == 2: # <<<<<<<<<<<<<< * parser_type = HTTP_BOTH * elif kind == 1: */ goto __pyx_L3; } /* "http_parser/parser.pyx":216 * if kind == 2: * parser_type = HTTP_BOTH * elif kind == 1: # <<<<<<<<<<<<<< * parser_type = HTTP_RESPONSE * elif kind == 0: */ __pyx_t_1 = __Pyx_PyInt_EqObjC(__pyx_v_kind, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 216, __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, 216, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_2) { /* "http_parser/parser.pyx":217 * parser_type = HTTP_BOTH * elif kind == 1: * parser_type = HTTP_RESPONSE # <<<<<<<<<<<<<< * elif kind == 0: * parser_type = HTTP_REQUEST */ __pyx_v_parser_type = HTTP_RESPONSE; /* "http_parser/parser.pyx":216 * if kind == 2: * parser_type = HTTP_BOTH * elif kind == 1: # <<<<<<<<<<<<<< * parser_type = HTTP_RESPONSE * elif kind == 0: */ goto __pyx_L3; } /* "http_parser/parser.pyx":218 * elif kind == 1: * parser_type = HTTP_RESPONSE * elif kind == 0: # <<<<<<<<<<<<<< * parser_type = HTTP_REQUEST * */ __pyx_t_1 = __Pyx_PyInt_EqObjC(__pyx_v_kind, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 218, __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, 218, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_2) { /* "http_parser/parser.pyx":219 * parser_type = HTTP_RESPONSE * elif kind == 0: * parser_type = HTTP_REQUEST # <<<<<<<<<<<<<< * * # initialize parser */ __pyx_v_parser_type = HTTP_REQUEST; /* "http_parser/parser.pyx":218 * elif kind == 1: * parser_type = HTTP_RESPONSE * elif kind == 0: # <<<<<<<<<<<<<< * parser_type = HTTP_REQUEST * */ } __pyx_L3:; /* "http_parser/parser.pyx":222 * * # initialize parser * http_parser_init(&self._parser, parser_type) # <<<<<<<<<<<<<< * self._data = _ParserData(decompress=decompress, header_only=header_only) * self._parser.data = self._data */ http_parser_init((&__pyx_v_self->_parser), __pyx_v_parser_type); /* "http_parser/parser.pyx":223 * # initialize parser * http_parser_init(&self._parser, parser_type) * self._data = _ParserData(decompress=decompress, header_only=header_only) # <<<<<<<<<<<<<< * self._parser.data = self._data * self._parsed_url = None */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_ParserData); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 223, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 223, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_decompress, __pyx_v_decompress) < 0) __PYX_ERR(0, 223, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_header_only, __pyx_v_header_only) < 0) __PYX_ERR(0, 223, __pyx_L1_error) __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 223, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GIVEREF(__pyx_t_4); __Pyx_GOTREF(__pyx_v_self->_data); __Pyx_DECREF(__pyx_v_self->_data); __pyx_v_self->_data = __pyx_t_4; __pyx_t_4 = 0; /* "http_parser/parser.pyx":224 * http_parser_init(&self._parser, parser_type) * self._data = _ParserData(decompress=decompress, header_only=header_only) * self._parser.data = self._data # <<<<<<<<<<<<<< * self._parsed_url = None * self._path = "" */ __pyx_v_self->_parser.data = ((void *)__pyx_v_self->_data); /* "http_parser/parser.pyx":225 * self._data = _ParserData(decompress=decompress, header_only=header_only) * self._parser.data = self._data * self._parsed_url = None # <<<<<<<<<<<<<< * self._path = "" * self._query_string = "" */ __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); __Pyx_GOTREF(__pyx_v_self->_parsed_url); __Pyx_DECREF(__pyx_v_self->_parsed_url); __pyx_v_self->_parsed_url = Py_None; /* "http_parser/parser.pyx":226 * self._parser.data = self._data * self._parsed_url = None * self._path = "" # <<<<<<<<<<<<<< * self._query_string = "" * self._fragment = "" */ __Pyx_INCREF(__pyx_kp_s_); __Pyx_GIVEREF(__pyx_kp_s_); __Pyx_GOTREF(__pyx_v_self->_path); __Pyx_DECREF(__pyx_v_self->_path); __pyx_v_self->_path = __pyx_kp_s_; /* "http_parser/parser.pyx":227 * self._parsed_url = None * self._path = "" * self._query_string = "" # <<<<<<<<<<<<<< * self._fragment = "" * */ __Pyx_INCREF(__pyx_kp_s_); __Pyx_GIVEREF(__pyx_kp_s_); __Pyx_GOTREF(__pyx_v_self->_query_string); __Pyx_DECREF(__pyx_v_self->_query_string); __pyx_v_self->_query_string = __pyx_kp_s_; /* "http_parser/parser.pyx":228 * self._path = "" * self._query_string = "" * self._fragment = "" # <<<<<<<<<<<<<< * * # set callback */ __Pyx_INCREF(__pyx_kp_s_); __Pyx_GIVEREF(__pyx_kp_s_); __Pyx_GOTREF(__pyx_v_self->_fragment); __Pyx_DECREF(__pyx_v_self->_fragment); __pyx_v_self->_fragment = __pyx_kp_s_; /* "http_parser/parser.pyx":231 * * # set callback * self._settings.on_url = on_url_cb # <<<<<<<<<<<<<< * self._settings.on_body = on_body_cb * self._settings.on_header_field = on_header_field_cb */ __pyx_v_self->_settings.on_url = ((http_data_cb)__pyx_f_11http_parser_6parser_on_url_cb); /* "http_parser/parser.pyx":232 * # set callback * self._settings.on_url = on_url_cb * self._settings.on_body = on_body_cb # <<<<<<<<<<<<<< * self._settings.on_header_field = on_header_field_cb * self._settings.on_header_value = on_header_value_cb */ __pyx_v_self->_settings.on_body = ((http_data_cb)__pyx_f_11http_parser_6parser_on_body_cb); /* "http_parser/parser.pyx":233 * self._settings.on_url = on_url_cb * self._settings.on_body = on_body_cb * self._settings.on_header_field = on_header_field_cb # <<<<<<<<<<<<<< * self._settings.on_header_value = on_header_value_cb * self._settings.on_headers_complete = on_headers_complete_cb */ __pyx_v_self->_settings.on_header_field = ((http_data_cb)__pyx_f_11http_parser_6parser_on_header_field_cb); /* "http_parser/parser.pyx":234 * self._settings.on_body = on_body_cb * self._settings.on_header_field = on_header_field_cb * self._settings.on_header_value = on_header_value_cb # <<<<<<<<<<<<<< * self._settings.on_headers_complete = on_headers_complete_cb * self._settings.on_message_begin = on_message_begin_cb */ __pyx_v_self->_settings.on_header_value = ((http_data_cb)__pyx_f_11http_parser_6parser_on_header_value_cb); /* "http_parser/parser.pyx":235 * self._settings.on_header_field = on_header_field_cb * self._settings.on_header_value = on_header_value_cb * self._settings.on_headers_complete = on_headers_complete_cb # <<<<<<<<<<<<<< * self._settings.on_message_begin = on_message_begin_cb * self._settings.on_message_complete = on_message_complete_cb */ __pyx_v_self->_settings.on_headers_complete = ((http_cb)__pyx_f_11http_parser_6parser_on_headers_complete_cb); /* "http_parser/parser.pyx":236 * self._settings.on_header_value = on_header_value_cb * self._settings.on_headers_complete = on_headers_complete_cb * self._settings.on_message_begin = on_message_begin_cb # <<<<<<<<<<<<<< * self._settings.on_message_complete = on_message_complete_cb * */ __pyx_v_self->_settings.on_message_begin = ((http_cb)__pyx_f_11http_parser_6parser_on_message_begin_cb); /* "http_parser/parser.pyx":237 * self._settings.on_headers_complete = on_headers_complete_cb * self._settings.on_message_begin = on_message_begin_cb * self._settings.on_message_complete = on_message_complete_cb # <<<<<<<<<<<<<< * * def execute(self, char *data, size_t length): */ __pyx_v_self->_settings.on_message_complete = ((http_cb)__pyx_f_11http_parser_6parser_on_message_complete_cb); /* "http_parser/parser.pyx":205 * cdef object _parsed_url * * def __init__(self, kind=2, decompress=False, header_only=False): # <<<<<<<<<<<<<< * """ constructor of HttpParser object. * : */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("http_parser.parser.HttpParser.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "http_parser/parser.pyx":239 * self._settings.on_message_complete = on_message_complete_cb * * def execute(self, char *data, size_t length): # <<<<<<<<<<<<<< * """ Execute the parser with the last chunk. We pass the length * to let the parser know when EOF has been received. In this case */ /* Python wrapper */ static PyObject *__pyx_pw_11http_parser_6parser_10HttpParser_3execute(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_11http_parser_6parser_10HttpParser_2execute[] = " Execute the parser with the last chunk. We pass the length\n to let the parser know when EOF has been received. In this case\n length == 0.\n\n :return recved: Int, received length of the data parsed. if\n recvd != length you should return an error.\n "; static PyObject *__pyx_pw_11http_parser_6parser_10HttpParser_3execute(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { char *__pyx_v_data; size_t __pyx_v_length; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("execute (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_data,&__pyx_n_s_length,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); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_data)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_length)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("execute", 1, 2, 2, 1); __PYX_ERR(0, 239, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "execute") < 0)) __PYX_ERR(0, 239, __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_data = __Pyx_PyObject_AsWritableString(values[0]); if (unlikely((!__pyx_v_data) && PyErr_Occurred())) __PYX_ERR(0, 239, __pyx_L3_error) __pyx_v_length = __Pyx_PyInt_As_size_t(values[1]); if (unlikely((__pyx_v_length == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 239, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("execute", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 239, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("http_parser.parser.HttpParser.execute", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_11http_parser_6parser_10HttpParser_2execute(((struct __pyx_obj_11http_parser_6parser_HttpParser *)__pyx_v_self), __pyx_v_data, __pyx_v_length); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_11http_parser_6parser_10HttpParser_2execute(struct __pyx_obj_11http_parser_6parser_HttpParser *__pyx_v_self, char *__pyx_v_data, size_t __pyx_v_length) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("execute", 0); /* "http_parser/parser.pyx":247 * recvd != length you should return an error. * """ * return http_parser_execute(&self._parser, &self._settings, # <<<<<<<<<<<<<< * data, length) * */ __Pyx_XDECREF(__pyx_r); /* "http_parser/parser.pyx":248 * """ * return http_parser_execute(&self._parser, &self._settings, * data, length) # <<<<<<<<<<<<<< * * def get_errno(self): */ __pyx_t_1 = __Pyx_PyInt_FromSize_t(http_parser_execute((&__pyx_v_self->_parser), (&__pyx_v_self->_settings), __pyx_v_data, __pyx_v_length)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 247, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "http_parser/parser.pyx":239 * self._settings.on_message_complete = on_message_complete_cb * * def execute(self, char *data, size_t length): # <<<<<<<<<<<<<< * """ Execute the parser with the last chunk. We pass the length * to let the parser know when EOF has been received. In this case */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("http_parser.parser.HttpParser.execute", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "http_parser/parser.pyx":250 * data, length) * * def get_errno(self): # <<<<<<<<<<<<<< * """ get error state """ * return self._parser.http_errno */ /* Python wrapper */ static PyObject *__pyx_pw_11http_parser_6parser_10HttpParser_5get_errno(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_11http_parser_6parser_10HttpParser_4get_errno[] = " get error state "; static PyObject *__pyx_pw_11http_parser_6parser_10HttpParser_5get_errno(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_errno (wrapper)", 0); __pyx_r = __pyx_pf_11http_parser_6parser_10HttpParser_4get_errno(((struct __pyx_obj_11http_parser_6parser_HttpParser *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_11http_parser_6parser_10HttpParser_4get_errno(struct __pyx_obj_11http_parser_6parser_HttpParser *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("get_errno", 0); /* "http_parser/parser.pyx":252 * def get_errno(self): * """ get error state """ * return self._parser.http_errno # <<<<<<<<<<<<<< * * def get_version(self): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_unsigned_char(__pyx_v_self->_parser.http_errno); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "http_parser/parser.pyx":250 * data, length) * * def get_errno(self): # <<<<<<<<<<<<<< * """ get error state """ * return self._parser.http_errno */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("http_parser.parser.HttpParser.get_errno", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "http_parser/parser.pyx":254 * return self._parser.http_errno * * def get_version(self): # <<<<<<<<<<<<<< * """ get HTTP version """ * return (self._parser.http_major, self._parser.http_minor) */ /* Python wrapper */ static PyObject *__pyx_pw_11http_parser_6parser_10HttpParser_7get_version(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_11http_parser_6parser_10HttpParser_6get_version[] = " get HTTP version "; static PyObject *__pyx_pw_11http_parser_6parser_10HttpParser_7get_version(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_version (wrapper)", 0); __pyx_r = __pyx_pf_11http_parser_6parser_10HttpParser_6get_version(((struct __pyx_obj_11http_parser_6parser_HttpParser *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_11http_parser_6parser_10HttpParser_6get_version(struct __pyx_obj_11http_parser_6parser_HttpParser *__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("get_version", 0); /* "http_parser/parser.pyx":256 * def get_version(self): * """ get HTTP version """ * return (self._parser.http_major, self._parser.http_minor) # <<<<<<<<<<<<<< * * def get_method(self): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_unsigned_short(__pyx_v_self->_parser.http_major); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 256, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyInt_From_unsigned_short(__pyx_v_self->_parser.http_minor); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 256, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 256, __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; /* "http_parser/parser.pyx":254 * return self._parser.http_errno * * def get_version(self): # <<<<<<<<<<<<<< * """ get HTTP version """ * return (self._parser.http_major, self._parser.http_minor) */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("http_parser.parser.HttpParser.get_version", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "http_parser/parser.pyx":258 * return (self._parser.http_major, self._parser.http_minor) * * def get_method(self): # <<<<<<<<<<<<<< * """ get HTTP method as string""" * return bytes_to_str(http_method_str(self._parser.method)) */ /* Python wrapper */ static PyObject *__pyx_pw_11http_parser_6parser_10HttpParser_9get_method(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_11http_parser_6parser_10HttpParser_8get_method[] = " get HTTP method as string"; static PyObject *__pyx_pw_11http_parser_6parser_10HttpParser_9get_method(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_method (wrapper)", 0); __pyx_r = __pyx_pf_11http_parser_6parser_10HttpParser_8get_method(((struct __pyx_obj_11http_parser_6parser_HttpParser *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_11http_parser_6parser_10HttpParser_8get_method(struct __pyx_obj_11http_parser_6parser_HttpParser *__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; __Pyx_RefNannySetupContext("get_method", 0); /* "http_parser/parser.pyx":260 * def get_method(self): * """ get HTTP method as string""" * return bytes_to_str(http_method_str(self._parser.method)) # <<<<<<<<<<<<<< * * def get_status_code(self): */ __Pyx_XDECREF(__pyx_r); __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_bytes_to_str); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 260, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyBytes_FromString(http_method_str(((enum http_method)__pyx_v_self->_parser.method))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 260, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __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); } } __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 260, __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; /* "http_parser/parser.pyx":258 * return (self._parser.http_major, self._parser.http_minor) * * def get_method(self): # <<<<<<<<<<<<<< * """ get HTTP method as string""" * return bytes_to_str(http_method_str(self._parser.method)) */ /* 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("http_parser.parser.HttpParser.get_method", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "http_parser/parser.pyx":262 * return bytes_to_str(http_method_str(self._parser.method)) * * def get_status_code(self): # <<<<<<<<<<<<<< * """ get status code of a response as integer """ * return self._parser.status_code */ /* Python wrapper */ static PyObject *__pyx_pw_11http_parser_6parser_10HttpParser_11get_status_code(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_11http_parser_6parser_10HttpParser_10get_status_code[] = " get status code of a response as integer "; static PyObject *__pyx_pw_11http_parser_6parser_10HttpParser_11get_status_code(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_status_code (wrapper)", 0); __pyx_r = __pyx_pf_11http_parser_6parser_10HttpParser_10get_status_code(((struct __pyx_obj_11http_parser_6parser_HttpParser *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_11http_parser_6parser_10HttpParser_10get_status_code(struct __pyx_obj_11http_parser_6parser_HttpParser *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("get_status_code", 0); /* "http_parser/parser.pyx":264 * def get_status_code(self): * """ get status code of a response as integer """ * return self._parser.status_code # <<<<<<<<<<<<<< * * def get_url(self): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_unsigned_short(__pyx_v_self->_parser.status_code); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 264, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "http_parser/parser.pyx":262 * return bytes_to_str(http_method_str(self._parser.method)) * * def get_status_code(self): # <<<<<<<<<<<<<< * """ get status code of a response as integer """ * return self._parser.status_code */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("http_parser.parser.HttpParser.get_status_code", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "http_parser/parser.pyx":266 * return self._parser.status_code * * def get_url(self): # <<<<<<<<<<<<<< * """ get full url of the request """ * return self._data.url */ /* Python wrapper */ static PyObject *__pyx_pw_11http_parser_6parser_10HttpParser_13get_url(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_11http_parser_6parser_10HttpParser_12get_url[] = " get full url of the request "; static PyObject *__pyx_pw_11http_parser_6parser_10HttpParser_13get_url(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_url (wrapper)", 0); __pyx_r = __pyx_pf_11http_parser_6parser_10HttpParser_12get_url(((struct __pyx_obj_11http_parser_6parser_HttpParser *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_11http_parser_6parser_10HttpParser_12get_url(struct __pyx_obj_11http_parser_6parser_HttpParser *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("get_url", 0); /* "http_parser/parser.pyx":268 * def get_url(self): * """ get full url of the request """ * return self._data.url # <<<<<<<<<<<<<< * * def maybe_parse_url(self): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_data, __pyx_n_s_url); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 268, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "http_parser/parser.pyx":266 * return self._parser.status_code * * def get_url(self): # <<<<<<<<<<<<<< * """ get full url of the request """ * return self._data.url */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("http_parser.parser.HttpParser.get_url", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "http_parser/parser.pyx":270 * return self._data.url * * def maybe_parse_url(self): # <<<<<<<<<<<<<< * raw_url = self.get_url() * if not self._parsed_url and raw_url: */ /* Python wrapper */ static PyObject *__pyx_pw_11http_parser_6parser_10HttpParser_15maybe_parse_url(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_pw_11http_parser_6parser_10HttpParser_15maybe_parse_url(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("maybe_parse_url (wrapper)", 0); __pyx_r = __pyx_pf_11http_parser_6parser_10HttpParser_14maybe_parse_url(((struct __pyx_obj_11http_parser_6parser_HttpParser *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_11http_parser_6parser_10HttpParser_14maybe_parse_url(struct __pyx_obj_11http_parser_6parser_HttpParser *__pyx_v_self) { PyObject *__pyx_v_raw_url = 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; int __pyx_t_5; int __pyx_t_6; __Pyx_RefNannySetupContext("maybe_parse_url", 0); /* "http_parser/parser.pyx":271 * * def maybe_parse_url(self): * raw_url = self.get_url() # <<<<<<<<<<<<<< * if not self._parsed_url and raw_url: * self._parsed_url = urlsplit(raw_url) */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_get_url); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 271, __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); } } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 271, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_raw_url = __pyx_t_1; __pyx_t_1 = 0; /* "http_parser/parser.pyx":272 * def maybe_parse_url(self): * raw_url = self.get_url() * if not self._parsed_url and raw_url: # <<<<<<<<<<<<<< * self._parsed_url = urlsplit(raw_url) * self._path = self._parsed_url.path or "" */ __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_v_self->_parsed_url); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 272, __pyx_L1_error) __pyx_t_6 = ((!__pyx_t_5) != 0); if (__pyx_t_6) { } else { __pyx_t_4 = __pyx_t_6; goto __pyx_L4_bool_binop_done; } __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_v_raw_url); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 272, __pyx_L1_error) __pyx_t_4 = __pyx_t_6; __pyx_L4_bool_binop_done:; if (__pyx_t_4) { /* "http_parser/parser.pyx":273 * raw_url = self.get_url() * if not self._parsed_url and raw_url: * self._parsed_url = urlsplit(raw_url) # <<<<<<<<<<<<<< * self._path = self._parsed_url.path or "" * self._query_string = self._parsed_url.query or "" */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_urlsplit); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 273, __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); } } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_raw_url) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_raw_url); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 273, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v_self->_parsed_url); __Pyx_DECREF(__pyx_v_self->_parsed_url); __pyx_v_self->_parsed_url = __pyx_t_1; __pyx_t_1 = 0; /* "http_parser/parser.pyx":274 * if not self._parsed_url and raw_url: * self._parsed_url = urlsplit(raw_url) * self._path = self._parsed_url.path or "" # <<<<<<<<<<<<<< * self._query_string = self._parsed_url.query or "" * self._fragment = self._parsed_url.fragment or "" */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_parsed_url, __pyx_n_s_path); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 274, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 274, __pyx_L1_error) if (!__pyx_t_4) { __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } else { if (!(likely(PyString_CheckExact(__pyx_t_2))||((__pyx_t_2) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "str", Py_TYPE(__pyx_t_2)->tp_name), 0))) __PYX_ERR(0, 274, __pyx_L1_error) __Pyx_INCREF(__pyx_t_2); __pyx_t_1 = __pyx_t_2; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; goto __pyx_L6_bool_binop_done; } __Pyx_INCREF(__pyx_kp_s_); __pyx_t_1 = __pyx_kp_s_; __pyx_L6_bool_binop_done:; __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v_self->_path); __Pyx_DECREF(__pyx_v_self->_path); __pyx_v_self->_path = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "http_parser/parser.pyx":275 * self._parsed_url = urlsplit(raw_url) * self._path = self._parsed_url.path or "" * self._query_string = self._parsed_url.query or "" # <<<<<<<<<<<<<< * self._fragment = self._parsed_url.fragment or "" * */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_parsed_url, __pyx_n_s_query); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 275, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 275, __pyx_L1_error) if (!__pyx_t_4) { __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } else { if (!(likely(PyString_CheckExact(__pyx_t_2))||((__pyx_t_2) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "str", Py_TYPE(__pyx_t_2)->tp_name), 0))) __PYX_ERR(0, 275, __pyx_L1_error) __Pyx_INCREF(__pyx_t_2); __pyx_t_1 = __pyx_t_2; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; goto __pyx_L8_bool_binop_done; } __Pyx_INCREF(__pyx_kp_s_); __pyx_t_1 = __pyx_kp_s_; __pyx_L8_bool_binop_done:; __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v_self->_query_string); __Pyx_DECREF(__pyx_v_self->_query_string); __pyx_v_self->_query_string = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "http_parser/parser.pyx":276 * self._path = self._parsed_url.path or "" * self._query_string = self._parsed_url.query or "" * self._fragment = self._parsed_url.fragment or "" # <<<<<<<<<<<<<< * * def get_path(self): */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_parsed_url, __pyx_n_s_fragment); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 276, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 276, __pyx_L1_error) if (!__pyx_t_4) { __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } else { if (!(likely(PyString_CheckExact(__pyx_t_2))||((__pyx_t_2) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "str", Py_TYPE(__pyx_t_2)->tp_name), 0))) __PYX_ERR(0, 276, __pyx_L1_error) __Pyx_INCREF(__pyx_t_2); __pyx_t_1 = __pyx_t_2; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; goto __pyx_L10_bool_binop_done; } __Pyx_INCREF(__pyx_kp_s_); __pyx_t_1 = __pyx_kp_s_; __pyx_L10_bool_binop_done:; __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v_self->_fragment); __Pyx_DECREF(__pyx_v_self->_fragment); __pyx_v_self->_fragment = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "http_parser/parser.pyx":272 * def maybe_parse_url(self): * raw_url = self.get_url() * if not self._parsed_url and raw_url: # <<<<<<<<<<<<<< * self._parsed_url = urlsplit(raw_url) * self._path = self._parsed_url.path or "" */ } /* "http_parser/parser.pyx":270 * return self._data.url * * def maybe_parse_url(self): # <<<<<<<<<<<<<< * raw_url = self.get_url() * if not self._parsed_url and raw_url: */ /* 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_AddTraceback("http_parser.parser.HttpParser.maybe_parse_url", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_raw_url); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "http_parser/parser.pyx":278 * self._fragment = self._parsed_url.fragment or "" * * def get_path(self): # <<<<<<<<<<<<<< * """ get path of the request (url without query string and * fragment """ */ /* Python wrapper */ static PyObject *__pyx_pw_11http_parser_6parser_10HttpParser_17get_path(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_11http_parser_6parser_10HttpParser_16get_path[] = " get path of the request (url without query string and\n fragment "; static PyObject *__pyx_pw_11http_parser_6parser_10HttpParser_17get_path(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_path (wrapper)", 0); __pyx_r = __pyx_pf_11http_parser_6parser_10HttpParser_16get_path(((struct __pyx_obj_11http_parser_6parser_HttpParser *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_11http_parser_6parser_10HttpParser_16get_path(struct __pyx_obj_11http_parser_6parser_HttpParser *__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("get_path", 0); /* "http_parser/parser.pyx":281 * """ get path of the request (url without query string and * fragment """ * self.maybe_parse_url() # <<<<<<<<<<<<<< * return self._path * */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_maybe_parse_url); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 281, __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); } } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 281, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "http_parser/parser.pyx":282 * fragment """ * self.maybe_parse_url() * return self._path # <<<<<<<<<<<<<< * * def get_query_string(self): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->_path); __pyx_r = __pyx_v_self->_path; goto __pyx_L0; /* "http_parser/parser.pyx":278 * self._fragment = self._parsed_url.fragment or "" * * def get_path(self): # <<<<<<<<<<<<<< * """ get path of the request (url without query string and * fragment """ */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("http_parser.parser.HttpParser.get_path", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "http_parser/parser.pyx":284 * return self._path * * def get_query_string(self): # <<<<<<<<<<<<<< * """ get query string of the url """ * self.maybe_parse_url() */ /* Python wrapper */ static PyObject *__pyx_pw_11http_parser_6parser_10HttpParser_19get_query_string(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_11http_parser_6parser_10HttpParser_18get_query_string[] = " get query string of the url "; static PyObject *__pyx_pw_11http_parser_6parser_10HttpParser_19get_query_string(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_query_string (wrapper)", 0); __pyx_r = __pyx_pf_11http_parser_6parser_10HttpParser_18get_query_string(((struct __pyx_obj_11http_parser_6parser_HttpParser *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_11http_parser_6parser_10HttpParser_18get_query_string(struct __pyx_obj_11http_parser_6parser_HttpParser *__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("get_query_string", 0); /* "http_parser/parser.pyx":286 * def get_query_string(self): * """ get query string of the url """ * self.maybe_parse_url() # <<<<<<<<<<<<<< * return self._query_string * */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_maybe_parse_url); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 286, __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); } } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 286, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "http_parser/parser.pyx":287 * """ get query string of the url """ * self.maybe_parse_url() * return self._query_string # <<<<<<<<<<<<<< * * def get_fragment(self): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->_query_string); __pyx_r = __pyx_v_self->_query_string; goto __pyx_L0; /* "http_parser/parser.pyx":284 * return self._path * * def get_query_string(self): # <<<<<<<<<<<<<< * """ get query string of the url """ * self.maybe_parse_url() */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("http_parser.parser.HttpParser.get_query_string", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "http_parser/parser.pyx":289 * return self._query_string * * def get_fragment(self): # <<<<<<<<<<<<<< * """ get fragment of the url """ * self.maybe_parse_url() */ /* Python wrapper */ static PyObject *__pyx_pw_11http_parser_6parser_10HttpParser_21get_fragment(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_11http_parser_6parser_10HttpParser_20get_fragment[] = " get fragment of the url "; static PyObject *__pyx_pw_11http_parser_6parser_10HttpParser_21get_fragment(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_fragment (wrapper)", 0); __pyx_r = __pyx_pf_11http_parser_6parser_10HttpParser_20get_fragment(((struct __pyx_obj_11http_parser_6parser_HttpParser *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_11http_parser_6parser_10HttpParser_20get_fragment(struct __pyx_obj_11http_parser_6parser_HttpParser *__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("get_fragment", 0); /* "http_parser/parser.pyx":291 * def get_fragment(self): * """ get fragment of the url """ * self.maybe_parse_url() # <<<<<<<<<<<<<< * return self._fragment * */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_maybe_parse_url); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 291, __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); } } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 291, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "http_parser/parser.pyx":292 * """ get fragment of the url """ * self.maybe_parse_url() * return self._fragment # <<<<<<<<<<<<<< * * def get_headers(self): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->_fragment); __pyx_r = __pyx_v_self->_fragment; goto __pyx_L0; /* "http_parser/parser.pyx":289 * return self._query_string * * def get_fragment(self): # <<<<<<<<<<<<<< * """ get fragment of the url """ * self.maybe_parse_url() */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("http_parser.parser.HttpParser.get_fragment", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "http_parser/parser.pyx":294 * return self._fragment * * def get_headers(self): # <<<<<<<<<<<<<< * """ get request/response headers, headers are returned in a * OrderedDict that allows you to get value using insensitive keys. """ */ /* Python wrapper */ static PyObject *__pyx_pw_11http_parser_6parser_10HttpParser_23get_headers(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_11http_parser_6parser_10HttpParser_22get_headers[] = " get request/response headers, headers are returned in a\n OrderedDict that allows you to get value using insensitive keys. "; static PyObject *__pyx_pw_11http_parser_6parser_10HttpParser_23get_headers(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_headers (wrapper)", 0); __pyx_r = __pyx_pf_11http_parser_6parser_10HttpParser_22get_headers(((struct __pyx_obj_11http_parser_6parser_HttpParser *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_11http_parser_6parser_10HttpParser_22get_headers(struct __pyx_obj_11http_parser_6parser_HttpParser *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("get_headers", 0); /* "http_parser/parser.pyx":297 * """ get request/response headers, headers are returned in a * OrderedDict that allows you to get value using insensitive keys. """ * return self._data.headers # <<<<<<<<<<<<<< * * def get_wsgi_environ(self): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_data, __pyx_n_s_headers); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 297, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "http_parser/parser.pyx":294 * return self._fragment * * def get_headers(self): # <<<<<<<<<<<<<< * """ get request/response headers, headers are returned in a * OrderedDict that allows you to get value using insensitive keys. """ */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("http_parser.parser.HttpParser.get_headers", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "http_parser/parser.pyx":299 * return self._data.headers * * def get_wsgi_environ(self): # <<<<<<<<<<<<<< * """ get WSGI environ based on the current request """ * self.maybe_parse_url() */ /* Python wrapper */ static PyObject *__pyx_pw_11http_parser_6parser_10HttpParser_25get_wsgi_environ(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_11http_parser_6parser_10HttpParser_24get_wsgi_environ[] = " get WSGI environ based on the current request "; static PyObject *__pyx_pw_11http_parser_6parser_10HttpParser_25get_wsgi_environ(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_wsgi_environ (wrapper)", 0); __pyx_r = __pyx_pf_11http_parser_6parser_10HttpParser_24get_wsgi_environ(((struct __pyx_obj_11http_parser_6parser_HttpParser *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_11http_parser_6parser_10HttpParser_24get_wsgi_environ(struct __pyx_obj_11http_parser_6parser_HttpParser *__pyx_v_self) { PyObject *__pyx_v_environ = NULL; PyObject *__pyx_v_script_name = NULL; PyObject *__pyx_v_key = NULL; PyObject *__pyx_v_val = NULL; PyObject *__pyx_v_ku = NULL; PyObject *__pyx_v_path_info = 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)(PyObject *); PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *(*__pyx_t_8)(PyObject *); int __pyx_t_9; int __pyx_t_10; __Pyx_RefNannySetupContext("get_wsgi_environ", 0); /* "http_parser/parser.pyx":301 * def get_wsgi_environ(self): * """ get WSGI environ based on the current request """ * self.maybe_parse_url() # <<<<<<<<<<<<<< * * environ = dict() */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_maybe_parse_url); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 301, __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); } } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 301, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "http_parser/parser.pyx":303 * self.maybe_parse_url() * * environ = dict() # <<<<<<<<<<<<<< * script_name = os.environ.get("SCRIPT_NAME", "") * for key, val in self._data.headers.items(): */ __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 303, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_environ = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "http_parser/parser.pyx":304 * * environ = dict() * script_name = os.environ.get("SCRIPT_NAME", "") # <<<<<<<<<<<<<< * for key, val in self._data.headers.items(): * ku = key.upper() */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_os); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 304, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_environ); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 304, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_get); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 304, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 304, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_script_name = __pyx_t_2; __pyx_t_2 = 0; /* "http_parser/parser.pyx":305 * environ = dict() * script_name = os.environ.get("SCRIPT_NAME", "") * for key, val in self._data.headers.items(): # <<<<<<<<<<<<<< * ku = key.upper() * if ku == "CONTENT-TYPE": */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_data, __pyx_n_s_headers); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 305, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_items); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 305, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = NULL; if (CYTHON_UNPACK_METHODS && likely(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); } } __pyx_t_2 = (__pyx_t_1) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 305, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; 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, 305, __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, 305, __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, 305, __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, 305, __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, 305, __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, 305, __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(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); else __PYX_ERR(0, 305, __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; Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); __PYX_ERR(0, 305, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS if (likely(PyTuple_CheckExact(sequence))) { __pyx_t_1 = PyTuple_GET_ITEM(sequence, 0); __pyx_t_6 = PyTuple_GET_ITEM(sequence, 1); } else { __pyx_t_1 = PyList_GET_ITEM(sequence, 0); __pyx_t_6 = PyList_GET_ITEM(sequence, 1); } __Pyx_INCREF(__pyx_t_1); __Pyx_INCREF(__pyx_t_6); #else __pyx_t_1 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 305, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_6 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 305, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); #endif __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } else { Py_ssize_t index = -1; __pyx_t_7 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 305, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_8 = Py_TYPE(__pyx_t_7)->tp_iternext; index = 0; __pyx_t_1 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_1)) goto __pyx_L5_unpacking_failed; __Pyx_GOTREF(__pyx_t_1); 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, 305, __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, 305, __pyx_L1_error) __pyx_L6_unpacking_done:; } __Pyx_XDECREF_SET(__pyx_v_key, __pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF_SET(__pyx_v_val, __pyx_t_6); __pyx_t_6 = 0; /* "http_parser/parser.pyx":306 * script_name = os.environ.get("SCRIPT_NAME", "") * for key, val in self._data.headers.items(): * ku = key.upper() # <<<<<<<<<<<<<< * if ku == "CONTENT-TYPE": * environ['CONTENT_TYPE'] = val */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_key, __pyx_n_s_upper); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 306, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_1 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_1)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_1); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); } } __pyx_t_2 = (__pyx_t_1) ? __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_1) : __Pyx_PyObject_CallNoArg(__pyx_t_6); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 306, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF_SET(__pyx_v_ku, __pyx_t_2); __pyx_t_2 = 0; /* "http_parser/parser.pyx":307 * for key, val in self._data.headers.items(): * ku = key.upper() * if ku == "CONTENT-TYPE": # <<<<<<<<<<<<<< * environ['CONTENT_TYPE'] = val * elif ku == "CONTENT-LENGTH": */ __pyx_t_9 = (__Pyx_PyString_Equals(__pyx_v_ku, __pyx_kp_s_CONTENT_TYPE, Py_EQ)); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 307, __pyx_L1_error) if (__pyx_t_9) { /* "http_parser/parser.pyx":308 * ku = key.upper() * if ku == "CONTENT-TYPE": * environ['CONTENT_TYPE'] = val # <<<<<<<<<<<<<< * elif ku == "CONTENT-LENGTH": * environ['CONTENT_LENGTH'] = val */ if (unlikely(PyDict_SetItem(__pyx_v_environ, __pyx_n_s_CONTENT_TYPE_2, __pyx_v_val) < 0)) __PYX_ERR(0, 308, __pyx_L1_error) /* "http_parser/parser.pyx":307 * for key, val in self._data.headers.items(): * ku = key.upper() * if ku == "CONTENT-TYPE": # <<<<<<<<<<<<<< * environ['CONTENT_TYPE'] = val * elif ku == "CONTENT-LENGTH": */ goto __pyx_L7; } /* "http_parser/parser.pyx":309 * if ku == "CONTENT-TYPE": * environ['CONTENT_TYPE'] = val * elif ku == "CONTENT-LENGTH": # <<<<<<<<<<<<<< * environ['CONTENT_LENGTH'] = val * elif ku == "SCRIPT_NAME": */ __pyx_t_9 = (__Pyx_PyString_Equals(__pyx_v_ku, __pyx_kp_s_CONTENT_LENGTH, Py_EQ)); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 309, __pyx_L1_error) if (__pyx_t_9) { /* "http_parser/parser.pyx":310 * environ['CONTENT_TYPE'] = val * elif ku == "CONTENT-LENGTH": * environ['CONTENT_LENGTH'] = val # <<<<<<<<<<<<<< * elif ku == "SCRIPT_NAME": * environ['SCRIPT_NAME'] = val */ if (unlikely(PyDict_SetItem(__pyx_v_environ, __pyx_n_s_CONTENT_LENGTH_2, __pyx_v_val) < 0)) __PYX_ERR(0, 310, __pyx_L1_error) /* "http_parser/parser.pyx":309 * if ku == "CONTENT-TYPE": * environ['CONTENT_TYPE'] = val * elif ku == "CONTENT-LENGTH": # <<<<<<<<<<<<<< * environ['CONTENT_LENGTH'] = val * elif ku == "SCRIPT_NAME": */ goto __pyx_L7; } /* "http_parser/parser.pyx":311 * elif ku == "CONTENT-LENGTH": * environ['CONTENT_LENGTH'] = val * elif ku == "SCRIPT_NAME": # <<<<<<<<<<<<<< * environ['SCRIPT_NAME'] = val * else: */ __pyx_t_9 = (__Pyx_PyString_Equals(__pyx_v_ku, __pyx_n_s_SCRIPT_NAME, Py_EQ)); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 311, __pyx_L1_error) if (__pyx_t_9) { /* "http_parser/parser.pyx":312 * environ['CONTENT_LENGTH'] = val * elif ku == "SCRIPT_NAME": * environ['SCRIPT_NAME'] = val # <<<<<<<<<<<<<< * else: * environ['HTTP_%s' % ku.replace('-','_')] = val */ if (unlikely(PyDict_SetItem(__pyx_v_environ, __pyx_n_s_SCRIPT_NAME, __pyx_v_val) < 0)) __PYX_ERR(0, 312, __pyx_L1_error) /* "http_parser/parser.pyx":311 * elif ku == "CONTENT-LENGTH": * environ['CONTENT_LENGTH'] = val * elif ku == "SCRIPT_NAME": # <<<<<<<<<<<<<< * environ['SCRIPT_NAME'] = val * else: */ goto __pyx_L7; } /* "http_parser/parser.pyx":314 * environ['SCRIPT_NAME'] = val * else: * environ['HTTP_%s' % ku.replace('-','_')] = val # <<<<<<<<<<<<<< * * if script_name: */ /*else*/ { __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_ku, __pyx_n_s_replace); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 314, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 314, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyString_FormatSafe(__pyx_kp_s_HTTP__s, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 314, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(PyDict_SetItem(__pyx_v_environ, __pyx_t_2, __pyx_v_val) < 0)) __PYX_ERR(0, 314, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } __pyx_L7:; /* "http_parser/parser.pyx":305 * environ = dict() * script_name = os.environ.get("SCRIPT_NAME", "") * for key, val in self._data.headers.items(): # <<<<<<<<<<<<<< * ku = key.upper() * if ku == "CONTENT-TYPE": */ } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "http_parser/parser.pyx":316 * environ['HTTP_%s' % ku.replace('-','_')] = val * * if script_name: # <<<<<<<<<<<<<< * path_info = self._path.split(script_name, 1)[1] * else: */ __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_script_name); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 316, __pyx_L1_error) if (__pyx_t_9) { /* "http_parser/parser.pyx":317 * * if script_name: * path_info = self._path.split(script_name, 1)[1] # <<<<<<<<<<<<<< * else: * path_info = self._path */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_path, __pyx_n_s_split); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 317, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_6 = NULL; __pyx_t_10 = 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_10 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_v_script_name, __pyx_int_1}; __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 317, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_3); } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_v_script_name, __pyx_int_1}; __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 317, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_3); } else #endif { __pyx_t_1 = PyTuple_New(2+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 317, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (__pyx_t_6) { __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_6); __pyx_t_6 = NULL; } __Pyx_INCREF(__pyx_v_script_name); __Pyx_GIVEREF(__pyx_v_script_name); PyTuple_SET_ITEM(__pyx_t_1, 0+__pyx_t_10, __pyx_v_script_name); __Pyx_INCREF(__pyx_int_1); __Pyx_GIVEREF(__pyx_int_1); PyTuple_SET_ITEM(__pyx_t_1, 1+__pyx_t_10, __pyx_int_1); __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 317, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_3, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 317, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_path_info = __pyx_t_2; __pyx_t_2 = 0; /* "http_parser/parser.pyx":316 * environ['HTTP_%s' % ku.replace('-','_')] = val * * if script_name: # <<<<<<<<<<<<<< * path_info = self._path.split(script_name, 1)[1] * else: */ goto __pyx_L8; } /* "http_parser/parser.pyx":319 * path_info = self._path.split(script_name, 1)[1] * else: * path_info = self._path # <<<<<<<<<<<<<< * * environ.update({ */ /*else*/ { __pyx_t_2 = __pyx_v_self->_path; __Pyx_INCREF(__pyx_t_2); __pyx_v_path_info = __pyx_t_2; __pyx_t_2 = 0; } __pyx_L8:; /* "http_parser/parser.pyx":322 * * environ.update({ * 'REQUEST_METHOD': self.get_method(), # <<<<<<<<<<<<<< * 'SERVER_PROTOCOL': "HTTP/%s" % ".".join(map(str, * self.get_version())), */ __pyx_t_2 = __Pyx_PyDict_NewPresized(6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 322, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_get_method); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 322, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_6 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); } } __pyx_t_3 = (__pyx_t_6) ? __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_6) : __Pyx_PyObject_CallNoArg(__pyx_t_1); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 322, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_REQUEST_METHOD, __pyx_t_3) < 0) __PYX_ERR(0, 322, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "http_parser/parser.pyx":324 * 'REQUEST_METHOD': self.get_method(), * 'SERVER_PROTOCOL': "HTTP/%s" % ".".join(map(str, * self.get_version())), # <<<<<<<<<<<<<< * 'PATH_INFO': path_info, * 'SCRIPT_NAME': script_name, */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_get_version); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 324, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_6 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); } } __pyx_t_3 = (__pyx_t_6) ? __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_6) : __Pyx_PyObject_CallNoArg(__pyx_t_1); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 324, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "http_parser/parser.pyx":323 * environ.update({ * 'REQUEST_METHOD': self.get_method(), * 'SERVER_PROTOCOL': "HTTP/%s" % ".".join(map(str, # <<<<<<<<<<<<<< * self.get_version())), * 'PATH_INFO': path_info, */ __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 323, __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_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_map, __pyx_t_1, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 323, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyString_Join(__pyx_kp_s__7, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 323, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_HTTP_s, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 323, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_SERVER_PROTOCOL, __pyx_t_3) < 0) __PYX_ERR(0, 322, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "http_parser/parser.pyx":325 * 'SERVER_PROTOCOL': "HTTP/%s" % ".".join(map(str, * self.get_version())), * 'PATH_INFO': path_info, # <<<<<<<<<<<<<< * 'SCRIPT_NAME': script_name, * 'QUERY_STRING': self._query_string, */ if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_PATH_INFO, __pyx_v_path_info) < 0) __PYX_ERR(0, 322, __pyx_L1_error) /* "http_parser/parser.pyx":326 * self.get_version())), * 'PATH_INFO': path_info, * 'SCRIPT_NAME': script_name, # <<<<<<<<<<<<<< * 'QUERY_STRING': self._query_string, * 'RAW_URI': self._data.url}) */ if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_SCRIPT_NAME, __pyx_v_script_name) < 0) __PYX_ERR(0, 322, __pyx_L1_error) /* "http_parser/parser.pyx":327 * 'PATH_INFO': path_info, * 'SCRIPT_NAME': script_name, * 'QUERY_STRING': self._query_string, # <<<<<<<<<<<<<< * 'RAW_URI': self._data.url}) * */ if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_QUERY_STRING, __pyx_v_self->_query_string) < 0) __PYX_ERR(0, 322, __pyx_L1_error) /* "http_parser/parser.pyx":328 * 'SCRIPT_NAME': script_name, * 'QUERY_STRING': self._query_string, * 'RAW_URI': self._data.url}) # <<<<<<<<<<<<<< * * return environ */ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_data, __pyx_n_s_url); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 328, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_RAW_URI, __pyx_t_3) < 0) __PYX_ERR(0, 322, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "http_parser/parser.pyx":321 * path_info = self._path * * environ.update({ # <<<<<<<<<<<<<< * 'REQUEST_METHOD': self.get_method(), * 'SERVER_PROTOCOL': "HTTP/%s" % ".".join(map(str, */ __pyx_t_3 = __Pyx_CallUnboundCMethod1(&__pyx_umethod_PyDict_Type_update, __pyx_v_environ, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 321, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "http_parser/parser.pyx":330 * 'RAW_URI': self._data.url}) * * return environ # <<<<<<<<<<<<<< * * def recv_body(self): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_environ); __pyx_r = __pyx_v_environ; goto __pyx_L0; /* "http_parser/parser.pyx":299 * return self._data.headers * * def get_wsgi_environ(self): # <<<<<<<<<<<<<< * """ get WSGI environ based on the current request """ * self.maybe_parse_url() */ /* 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_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_AddTraceback("http_parser.parser.HttpParser.get_wsgi_environ", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_environ); __Pyx_XDECREF(__pyx_v_script_name); __Pyx_XDECREF(__pyx_v_key); __Pyx_XDECREF(__pyx_v_val); __Pyx_XDECREF(__pyx_v_ku); __Pyx_XDECREF(__pyx_v_path_info); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "http_parser/parser.pyx":332 * return environ * * def recv_body(self): # <<<<<<<<<<<<<< * """ return last chunk of the parsed body""" * body = b("").join(self._data.body) */ /* Python wrapper */ static PyObject *__pyx_pw_11http_parser_6parser_10HttpParser_27recv_body(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_11http_parser_6parser_10HttpParser_26recv_body[] = " return last chunk of the parsed body"; static PyObject *__pyx_pw_11http_parser_6parser_10HttpParser_27recv_body(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("recv_body (wrapper)", 0); __pyx_r = __pyx_pf_11http_parser_6parser_10HttpParser_26recv_body(((struct __pyx_obj_11http_parser_6parser_HttpParser *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_11http_parser_6parser_10HttpParser_26recv_body(struct __pyx_obj_11http_parser_6parser_HttpParser *__pyx_v_self) { PyObject *__pyx_v_body = 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; __Pyx_RefNannySetupContext("recv_body", 0); /* "http_parser/parser.pyx":334 * def recv_body(self): * """ return last chunk of the parsed body""" * body = b("").join(self._data.body) # <<<<<<<<<<<<<< * self._data.body = [] * self._data.partial_body = False */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_b); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 334, __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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_kp_s_) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_kp_s_); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 334, __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_join); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 334, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_data, __pyx_n_s_body); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 334, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __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); } } __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 334, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_body = __pyx_t_1; __pyx_t_1 = 0; /* "http_parser/parser.pyx":335 * """ return last chunk of the parsed body""" * body = b("").join(self._data.body) * self._data.body = [] # <<<<<<<<<<<<<< * self._data.partial_body = False * return body */ __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 335, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (__Pyx_PyObject_SetAttrStr(__pyx_v_self->_data, __pyx_n_s_body, __pyx_t_1) < 0) __PYX_ERR(0, 335, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "http_parser/parser.pyx":336 * body = b("").join(self._data.body) * self._data.body = [] * self._data.partial_body = False # <<<<<<<<<<<<<< * return body * */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_self->_data, __pyx_n_s_partial_body, Py_False) < 0) __PYX_ERR(0, 336, __pyx_L1_error) /* "http_parser/parser.pyx":337 * self._data.body = [] * self._data.partial_body = False * return body # <<<<<<<<<<<<<< * * def recv_body_into(self, barray): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_body); __pyx_r = __pyx_v_body; goto __pyx_L0; /* "http_parser/parser.pyx":332 * return environ * * def recv_body(self): # <<<<<<<<<<<<<< * """ return last chunk of the parsed body""" * body = b("").join(self._data.body) */ /* 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("http_parser.parser.HttpParser.recv_body", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_body); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "http_parser/parser.pyx":339 * return body * * def recv_body_into(self, barray): # <<<<<<<<<<<<<< * """ Receive the last chunk of the parsed body and store the data * in a buffer rather than creating a new string. """ */ /* Python wrapper */ static PyObject *__pyx_pw_11http_parser_6parser_10HttpParser_29recv_body_into(PyObject *__pyx_v_self, PyObject *__pyx_v_barray); /*proto*/ static char __pyx_doc_11http_parser_6parser_10HttpParser_28recv_body_into[] = " Receive the last chunk of the parsed body and store the data\n in a buffer rather than creating a new string. "; static PyObject *__pyx_pw_11http_parser_6parser_10HttpParser_29recv_body_into(PyObject *__pyx_v_self, PyObject *__pyx_v_barray) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("recv_body_into (wrapper)", 0); __pyx_r = __pyx_pf_11http_parser_6parser_10HttpParser_28recv_body_into(((struct __pyx_obj_11http_parser_6parser_HttpParser *)__pyx_v_self), ((PyObject *)__pyx_v_barray)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_11http_parser_6parser_10HttpParser_28recv_body_into(struct __pyx_obj_11http_parser_6parser_HttpParser *__pyx_v_self, PyObject *__pyx_v_barray) { Py_ssize_t __pyx_v_l; PyObject *__pyx_v_body = NULL; Py_ssize_t __pyx_v_m; PyObject *__pyx_v_data = NULL; PyObject *__pyx_v_rest = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations Py_ssize_t __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; Py_ssize_t __pyx_t_6; Py_ssize_t __pyx_t_7; int __pyx_t_8; int __pyx_t_9; __Pyx_RefNannySetupContext("recv_body_into", 0); /* "http_parser/parser.pyx":342 * """ Receive the last chunk of the parsed body and store the data * in a buffer rather than creating a new string. """ * l = len(barray) # <<<<<<<<<<<<<< * body = b("").join(self._data.body) * m = min(len(body), l) */ __pyx_t_1 = PyObject_Length(__pyx_v_barray); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 342, __pyx_L1_error) __pyx_v_l = __pyx_t_1; /* "http_parser/parser.pyx":343 * in a buffer rather than creating a new string. """ * l = len(barray) * body = b("").join(self._data.body) # <<<<<<<<<<<<<< * m = min(len(body), l) * data, rest = body[:m], body[m:] */ __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_b); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 343, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = NULL; 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_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_kp_s_) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_kp_s_); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 343, __pyx_L1_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_join); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 343, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_data, __pyx_n_s_body); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 343, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __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); } } __pyx_t_2 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 343, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v_body = __pyx_t_2; __pyx_t_2 = 0; /* "http_parser/parser.pyx":344 * l = len(barray) * body = b("").join(self._data.body) * m = min(len(body), l) # <<<<<<<<<<<<<< * data, rest = body[:m], body[m:] * barray[0:m] = bytes(data) */ __pyx_t_1 = __pyx_v_l; __pyx_t_6 = PyObject_Length(__pyx_v_body); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(0, 344, __pyx_L1_error) if (((__pyx_t_1 < __pyx_t_6) != 0)) { __pyx_t_7 = __pyx_t_1; } else { __pyx_t_7 = __pyx_t_6; } __pyx_v_m = __pyx_t_7; /* "http_parser/parser.pyx":345 * body = b("").join(self._data.body) * m = min(len(body), l) * data, rest = body[:m], body[m:] # <<<<<<<<<<<<<< * barray[0:m] = bytes(data) * if not rest: */ __pyx_t_2 = __Pyx_PyObject_GetSlice(__pyx_v_body, 0, __pyx_v_m, NULL, NULL, NULL, 0, 1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 345, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = __Pyx_PyObject_GetSlice(__pyx_v_body, __pyx_v_m, 0, NULL, NULL, NULL, 1, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 345, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_v_data = __pyx_t_2; __pyx_t_2 = 0; __pyx_v_rest = __pyx_t_4; __pyx_t_4 = 0; /* "http_parser/parser.pyx":346 * m = min(len(body), l) * data, rest = body[:m], body[m:] * barray[0:m] = bytes(data) # <<<<<<<<<<<<<< * if not rest: * self._data.body = [] */ __pyx_t_4 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyBytes_Type)), __pyx_v_data); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 346, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_PyObject_SetSlice(__pyx_v_barray, __pyx_t_4, 0, __pyx_v_m, NULL, NULL, NULL, 1, 1, 1) < 0) __PYX_ERR(0, 346, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "http_parser/parser.pyx":347 * data, rest = body[:m], body[m:] * barray[0:m] = bytes(data) * if not rest: # <<<<<<<<<<<<<< * self._data.body = [] * self._data.partial_body = False */ __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_rest); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 347, __pyx_L1_error) __pyx_t_9 = ((!__pyx_t_8) != 0); if (__pyx_t_9) { /* "http_parser/parser.pyx":348 * barray[0:m] = bytes(data) * if not rest: * self._data.body = [] # <<<<<<<<<<<<<< * self._data.partial_body = False * else: */ __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 348, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_PyObject_SetAttrStr(__pyx_v_self->_data, __pyx_n_s_body, __pyx_t_4) < 0) __PYX_ERR(0, 348, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "http_parser/parser.pyx":349 * if not rest: * self._data.body = [] * self._data.partial_body = False # <<<<<<<<<<<<<< * else: * self._data.body = [rest] */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_self->_data, __pyx_n_s_partial_body, Py_False) < 0) __PYX_ERR(0, 349, __pyx_L1_error) /* "http_parser/parser.pyx":347 * data, rest = body[:m], body[m:] * barray[0:m] = bytes(data) * if not rest: # <<<<<<<<<<<<<< * self._data.body = [] * self._data.partial_body = False */ goto __pyx_L3; } /* "http_parser/parser.pyx":351 * self._data.partial_body = False * else: * self._data.body = [rest] # <<<<<<<<<<<<<< * return m * */ /*else*/ { __pyx_t_4 = PyList_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 351, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_v_rest); __Pyx_GIVEREF(__pyx_v_rest); PyList_SET_ITEM(__pyx_t_4, 0, __pyx_v_rest); if (__Pyx_PyObject_SetAttrStr(__pyx_v_self->_data, __pyx_n_s_body, __pyx_t_4) < 0) __PYX_ERR(0, 351, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __pyx_L3:; /* "http_parser/parser.pyx":352 * else: * self._data.body = [rest] * return m # <<<<<<<<<<<<<< * * def is_upgrade(self): */ __Pyx_XDECREF(__pyx_r); __pyx_t_4 = PyInt_FromSsize_t(__pyx_v_m); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 352, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_r = __pyx_t_4; __pyx_t_4 = 0; goto __pyx_L0; /* "http_parser/parser.pyx":339 * return body * * def recv_body_into(self, barray): # <<<<<<<<<<<<<< * """ Receive the last chunk of the parsed body and store the data * in a buffer rather than creating a new string. """ */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("http_parser.parser.HttpParser.recv_body_into", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_body); __Pyx_XDECREF(__pyx_v_data); __Pyx_XDECREF(__pyx_v_rest); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "http_parser/parser.pyx":354 * return m * * def is_upgrade(self): # <<<<<<<<<<<<<< * """ Do we get upgrade header in the request. Useful for * websockets """ */ /* Python wrapper */ static PyObject *__pyx_pw_11http_parser_6parser_10HttpParser_31is_upgrade(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_11http_parser_6parser_10HttpParser_30is_upgrade[] = " Do we get upgrade header in the request. Useful for\n websockets "; static PyObject *__pyx_pw_11http_parser_6parser_10HttpParser_31is_upgrade(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("is_upgrade (wrapper)", 0); __pyx_r = __pyx_pf_11http_parser_6parser_10HttpParser_30is_upgrade(((struct __pyx_obj_11http_parser_6parser_HttpParser *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_11http_parser_6parser_10HttpParser_30is_upgrade(struct __pyx_obj_11http_parser_6parser_HttpParser *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("is_upgrade", 0); /* "http_parser/parser.pyx":357 * """ Do we get upgrade header in the request. Useful for * websockets """ * return self._parser.upgrade # <<<<<<<<<<<<<< * * def is_headers_complete(self): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_char(__pyx_v_self->_parser.upgrade); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 357, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "http_parser/parser.pyx":354 * return m * * def is_upgrade(self): # <<<<<<<<<<<<<< * """ Do we get upgrade header in the request. Useful for * websockets """ */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("http_parser.parser.HttpParser.is_upgrade", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "http_parser/parser.pyx":359 * return self._parser.upgrade * * def is_headers_complete(self): # <<<<<<<<<<<<<< * """ return True if all headers have been parsed. """ * return self._data.headers_complete */ /* Python wrapper */ static PyObject *__pyx_pw_11http_parser_6parser_10HttpParser_33is_headers_complete(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_11http_parser_6parser_10HttpParser_32is_headers_complete[] = " return True if all headers have been parsed. "; static PyObject *__pyx_pw_11http_parser_6parser_10HttpParser_33is_headers_complete(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("is_headers_complete (wrapper)", 0); __pyx_r = __pyx_pf_11http_parser_6parser_10HttpParser_32is_headers_complete(((struct __pyx_obj_11http_parser_6parser_HttpParser *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_11http_parser_6parser_10HttpParser_32is_headers_complete(struct __pyx_obj_11http_parser_6parser_HttpParser *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("is_headers_complete", 0); /* "http_parser/parser.pyx":361 * def is_headers_complete(self): * """ return True if all headers have been parsed. """ * return self._data.headers_complete # <<<<<<<<<<<<<< * * def is_partial_body(self): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_data, __pyx_n_s_headers_complete); 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; /* "http_parser/parser.pyx":359 * return self._parser.upgrade * * def is_headers_complete(self): # <<<<<<<<<<<<<< * """ return True if all headers have been parsed. """ * return self._data.headers_complete */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("http_parser.parser.HttpParser.is_headers_complete", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "http_parser/parser.pyx":363 * return self._data.headers_complete * * def is_partial_body(self): # <<<<<<<<<<<<<< * """ return True if a chunk of body have been parsed """ * return self._data.partial_body */ /* Python wrapper */ static PyObject *__pyx_pw_11http_parser_6parser_10HttpParser_35is_partial_body(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_11http_parser_6parser_10HttpParser_34is_partial_body[] = " return True if a chunk of body have been parsed "; static PyObject *__pyx_pw_11http_parser_6parser_10HttpParser_35is_partial_body(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("is_partial_body (wrapper)", 0); __pyx_r = __pyx_pf_11http_parser_6parser_10HttpParser_34is_partial_body(((struct __pyx_obj_11http_parser_6parser_HttpParser *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_11http_parser_6parser_10HttpParser_34is_partial_body(struct __pyx_obj_11http_parser_6parser_HttpParser *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("is_partial_body", 0); /* "http_parser/parser.pyx":365 * def is_partial_body(self): * """ return True if a chunk of body have been parsed """ * return self._data.partial_body # <<<<<<<<<<<<<< * * def is_message_begin(self): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_data, __pyx_n_s_partial_body); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 365, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "http_parser/parser.pyx":363 * return self._data.headers_complete * * def is_partial_body(self): # <<<<<<<<<<<<<< * """ return True if a chunk of body have been parsed """ * return self._data.partial_body */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("http_parser.parser.HttpParser.is_partial_body", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "http_parser/parser.pyx":367 * return self._data.partial_body * * def is_message_begin(self): # <<<<<<<<<<<<<< * """ return True if the parsing start """ * return self._data.message_begin */ /* Python wrapper */ static PyObject *__pyx_pw_11http_parser_6parser_10HttpParser_37is_message_begin(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_11http_parser_6parser_10HttpParser_36is_message_begin[] = " return True if the parsing start "; static PyObject *__pyx_pw_11http_parser_6parser_10HttpParser_37is_message_begin(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("is_message_begin (wrapper)", 0); __pyx_r = __pyx_pf_11http_parser_6parser_10HttpParser_36is_message_begin(((struct __pyx_obj_11http_parser_6parser_HttpParser *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_11http_parser_6parser_10HttpParser_36is_message_begin(struct __pyx_obj_11http_parser_6parser_HttpParser *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("is_message_begin", 0); /* "http_parser/parser.pyx":369 * def is_message_begin(self): * """ return True if the parsing start """ * return self._data.message_begin # <<<<<<<<<<<<<< * * def is_message_complete(self): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_data, __pyx_n_s_message_begin); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 369, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "http_parser/parser.pyx":367 * return self._data.partial_body * * def is_message_begin(self): # <<<<<<<<<<<<<< * """ return True if the parsing start """ * return self._data.message_begin */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("http_parser.parser.HttpParser.is_message_begin", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "http_parser/parser.pyx":371 * return self._data.message_begin * * def is_message_complete(self): # <<<<<<<<<<<<<< * """ return True if the parsing is done (we get EOF) """ * return self._data.message_complete */ /* Python wrapper */ static PyObject *__pyx_pw_11http_parser_6parser_10HttpParser_39is_message_complete(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_11http_parser_6parser_10HttpParser_38is_message_complete[] = " return True if the parsing is done (we get EOF) "; static PyObject *__pyx_pw_11http_parser_6parser_10HttpParser_39is_message_complete(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("is_message_complete (wrapper)", 0); __pyx_r = __pyx_pf_11http_parser_6parser_10HttpParser_38is_message_complete(((struct __pyx_obj_11http_parser_6parser_HttpParser *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_11http_parser_6parser_10HttpParser_38is_message_complete(struct __pyx_obj_11http_parser_6parser_HttpParser *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("is_message_complete", 0); /* "http_parser/parser.pyx":373 * def is_message_complete(self): * """ return True if the parsing is done (we get EOF) """ * return self._data.message_complete # <<<<<<<<<<<<<< * * def is_chunked(self): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_data, __pyx_n_s_message_complete); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 373, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "http_parser/parser.pyx":371 * return self._data.message_begin * * def is_message_complete(self): # <<<<<<<<<<<<<< * """ return True if the parsing is done (we get EOF) """ * return self._data.message_complete */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("http_parser.parser.HttpParser.is_message_complete", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "http_parser/parser.pyx":375 * return self._data.message_complete * * def is_chunked(self): # <<<<<<<<<<<<<< * """ return True if Transfer-Encoding header value is chunked""" * te = self._data.headers.get('transfer-encoding', '').lower() */ /* Python wrapper */ static PyObject *__pyx_pw_11http_parser_6parser_10HttpParser_41is_chunked(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_11http_parser_6parser_10HttpParser_40is_chunked[] = " return True if Transfer-Encoding header value is chunked"; static PyObject *__pyx_pw_11http_parser_6parser_10HttpParser_41is_chunked(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("is_chunked (wrapper)", 0); __pyx_r = __pyx_pf_11http_parser_6parser_10HttpParser_40is_chunked(((struct __pyx_obj_11http_parser_6parser_HttpParser *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_11http_parser_6parser_10HttpParser_40is_chunked(struct __pyx_obj_11http_parser_6parser_HttpParser *__pyx_v_self) { PyObject *__pyx_v_te = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; __Pyx_RefNannySetupContext("is_chunked", 0); /* "http_parser/parser.pyx":377 * def is_chunked(self): * """ return True if Transfer-Encoding header value is chunked""" * te = self._data.headers.get('transfer-encoding', '').lower() # <<<<<<<<<<<<<< * return te == 'chunked' * */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_data, __pyx_n_s_headers); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 377, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_get); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 377, __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_3, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 377, __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_lower); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 377, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = NULL; if (CYTHON_UNPACK_METHODS && likely(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_1 = (__pyx_t_2) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 377, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_te = __pyx_t_1; __pyx_t_1 = 0; /* "http_parser/parser.pyx":378 * """ return True if Transfer-Encoding header value is chunked""" * te = self._data.headers.get('transfer-encoding', '').lower() * return te == 'chunked' # <<<<<<<<<<<<<< * * def should_keep_alive(self): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyObject_RichCompare(__pyx_v_te, __pyx_n_s_chunked, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 378, __pyx_L1_error) __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "http_parser/parser.pyx":375 * return self._data.message_complete * * def is_chunked(self): # <<<<<<<<<<<<<< * """ return True if Transfer-Encoding header value is chunked""" * te = self._data.headers.get('transfer-encoding', '').lower() */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("http_parser.parser.HttpParser.is_chunked", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_te); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "http_parser/parser.pyx":380 * return te == 'chunked' * * def should_keep_alive(self): # <<<<<<<<<<<<<< * """ return True if the connection should be kept alive * """ */ /* Python wrapper */ static PyObject *__pyx_pw_11http_parser_6parser_10HttpParser_43should_keep_alive(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_11http_parser_6parser_10HttpParser_42should_keep_alive[] = " return True if the connection should be kept alive\n "; static PyObject *__pyx_pw_11http_parser_6parser_10HttpParser_43should_keep_alive(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("should_keep_alive (wrapper)", 0); __pyx_r = __pyx_pf_11http_parser_6parser_10HttpParser_42should_keep_alive(((struct __pyx_obj_11http_parser_6parser_HttpParser *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_11http_parser_6parser_10HttpParser_42should_keep_alive(struct __pyx_obj_11http_parser_6parser_HttpParser *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("should_keep_alive", 0); /* "http_parser/parser.pyx":383 * """ return True if the connection should be kept alive * """ * return http_should_keep_alive(&self._parser) # <<<<<<<<<<<<<< */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_int(http_should_keep_alive((&__pyx_v_self->_parser))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 383, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "http_parser/parser.pyx":380 * return te == 'chunked' * * def should_keep_alive(self): # <<<<<<<<<<<<<< * """ return True if the connection should be kept alive * """ */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("http_parser.parser.HttpParser.should_keep_alive", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError("self._parser,self._settings cannot be converted to a Python object for pickling") * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ static PyObject *__pyx_pw_11http_parser_6parser_10HttpParser_45__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_pw_11http_parser_6parser_10HttpParser_45__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); __pyx_r = __pyx_pf_11http_parser_6parser_10HttpParser_44__reduce_cython__(((struct __pyx_obj_11http_parser_6parser_HttpParser *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_11http_parser_6parser_10HttpParser_44__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_11http_parser_6parser_HttpParser *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("__reduce_cython__", 0); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError("self._parser,self._settings cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError("self._parser,self._settings cannot be converted to a Python object for pickling") */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __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(1, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError("self._parser,self._settings cannot be converted to a Python object for pickling") * def __setstate_cython__(self, __pyx_state): */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("http_parser.parser.HttpParser.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError("self._parser,self._settings cannot be converted to a Python object for pickling") * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError("self._parser,self._settings cannot be converted to a Python object for pickling") */ /* Python wrapper */ static PyObject *__pyx_pw_11http_parser_6parser_10HttpParser_47__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ static PyObject *__pyx_pw_11http_parser_6parser_10HttpParser_47__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); __pyx_r = __pyx_pf_11http_parser_6parser_10HttpParser_46__setstate_cython__(((struct __pyx_obj_11http_parser_6parser_HttpParser *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_11http_parser_6parser_10HttpParser_46__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_11http_parser_6parser_HttpParser *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("__setstate_cython__", 0); /* "(tree fragment)":4 * raise TypeError("self._parser,self._settings cannot be converted to a Python object for pickling") * def __setstate_cython__(self, __pyx_state): * raise TypeError("self._parser,self._settings cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __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(1, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError("self._parser,self._settings cannot be converted to a Python object for pickling") * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError("self._parser,self._settings cannot be converted to a Python object for pickling") */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("http_parser.parser.HttpParser.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_tp_new_11http_parser_6parser_HttpParser(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { struct __pyx_obj_11http_parser_6parser_HttpParser *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_11http_parser_6parser_HttpParser *)o); p->_data = Py_None; Py_INCREF(Py_None); p->_path = ((PyObject*)Py_None); Py_INCREF(Py_None); p->_query_string = ((PyObject*)Py_None); Py_INCREF(Py_None); p->_fragment = ((PyObject*)Py_None); Py_INCREF(Py_None); p->_parsed_url = Py_None; Py_INCREF(Py_None); return o; } static void __pyx_tp_dealloc_11http_parser_6parser_HttpParser(PyObject *o) { struct __pyx_obj_11http_parser_6parser_HttpParser *p = (struct __pyx_obj_11http_parser_6parser_HttpParser *)o; #if CYTHON_USE_TP_FINALIZE if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { if (PyObject_CallFinalizerFromDealloc(o)) return; } #endif PyObject_GC_UnTrack(o); Py_CLEAR(p->_data); Py_CLEAR(p->_path); Py_CLEAR(p->_query_string); Py_CLEAR(p->_fragment); Py_CLEAR(p->_parsed_url); (*Py_TYPE(o)->tp_free)(o); } static int __pyx_tp_traverse_11http_parser_6parser_HttpParser(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_11http_parser_6parser_HttpParser *p = (struct __pyx_obj_11http_parser_6parser_HttpParser *)o; if (p->_data) { e = (*v)(p->_data, a); if (e) return e; } if (p->_parsed_url) { e = (*v)(p->_parsed_url, a); if (e) return e; } return 0; } static int __pyx_tp_clear_11http_parser_6parser_HttpParser(PyObject *o) { PyObject* tmp; struct __pyx_obj_11http_parser_6parser_HttpParser *p = (struct __pyx_obj_11http_parser_6parser_HttpParser *)o; tmp = ((PyObject*)p->_data); p->_data = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); tmp = ((PyObject*)p->_parsed_url); p->_parsed_url = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); return 0; } static PyMethodDef __pyx_methods_11http_parser_6parser_HttpParser[] = { {"execute", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_11http_parser_6parser_10HttpParser_3execute, METH_VARARGS|METH_KEYWORDS, __pyx_doc_11http_parser_6parser_10HttpParser_2execute}, {"get_errno", (PyCFunction)__pyx_pw_11http_parser_6parser_10HttpParser_5get_errno, METH_NOARGS, __pyx_doc_11http_parser_6parser_10HttpParser_4get_errno}, {"get_version", (PyCFunction)__pyx_pw_11http_parser_6parser_10HttpParser_7get_version, METH_NOARGS, __pyx_doc_11http_parser_6parser_10HttpParser_6get_version}, {"get_method", (PyCFunction)__pyx_pw_11http_parser_6parser_10HttpParser_9get_method, METH_NOARGS, __pyx_doc_11http_parser_6parser_10HttpParser_8get_method}, {"get_status_code", (PyCFunction)__pyx_pw_11http_parser_6parser_10HttpParser_11get_status_code, METH_NOARGS, __pyx_doc_11http_parser_6parser_10HttpParser_10get_status_code}, {"get_url", (PyCFunction)__pyx_pw_11http_parser_6parser_10HttpParser_13get_url, METH_NOARGS, __pyx_doc_11http_parser_6parser_10HttpParser_12get_url}, {"maybe_parse_url", (PyCFunction)__pyx_pw_11http_parser_6parser_10HttpParser_15maybe_parse_url, METH_NOARGS, 0}, {"get_path", (PyCFunction)__pyx_pw_11http_parser_6parser_10HttpParser_17get_path, METH_NOARGS, __pyx_doc_11http_parser_6parser_10HttpParser_16get_path}, {"get_query_string", (PyCFunction)__pyx_pw_11http_parser_6parser_10HttpParser_19get_query_string, METH_NOARGS, __pyx_doc_11http_parser_6parser_10HttpParser_18get_query_string}, {"get_fragment", (PyCFunction)__pyx_pw_11http_parser_6parser_10HttpParser_21get_fragment, METH_NOARGS, __pyx_doc_11http_parser_6parser_10HttpParser_20get_fragment}, {"get_headers", (PyCFunction)__pyx_pw_11http_parser_6parser_10HttpParser_23get_headers, METH_NOARGS, __pyx_doc_11http_parser_6parser_10HttpParser_22get_headers}, {"get_wsgi_environ", (PyCFunction)__pyx_pw_11http_parser_6parser_10HttpParser_25get_wsgi_environ, METH_NOARGS, __pyx_doc_11http_parser_6parser_10HttpParser_24get_wsgi_environ}, {"recv_body", (PyCFunction)__pyx_pw_11http_parser_6parser_10HttpParser_27recv_body, METH_NOARGS, __pyx_doc_11http_parser_6parser_10HttpParser_26recv_body}, {"recv_body_into", (PyCFunction)__pyx_pw_11http_parser_6parser_10HttpParser_29recv_body_into, METH_O, __pyx_doc_11http_parser_6parser_10HttpParser_28recv_body_into}, {"is_upgrade", (PyCFunction)__pyx_pw_11http_parser_6parser_10HttpParser_31is_upgrade, METH_NOARGS, __pyx_doc_11http_parser_6parser_10HttpParser_30is_upgrade}, {"is_headers_complete", (PyCFunction)__pyx_pw_11http_parser_6parser_10HttpParser_33is_headers_complete, METH_NOARGS, __pyx_doc_11http_parser_6parser_10HttpParser_32is_headers_complete}, {"is_partial_body", (PyCFunction)__pyx_pw_11http_parser_6parser_10HttpParser_35is_partial_body, METH_NOARGS, __pyx_doc_11http_parser_6parser_10HttpParser_34is_partial_body}, {"is_message_begin", (PyCFunction)__pyx_pw_11http_parser_6parser_10HttpParser_37is_message_begin, METH_NOARGS, __pyx_doc_11http_parser_6parser_10HttpParser_36is_message_begin}, {"is_message_complete", (PyCFunction)__pyx_pw_11http_parser_6parser_10HttpParser_39is_message_complete, METH_NOARGS, __pyx_doc_11http_parser_6parser_10HttpParser_38is_message_complete}, {"is_chunked", (PyCFunction)__pyx_pw_11http_parser_6parser_10HttpParser_41is_chunked, METH_NOARGS, __pyx_doc_11http_parser_6parser_10HttpParser_40is_chunked}, {"should_keep_alive", (PyCFunction)__pyx_pw_11http_parser_6parser_10HttpParser_43should_keep_alive, METH_NOARGS, __pyx_doc_11http_parser_6parser_10HttpParser_42should_keep_alive}, {"__reduce_cython__", (PyCFunction)__pyx_pw_11http_parser_6parser_10HttpParser_45__reduce_cython__, METH_NOARGS, 0}, {"__setstate_cython__", (PyCFunction)__pyx_pw_11http_parser_6parser_10HttpParser_47__setstate_cython__, METH_O, 0}, {0, 0, 0, 0} }; static PyTypeObject __pyx_type_11http_parser_6parser_HttpParser = { PyVarObject_HEAD_INIT(0, 0) "http_parser.parser.HttpParser", /*tp_name*/ sizeof(struct __pyx_obj_11http_parser_6parser_HttpParser), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_11http_parser_6parser_HttpParser, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 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_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ " Low level HTTP parser. ", /*tp_doc*/ __pyx_tp_traverse_11http_parser_6parser_HttpParser, /*tp_traverse*/ __pyx_tp_clear_11http_parser_6parser_HttpParser, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ __pyx_methods_11http_parser_6parser_HttpParser, /*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*/ __pyx_pw_11http_parser_6parser_10HttpParser_1__init__, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_11http_parser_6parser_HttpParser, /*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 #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif }; static PyMethodDef __pyx_methods[] = { {0, 0, 0, 0} }; #if PY_MAJOR_VERSION >= 3 #if CYTHON_PEP489_MULTI_PHASE_INIT static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ static int __pyx_pymod_exec_parser(PyObject* module); /*proto*/ static PyModuleDef_Slot __pyx_moduledef_slots[] = { {Py_mod_create, (void*)__pyx_pymod_create}, {Py_mod_exec, (void*)__pyx_pymod_exec_parser}, {0, NULL} }; #endif static struct PyModuleDef __pyx_moduledef = { PyModuleDef_HEAD_INIT, "parser", 0, /* m_doc */ #if CYTHON_PEP489_MULTI_PHASE_INIT 0, /* m_size */ #else -1, /* m_size */ #endif __pyx_methods /* m_methods */, #if CYTHON_PEP489_MULTI_PHASE_INIT __pyx_moduledef_slots, /* m_slots */ #else NULL, /* m_reload */ #endif NULL, /* m_traverse */ NULL, /* m_clear */ NULL /* m_free */ }; #endif #ifndef CYTHON_SMALL_CODE #if defined(__clang__) #define CYTHON_SMALL_CODE #elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) #define CYTHON_SMALL_CODE __attribute__((cold)) #else #define CYTHON_SMALL_CODE #endif #endif static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_kp_s_, __pyx_k_, sizeof(__pyx_k_), 0, 0, 1, 0}, {&__pyx_kp_s_CONTENT_LENGTH, __pyx_k_CONTENT_LENGTH, sizeof(__pyx_k_CONTENT_LENGTH), 0, 0, 1, 0}, {&__pyx_n_s_CONTENT_LENGTH_2, __pyx_k_CONTENT_LENGTH_2, sizeof(__pyx_k_CONTENT_LENGTH_2), 0, 0, 1, 1}, {&__pyx_kp_s_CONTENT_TYPE, __pyx_k_CONTENT_TYPE, sizeof(__pyx_k_CONTENT_TYPE), 0, 0, 1, 0}, {&__pyx_n_s_CONTENT_TYPE_2, __pyx_k_CONTENT_TYPE_2, sizeof(__pyx_k_CONTENT_TYPE_2), 0, 0, 1, 1}, {&__pyx_kp_s_HTTP__s, __pyx_k_HTTP__s, sizeof(__pyx_k_HTTP__s), 0, 0, 1, 0}, {&__pyx_kp_s_HTTP_s, __pyx_k_HTTP_s, sizeof(__pyx_k_HTTP_s), 0, 0, 1, 0}, {&__pyx_n_s_HttpParser, __pyx_k_HttpParser, sizeof(__pyx_k_HttpParser), 0, 0, 1, 1}, {&__pyx_n_s_IOrderedDict, __pyx_k_IOrderedDict, sizeof(__pyx_k_IOrderedDict), 0, 0, 1, 1}, {&__pyx_n_s_ImportError, __pyx_k_ImportError, sizeof(__pyx_k_ImportError), 0, 0, 1, 1}, {&__pyx_n_s_MAX_WBITS, __pyx_k_MAX_WBITS, sizeof(__pyx_k_MAX_WBITS), 0, 0, 1, 1}, {&__pyx_n_s_PATH_INFO, __pyx_k_PATH_INFO, sizeof(__pyx_k_PATH_INFO), 0, 0, 1, 1}, {&__pyx_n_s_ParserData, __pyx_k_ParserData, sizeof(__pyx_k_ParserData), 0, 0, 1, 1}, {&__pyx_n_s_ParserData___init, __pyx_k_ParserData___init, sizeof(__pyx_k_ParserData___init), 0, 0, 1, 1}, {&__pyx_n_s_QUERY_STRING, __pyx_k_QUERY_STRING, sizeof(__pyx_k_QUERY_STRING), 0, 0, 1, 1}, {&__pyx_n_s_RAW_URI, __pyx_k_RAW_URI, sizeof(__pyx_k_RAW_URI), 0, 0, 1, 1}, {&__pyx_n_s_REQUEST_METHOD, __pyx_k_REQUEST_METHOD, sizeof(__pyx_k_REQUEST_METHOD), 0, 0, 1, 1}, {&__pyx_n_s_SCRIPT_NAME, __pyx_k_SCRIPT_NAME, sizeof(__pyx_k_SCRIPT_NAME), 0, 0, 1, 1}, {&__pyx_n_s_SERVER_PROTOCOL, __pyx_k_SERVER_PROTOCOL, sizeof(__pyx_k_SERVER_PROTOCOL), 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__4, __pyx_k__4, sizeof(__pyx_k__4), 0, 0, 1, 0}, {&__pyx_n_s__5, __pyx_k__5, sizeof(__pyx_k__5), 0, 0, 1, 1}, {&__pyx_kp_s__7, __pyx_k__7, sizeof(__pyx_k__7), 0, 0, 1, 0}, {&__pyx_n_s_append, __pyx_k_append, sizeof(__pyx_k_append), 0, 0, 1, 1}, {&__pyx_n_s_b, __pyx_k_b, sizeof(__pyx_k_b), 0, 0, 1, 1}, {&__pyx_n_s_body, __pyx_k_body, sizeof(__pyx_k_body), 0, 0, 1, 1}, {&__pyx_n_s_bytes_to_str, __pyx_k_bytes_to_str, sizeof(__pyx_k_bytes_to_str), 0, 0, 1, 1}, {&__pyx_n_s_chunked, __pyx_k_chunked, sizeof(__pyx_k_chunked), 0, 0, 1, 1}, {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, {&__pyx_kp_s_content_encoding, __pyx_k_content_encoding, sizeof(__pyx_k_content_encoding), 0, 0, 1, 0}, {&__pyx_n_s_data, __pyx_k_data, sizeof(__pyx_k_data), 0, 0, 1, 1}, {&__pyx_n_s_decompress, __pyx_k_decompress, sizeof(__pyx_k_decompress), 0, 0, 1, 1}, {&__pyx_n_s_decompress_first_try, __pyx_k_decompress_first_try, sizeof(__pyx_k_decompress_first_try), 0, 0, 1, 1}, {&__pyx_n_s_decompressobj, __pyx_k_decompressobj, sizeof(__pyx_k_decompressobj), 0, 0, 1, 1}, {&__pyx_n_s_deflate, __pyx_k_deflate, sizeof(__pyx_k_deflate), 0, 0, 1, 1}, {&__pyx_n_s_doc, __pyx_k_doc, sizeof(__pyx_k_doc), 0, 0, 1, 1}, {&__pyx_n_s_environ, __pyx_k_environ, sizeof(__pyx_k_environ), 0, 0, 1, 1}, {&__pyx_n_s_errno, __pyx_k_errno, sizeof(__pyx_k_errno), 0, 0, 1, 1}, {&__pyx_kp_s_errno_out_of_range, __pyx_k_errno_out_of_range, sizeof(__pyx_k_errno_out_of_range), 0, 0, 1, 0}, {&__pyx_n_s_error, __pyx_k_error, sizeof(__pyx_k_error), 0, 0, 1, 1}, {&__pyx_n_s_fragment, __pyx_k_fragment, sizeof(__pyx_k_fragment), 0, 0, 1, 1}, {&__pyx_n_s_get, __pyx_k_get, sizeof(__pyx_k_get), 0, 0, 1, 1}, {&__pyx_n_s_get_errno_description, __pyx_k_get_errno_description, sizeof(__pyx_k_get_errno_description), 0, 0, 1, 1}, {&__pyx_n_s_get_errno_name, __pyx_k_get_errno_name, sizeof(__pyx_k_get_errno_name), 0, 0, 1, 1}, {&__pyx_n_s_get_method, __pyx_k_get_method, sizeof(__pyx_k_get_method), 0, 0, 1, 1}, {&__pyx_n_s_get_url, __pyx_k_get_url, sizeof(__pyx_k_get_url), 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_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1}, {&__pyx_n_s_gzip, __pyx_k_gzip, sizeof(__pyx_k_gzip), 0, 0, 1, 1}, {&__pyx_n_s_header_only, __pyx_k_header_only, sizeof(__pyx_k_header_only), 0, 0, 1, 1}, {&__pyx_n_s_headers, __pyx_k_headers, sizeof(__pyx_k_headers), 0, 0, 1, 1}, {&__pyx_n_s_headers_complete, __pyx_k_headers_complete, sizeof(__pyx_k_headers_complete), 0, 0, 1, 1}, {&__pyx_n_s_http_parser_parser, __pyx_k_http_parser_parser, sizeof(__pyx_k_http_parser_parser), 0, 0, 1, 1}, {&__pyx_kp_s_http_parser_parser_pyx, __pyx_k_http_parser_parser_pyx, sizeof(__pyx_k_http_parser_parser_pyx), 0, 0, 1, 0}, {&__pyx_n_s_http_parser_util, __pyx_k_http_parser_util, sizeof(__pyx_k_http_parser_util), 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_items, __pyx_k_items, sizeof(__pyx_k_items), 0, 0, 1, 1}, {&__pyx_n_s_join, __pyx_k_join, sizeof(__pyx_k_join), 0, 0, 1, 1}, {&__pyx_n_s_kind, __pyx_k_kind, sizeof(__pyx_k_kind), 0, 0, 1, 1}, {&__pyx_n_s_last_field, __pyx_k_last_field, sizeof(__pyx_k_last_field), 0, 0, 1, 1}, {&__pyx_n_s_last_was_value, __pyx_k_last_was_value, sizeof(__pyx_k_last_was_value), 0, 0, 1, 1}, {&__pyx_n_s_length, __pyx_k_length, sizeof(__pyx_k_length), 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_map, __pyx_k_map, sizeof(__pyx_k_map), 0, 0, 1, 1}, {&__pyx_n_s_maybe_parse_url, __pyx_k_maybe_parse_url, sizeof(__pyx_k_maybe_parse_url), 0, 0, 1, 1}, {&__pyx_n_s_message_begin, __pyx_k_message_begin, sizeof(__pyx_k_message_begin), 0, 0, 1, 1}, {&__pyx_n_s_message_complete, __pyx_k_message_complete, sizeof(__pyx_k_message_complete), 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_object, __pyx_k_object, sizeof(__pyx_k_object), 0, 0, 1, 1}, {&__pyx_n_s_os, __pyx_k_os, sizeof(__pyx_k_os), 0, 0, 1, 1}, {&__pyx_n_s_partial_body, __pyx_k_partial_body, sizeof(__pyx_k_partial_body), 0, 0, 1, 1}, {&__pyx_n_s_path, __pyx_k_path, sizeof(__pyx_k_path), 0, 0, 1, 1}, {&__pyx_n_s_prepare, __pyx_k_prepare, sizeof(__pyx_k_prepare), 0, 0, 1, 1}, {&__pyx_n_s_qualname, __pyx_k_qualname, sizeof(__pyx_k_qualname), 0, 0, 1, 1}, {&__pyx_n_s_query, __pyx_k_query, sizeof(__pyx_k_query), 0, 0, 1, 1}, {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1}, {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1}, {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1}, {&__pyx_n_s_replace, __pyx_k_replace, sizeof(__pyx_k_replace), 0, 0, 1, 1}, {&__pyx_kp_s_s_s, __pyx_k_s_s, sizeof(__pyx_k_s_s), 0, 0, 1, 0}, {&__pyx_kp_s_s_s_2, __pyx_k_s_s_2, sizeof(__pyx_k_s_s_2), 0, 0, 1, 0}, {&__pyx_n_s_self, __pyx_k_self, sizeof(__pyx_k_self), 0, 0, 1, 1}, {&__pyx_kp_s_self__parser_self__settings_cann, __pyx_k_self__parser_self__settings_cann, sizeof(__pyx_k_self__parser_self__settings_cann), 0, 0, 1, 0}, {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1}, {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1}, {&__pyx_n_s_split, __pyx_k_split, sizeof(__pyx_k_split), 0, 0, 1, 1}, {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, {&__pyx_kp_s_transfer_encoding, __pyx_k_transfer_encoding, sizeof(__pyx_k_transfer_encoding), 0, 0, 1, 0}, {&__pyx_n_s_unquote, __pyx_k_unquote, sizeof(__pyx_k_unquote), 0, 0, 1, 1}, {&__pyx_n_s_update, __pyx_k_update, sizeof(__pyx_k_update), 0, 0, 1, 1}, {&__pyx_n_s_upper, __pyx_k_upper, sizeof(__pyx_k_upper), 0, 0, 1, 1}, {&__pyx_n_s_url, __pyx_k_url, sizeof(__pyx_k_url), 0, 0, 1, 1}, {&__pyx_n_s_urllib_parse, __pyx_k_urllib_parse, sizeof(__pyx_k_urllib_parse), 0, 0, 1, 1}, {&__pyx_n_s_urlparse, __pyx_k_urlparse, sizeof(__pyx_k_urlparse), 0, 0, 1, 1}, {&__pyx_n_s_urlsplit, __pyx_k_urlsplit, sizeof(__pyx_k_urlsplit), 0, 0, 1, 1}, {&__pyx_n_s_zlib, __pyx_k_zlib, sizeof(__pyx_k_zlib), 0, 0, 1, 1}, {0, 0, 0, 0, 0, 0, 0} }; static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(0, 10, __pyx_L1_error) __pyx_builtin_object = __Pyx_GetBuiltinName(__pyx_n_s_object); if (!__pyx_builtin_object) __PYX_ERR(0, 171, __pyx_L1_error) __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(0, 162, __pyx_L1_error) __pyx_builtin_map = __Pyx_GetBuiltinName(__pyx_n_s_map); if (!__pyx_builtin_map) __PYX_ERR(0, 323, __pyx_L1_error) __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(1, 2, __pyx_L1_error) return 0; __pyx_L1_error:; return -1; } static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); /* "http_parser/parser.pyx":162 * def get_errno_name(errno): * if not HPE_OK <= errno <= HPE_UNKNOWN: * raise ValueError('errno out of range') # <<<<<<<<<<<<<< * return http_errno_name(errno) * */ __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_s_errno_out_of_range); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 162, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__2); __Pyx_GIVEREF(__pyx_tuple__2); /* "http_parser/parser.pyx":304 * * environ = dict() * script_name = os.environ.get("SCRIPT_NAME", "") # <<<<<<<<<<<<<< * for key, val in self._data.headers.items(): * ku = key.upper() */ __pyx_tuple__3 = PyTuple_Pack(2, __pyx_n_s_SCRIPT_NAME, __pyx_kp_s_); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 304, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__3); __Pyx_GIVEREF(__pyx_tuple__3); /* "http_parser/parser.pyx":314 * environ['SCRIPT_NAME'] = val * else: * environ['HTTP_%s' % ku.replace('-','_')] = val # <<<<<<<<<<<<<< * * if script_name: */ __pyx_tuple__6 = PyTuple_Pack(2, __pyx_kp_s__4, __pyx_n_s__5); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 314, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__6); __Pyx_GIVEREF(__pyx_tuple__6); /* "http_parser/parser.pyx":377 * def is_chunked(self): * """ return True if Transfer-Encoding header value is chunked""" * te = self._data.headers.get('transfer-encoding', '').lower() # <<<<<<<<<<<<<< * return te == 'chunked' * */ __pyx_tuple__8 = PyTuple_Pack(2, __pyx_kp_s_transfer_encoding, __pyx_kp_s_); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(0, 377, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__8); __Pyx_GIVEREF(__pyx_tuple__8); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError("self._parser,self._settings cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError("self._parser,self._settings cannot be converted to a Python object for pickling") */ __pyx_tuple__9 = PyTuple_Pack(1, __pyx_kp_s_self__parser_self__settings_cann); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(1, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__9); __Pyx_GIVEREF(__pyx_tuple__9); /* "(tree fragment)":4 * raise TypeError("self._parser,self._settings cannot be converted to a Python object for pickling") * def __setstate_cython__(self, __pyx_state): * raise TypeError("self._parser,self._settings cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< */ __pyx_tuple__10 = PyTuple_Pack(1, __pyx_kp_s_self__parser_self__settings_cann); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__10); __Pyx_GIVEREF(__pyx_tuple__10); /* "http_parser/parser.pyx":160 * * * def get_errno_name(errno): # <<<<<<<<<<<<<< * if not HPE_OK <= errno <= HPE_UNKNOWN: * raise ValueError('errno out of range') */ __pyx_tuple__11 = PyTuple_Pack(1, __pyx_n_s_errno); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(0, 160, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__11); __Pyx_GIVEREF(__pyx_tuple__11); __pyx_codeobj__12 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__11, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_http_parser_parser_pyx, __pyx_n_s_get_errno_name, 160, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__12)) __PYX_ERR(0, 160, __pyx_L1_error) /* "http_parser/parser.pyx":165 * return http_errno_name(errno) * * def get_errno_description(errno): # <<<<<<<<<<<<<< * if not HPE_OK <= errno <= HPE_UNKNOWN: * raise ValueError('errno out of range') */ __pyx_tuple__13 = PyTuple_Pack(1, __pyx_n_s_errno); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(0, 165, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__13); __Pyx_GIVEREF(__pyx_tuple__13); __pyx_codeobj__14 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__13, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_http_parser_parser_pyx, __pyx_n_s_get_errno_description, 165, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__14)) __PYX_ERR(0, 165, __pyx_L1_error) /* "http_parser/parser.pyx":171 * * * class _ParserData(object): # <<<<<<<<<<<<<< * * def __init__(self, decompress=False, header_only=False): */ __pyx_tuple__15 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(0, 171, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__15); __Pyx_GIVEREF(__pyx_tuple__15); /* "http_parser/parser.pyx":173 * class _ParserData(object): * * def __init__(self, decompress=False, header_only=False): # <<<<<<<<<<<<<< * self.url = "" * self.body = [] */ __pyx_tuple__16 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_decompress, __pyx_n_s_header_only); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(0, 173, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__16); __Pyx_GIVEREF(__pyx_tuple__16); __pyx_codeobj__17 = (PyObject*)__Pyx_PyCode_New(3, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__16, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_http_parser_parser_pyx, __pyx_n_s_init, 173, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__17)) __PYX_ERR(0, 173, __pyx_L1_error) __pyx_tuple__18 = PyTuple_Pack(2, ((PyObject *)Py_False), ((PyObject *)Py_False)); if (unlikely(!__pyx_tuple__18)) __PYX_ERR(0, 173, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__18); __Pyx_GIVEREF(__pyx_tuple__18); __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_RefNannyFinishContext(); return -1; } static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { __pyx_umethod_PyDict_Type_update.type = (PyObject*)&PyDict_Type; 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) __pyx_int_2 = PyInt_FromLong(2); if (unlikely(!__pyx_int_2)) __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) return 0; __pyx_L1_error:; return -1; } static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/ static int __Pyx_modinit_global_init_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); /*--- Global init code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_variable_export_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); /*--- Variable export code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_function_export_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); /*--- Function export code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_type_init_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); /*--- Type init code ---*/ if (PyType_Ready(&__pyx_type_11http_parser_6parser_HttpParser) < 0) __PYX_ERR(0, 193, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_11http_parser_6parser_HttpParser.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_11http_parser_6parser_HttpParser.tp_dictoffset && __pyx_type_11http_parser_6parser_HttpParser.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_11http_parser_6parser_HttpParser.tp_getattro = __Pyx_PyObject_GenericGetAttr; } #if CYTHON_COMPILING_IN_CPYTHON { PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_11http_parser_6parser_HttpParser, "__init__"); if (unlikely(!wrapper)) __PYX_ERR(0, 193, __pyx_L1_error) if (Py_TYPE(wrapper) == &PyWrapperDescr_Type) { __pyx_wrapperbase_11http_parser_6parser_10HttpParser___init__ = *((PyWrapperDescrObject *)wrapper)->d_base; __pyx_wrapperbase_11http_parser_6parser_10HttpParser___init__.doc = __pyx_doc_11http_parser_6parser_10HttpParser___init__; ((PyWrapperDescrObject *)wrapper)->d_base = &__pyx_wrapperbase_11http_parser_6parser_10HttpParser___init__; } } #endif if (PyObject_SetAttr(__pyx_m, __pyx_n_s_HttpParser, (PyObject *)&__pyx_type_11http_parser_6parser_HttpParser) < 0) __PYX_ERR(0, 193, __pyx_L1_error) if (__Pyx_setup_reduce((PyObject*)&__pyx_type_11http_parser_6parser_HttpParser) < 0) __PYX_ERR(0, 193, __pyx_L1_error) __pyx_ptype_11http_parser_6parser_HttpParser = &__pyx_type_11http_parser_6parser_HttpParser; __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_RefNannyFinishContext(); return -1; } static int __Pyx_modinit_type_import_code(void) { __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); /*--- Type import code ---*/ __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 9, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type", #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 sizeof(PyTypeObject), #else sizeof(PyHeapTypeObject), #endif __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_7cpython_4type_type) __PYX_ERR(2, 9, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_ptype_7cpython_4bool_bool = __Pyx_ImportType(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "bool", sizeof(PyBoolObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_7cpython_4bool_bool) __PYX_ERR(3, 8, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_ptype_7cpython_7complex_complex = __Pyx_ImportType(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "complex", sizeof(PyComplexObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_7cpython_7complex_complex) __PYX_ERR(4, 15, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_RefNannyFinishContext(); return -1; } static int __Pyx_modinit_variable_import_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); /*--- Variable import code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_function_import_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); /*--- Function import code ---*/ __Pyx_RefNannyFinishContext(); return 0; } #if PY_MAJOR_VERSION < 3 #ifdef CYTHON_NO_PYINIT_EXPORT #define __Pyx_PyMODINIT_FUNC void #else #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC #endif #else #ifdef CYTHON_NO_PYINIT_EXPORT #define __Pyx_PyMODINIT_FUNC PyObject * #else #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC #endif #endif #if PY_MAJOR_VERSION < 3 __Pyx_PyMODINIT_FUNC initparser(void) CYTHON_SMALL_CODE; /*proto*/ __Pyx_PyMODINIT_FUNC initparser(void) #else __Pyx_PyMODINIT_FUNC PyInit_parser(void) CYTHON_SMALL_CODE; /*proto*/ __Pyx_PyMODINIT_FUNC PyInit_parser(void) #if CYTHON_PEP489_MULTI_PHASE_INIT { return PyModuleDef_Init(&__pyx_moduledef); } static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { #if PY_VERSION_HEX >= 0x030700A1 static PY_INT64_T main_interpreter_id = -1; PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); if (main_interpreter_id == -1) { main_interpreter_id = current_id; return (unlikely(current_id == -1)) ? -1 : 0; } else if (unlikely(main_interpreter_id != current_id)) #else static PyInterpreterState *main_interpreter = NULL; PyInterpreterState *current_interpreter = PyThreadState_Get()->interp; if (!main_interpreter) { main_interpreter = current_interpreter; } else if (unlikely(main_interpreter != current_interpreter)) #endif { PyErr_SetString( PyExc_ImportError, "Interpreter change detected - this module can only be loaded into one interpreter per process."); return -1; } return 0; } static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) { PyObject *value = PyObject_GetAttrString(spec, from_name); int result = 0; if (likely(value)) { if (allow_none || value != Py_None) { result = PyDict_SetItemString(moddict, to_name, value); } Py_DECREF(value); } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { PyErr_Clear(); } else { result = -1; } return result; } static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) { PyObject *module = NULL, *moddict, *modname; if (__Pyx_check_single_interpreter()) return NULL; if (__pyx_m) return __Pyx_NewRef(__pyx_m); modname = PyObject_GetAttrString(spec, "name"); if (unlikely(!modname)) goto bad; module = PyModule_NewObject(modname); Py_DECREF(modname); if (unlikely(!module)) goto bad; moddict = PyModule_GetDict(module); if (unlikely(!moddict)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; return module; bad: Py_XDECREF(module); return NULL; } static CYTHON_SMALL_CODE int __pyx_pymod_exec_parser(PyObject *__pyx_pyinit_module) #endif #endif { 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; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; __Pyx_RefNannyDeclarations #if CYTHON_PEP489_MULTI_PHASE_INIT if (__pyx_m) { if (__pyx_m == __pyx_pyinit_module) return 0; PyErr_SetString(PyExc_RuntimeError, "Module 'parser' has already been imported. Re-initialisation is not supported."); return -1; } #elif PY_MAJOR_VERSION >= 3 if (__pyx_m) return __Pyx_NewRef(__pyx_m); #endif #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("__Pyx_PyMODINIT_FUNC PyInit_parser(void)", 0); if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #ifdef __Pxy_PyFrame_Initialize_Offsets __Pxy_PyFrame_Initialize_Offsets(); #endif __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_AsyncGen_USED if (__pyx_AsyncGen_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 CYTHON_PEP489_MULTI_PHASE_INIT __pyx_m = __pyx_pyinit_module; Py_INCREF(__pyx_m); #else #if PY_MAJOR_VERSION < 3 __pyx_m = Py_InitModule4("parser", __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) #endif __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) Py_INCREF(__pyx_b); __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) Py_INCREF(__pyx_cython_runtime); 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_http_parser__parser) { if (PyObject_SetAttr(__pyx_m, __pyx_n_s_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, "http_parser.parser")) { if (unlikely(PyDict_SetItemString(modules, "http_parser.parser", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) } } #endif /*--- Builtin init code ---*/ if (__Pyx_InitCachedBuiltins() < 0) goto __pyx_L1_error; /*--- Constants init code ---*/ if (__Pyx_InitCachedConstants() < 0) goto __pyx_L1_error; /*--- Global type/function init code ---*/ (void)__Pyx_modinit_global_init_code(); (void)__Pyx_modinit_variable_export_code(); (void)__Pyx_modinit_function_export_code(); if (unlikely(__Pyx_modinit_type_init_code() != 0)) goto __pyx_L1_error; if (unlikely(__Pyx_modinit_type_import_code() != 0)) goto __pyx_L1_error; (void)__Pyx_modinit_variable_import_code(); (void)__Pyx_modinit_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 /* "http_parser/parser.pyx":7 * * from libc.stdlib cimport * * import os # <<<<<<<<<<<<<< * try: * from urllib.parse import urlsplit */ __pyx_t_1 = __Pyx_Import(__pyx_n_s_os, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 7, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_os, __pyx_t_1) < 0) __PYX_ERR(0, 7, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "http_parser/parser.pyx":8 * from libc.stdlib cimport * * import os * try: # <<<<<<<<<<<<<< * from urllib.parse import urlsplit * except ImportError: */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); __Pyx_XGOTREF(__pyx_t_4); /*try:*/ { /* "http_parser/parser.pyx":9 * import os * try: * from urllib.parse import urlsplit # <<<<<<<<<<<<<< * except ImportError: * from urlparse import urlsplit */ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 9, __pyx_L2_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_urlsplit); __Pyx_GIVEREF(__pyx_n_s_urlsplit); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_urlsplit); __pyx_t_5 = __Pyx_Import(__pyx_n_s_urllib_parse, __pyx_t_1, -1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 9, __pyx_L2_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_5, __pyx_n_s_urlsplit); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 9, __pyx_L2_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_urlsplit, __pyx_t_1) < 0) __PYX_ERR(0, 9, __pyx_L2_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; /* "http_parser/parser.pyx":8 * from libc.stdlib cimport * * import os * try: # <<<<<<<<<<<<<< * from urllib.parse import urlsplit * except ImportError: */ } __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L7_try_end; __pyx_L2_error:; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; /* "http_parser/parser.pyx":10 * try: * from urllib.parse import urlsplit * except ImportError: # <<<<<<<<<<<<<< * from urlparse import urlsplit * */ __pyx_t_6 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_ImportError); if (__pyx_t_6) { __Pyx_AddTraceback("http_parser.parser", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_1, &__pyx_t_7) < 0) __PYX_ERR(0, 10, __pyx_L4_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_1); __Pyx_GOTREF(__pyx_t_7); /* "http_parser/parser.pyx":11 * from urllib.parse import urlsplit * except ImportError: * from urlparse import urlsplit # <<<<<<<<<<<<<< * * import zlib */ __pyx_t_8 = PyList_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 11, __pyx_L4_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_INCREF(__pyx_n_s_urlsplit); __Pyx_GIVEREF(__pyx_n_s_urlsplit); PyList_SET_ITEM(__pyx_t_8, 0, __pyx_n_s_urlsplit); __pyx_t_9 = __Pyx_Import(__pyx_n_s_urlparse, __pyx_t_8, -1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 11, __pyx_L4_except_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = __Pyx_ImportFrom(__pyx_t_9, __pyx_n_s_urlsplit); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 11, __pyx_L4_except_error) __Pyx_GOTREF(__pyx_t_8); if (PyDict_SetItem(__pyx_d, __pyx_n_s_urlsplit, __pyx_t_8) < 0) __PYX_ERR(0, 11, __pyx_L4_except_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; goto __pyx_L3_exception_handled; } goto __pyx_L4_except_error; __pyx_L4_except_error:; /* "http_parser/parser.pyx":8 * from libc.stdlib cimport * * import os * try: # <<<<<<<<<<<<<< * from urllib.parse import urlsplit * except ImportError: */ __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); goto __pyx_L1_error; __pyx_L3_exception_handled:; __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); __pyx_L7_try_end:; } /* "http_parser/parser.pyx":13 * from urlparse import urlsplit * * import zlib # <<<<<<<<<<<<<< * * from http_parser.util import b, bytes_to_str, IOrderedDict, unquote */ __pyx_t_7 = __Pyx_Import(__pyx_n_s_zlib, 0, -1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (PyDict_SetItem(__pyx_d, __pyx_n_s_zlib, __pyx_t_7) < 0) __PYX_ERR(0, 13, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; /* "http_parser/parser.pyx":15 * import zlib * * from http_parser.util import b, bytes_to_str, IOrderedDict, unquote # <<<<<<<<<<<<<< * * cdef extern from "pyversion_compat.h": */ __pyx_t_7 = PyList_New(4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_INCREF(__pyx_n_s_b); __Pyx_GIVEREF(__pyx_n_s_b); PyList_SET_ITEM(__pyx_t_7, 0, __pyx_n_s_b); __Pyx_INCREF(__pyx_n_s_bytes_to_str); __Pyx_GIVEREF(__pyx_n_s_bytes_to_str); PyList_SET_ITEM(__pyx_t_7, 1, __pyx_n_s_bytes_to_str); __Pyx_INCREF(__pyx_n_s_IOrderedDict); __Pyx_GIVEREF(__pyx_n_s_IOrderedDict); PyList_SET_ITEM(__pyx_t_7, 2, __pyx_n_s_IOrderedDict); __Pyx_INCREF(__pyx_n_s_unquote); __Pyx_GIVEREF(__pyx_n_s_unquote); PyList_SET_ITEM(__pyx_t_7, 3, __pyx_n_s_unquote); __pyx_t_1 = __Pyx_Import(__pyx_n_s_http_parser_util, __pyx_t_7, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_b); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (PyDict_SetItem(__pyx_d, __pyx_n_s_b, __pyx_t_7) < 0) __PYX_ERR(0, 15, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_bytes_to_str); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (PyDict_SetItem(__pyx_d, __pyx_n_s_bytes_to_str, __pyx_t_7) < 0) __PYX_ERR(0, 15, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_IOrderedDict); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (PyDict_SetItem(__pyx_d, __pyx_n_s_IOrderedDict, __pyx_t_7) < 0) __PYX_ERR(0, 15, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_unquote); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (PyDict_SetItem(__pyx_d, __pyx_n_s_unquote, __pyx_t_7) < 0) __PYX_ERR(0, 15, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "http_parser/parser.pyx":160 * * * def get_errno_name(errno): # <<<<<<<<<<<<<< * if not HPE_OK <= errno <= HPE_UNKNOWN: * raise ValueError('errno out of range') */ __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_11http_parser_6parser_1get_errno_name, NULL, __pyx_n_s_http_parser_parser); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 160, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_errno_name, __pyx_t_1) < 0) __PYX_ERR(0, 160, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "http_parser/parser.pyx":165 * return http_errno_name(errno) * * def get_errno_description(errno): # <<<<<<<<<<<<<< * if not HPE_OK <= errno <= HPE_UNKNOWN: * raise ValueError('errno out of range') */ __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_11http_parser_6parser_3get_errno_description, NULL, __pyx_n_s_http_parser_parser); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 165, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_errno_description, __pyx_t_1) < 0) __PYX_ERR(0, 165, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "http_parser/parser.pyx":171 * * * class _ParserData(object): # <<<<<<<<<<<<<< * * def __init__(self, decompress=False, header_only=False): */ __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__15); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 171, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_7 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_tuple__15, __pyx_n_s_ParserData, __pyx_n_s_ParserData, (PyObject *) NULL, __pyx_n_s_http_parser_parser, (PyObject *) NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 171, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); /* "http_parser/parser.pyx":173 * class _ParserData(object): * * def __init__(self, decompress=False, header_only=False): # <<<<<<<<<<<<<< * self.url = "" * self.body = [] */ __pyx_t_5 = __Pyx_CyFunction_NewEx(&__pyx_mdef_11http_parser_6parser_11_ParserData_1__init__, 0, __pyx_n_s_ParserData___init, NULL, __pyx_n_s_http_parser_parser, __pyx_d, ((PyObject *)__pyx_codeobj__17)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 173, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_5, __pyx_tuple__18); if (__Pyx_SetNameInClass(__pyx_t_7, __pyx_n_s_init, __pyx_t_5) < 0) __PYX_ERR(0, 173, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; /* "http_parser/parser.pyx":171 * * * class _ParserData(object): # <<<<<<<<<<<<<< * * def __init__(self, decompress=False, header_only=False): */ __pyx_t_5 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_ParserData, __pyx_tuple__15, __pyx_t_7, NULL, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 171, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ParserData, __pyx_t_5) < 0) __PYX_ERR(0, 171, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "http_parser/parser.pyx":1 * # -*- coding: utf-8 - # <<<<<<<<<<<<<< * # * # This file is part of http-parser released under the MIT license. */ __pyx_t_1 = __Pyx_PyDict_NewPresized(0); 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_5); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_9); if (__pyx_m) { if (__pyx_d) { __Pyx_AddTraceback("init http_parser.parser", __pyx_clineno, __pyx_lineno, __pyx_filename); } Py_CLEAR(__pyx_m); } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_ImportError, "init http_parser.parser"); } __pyx_L0:; __Pyx_RefNannyFinishContext(); #if CYTHON_PEP489_MULTI_PHASE_INIT return (__pyx_m != NULL) ? 0 : -1; #elif PY_MAJOR_VERSION >= 3 return __pyx_m; #else return; #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(modname); if (!m) goto end; p = PyObject_GetAttrString(m, "RefNannyAPI"); if (!p) goto end; r = PyLong_AsVoidPtr(p); end: Py_XDECREF(p); Py_XDECREF(m); return (__Pyx_RefNannyAPIStruct *)r; } #endif /* PyObjectGetAttrStr */ #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); } #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; } /* PyDictVersioning */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { PyObject *dict = Py_TYPE(obj)->tp_dict; return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0; } static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) { PyObject **dictptr = NULL; Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset; if (offset) { #if CYTHON_COMPILING_IN_CPYTHON dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj); #else dictptr = _PyObject_GetDictPtr(obj); #endif } return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0; } static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) { PyObject *dict = Py_TYPE(obj)->tp_dict; if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict))) return 0; return obj_dict_version == __Pyx_get_object_dict_version(obj); } #endif /* GetModuleGlobalName */ #if CYTHON_USE_DICT_VERSIONS static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value) #else static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) #endif { PyObject *result; #if !CYTHON_AVOID_BORROWED_REFS #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } else if (unlikely(PyErr_Occurred())) { return NULL; } #else result = PyDict_GetItem(__pyx_d, name); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } #endif #else result = PyObject_GetItem(__pyx_d, name); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } PyErr_Clear(); #endif return __Pyx_GetBuiltinName(name); } /* 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); int flags = PyCFunction_GET_FLAGS(func); assert(PyCFunction_Check(func)); assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))); 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()); if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) { return (*((__Pyx_PyCFunctionFastWithKeywords)(void*)meth)) (self, args, nargs, NULL); } else { return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs); } } #endif /* PyFunctionFastCall */ #if CYTHON_FAST_PYCALL static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, PyObject *globals) { PyFrameObject *f; PyThreadState *tstate = __Pyx_PyThreadState_Current; 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 = __Pyx_PyFrame_GetLocalsplus(f); 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, Py_ssize_t 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, (int)nargs, k, (int)nk, d, (int)nd, kwdefs, closure); #else result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, args, (int)nargs, k, (int)nk, d, (int)nd, closure); #endif Py_XDECREF(kwtuple); done: Py_LeaveRecursiveCall(); return result; } #endif #endif /* 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 /* PyObjectCall2Args */ static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) { PyObject *args, *result = NULL; #if CYTHON_FAST_PYCALL if (PyFunction_Check(function)) { PyObject *args[2] = {arg1, arg2}; return __Pyx_PyFunction_FastCall(function, args, 2); } #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(function)) { PyObject *args[2] = {arg1, arg2}; return __Pyx_PyCFunction_FastCall(function, args, 2); } #endif args = PyTuple_New(2); if (unlikely(!args)) goto done; Py_INCREF(arg1); PyTuple_SET_ITEM(args, 0, arg1); Py_INCREF(arg2); PyTuple_SET_ITEM(args, 1, arg2); Py_INCREF(function); result = __Pyx_PyObject_Call(function, args, NULL); Py_DECREF(args); Py_DECREF(function); done: return result; } /* 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 if (likely(PyCFunction_Check(func))) { 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 /* PyObjectSetAttrStr */ #if CYTHON_USE_TYPE_SLOTS 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); } #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 /* 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 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 Py_ssize_t wrapped_i = i; if (wraparound & unlikely(i < 0)) { wrapped_i += PyList_GET_SIZE(o); } if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyList_GET_SIZE(o)))) { PyObject *r = PyList_GET_ITEM(o, wrapped_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 Py_ssize_t wrapped_i = i; if (wraparound & unlikely(i < 0)) { wrapped_i += PyTuple_GET_SIZE(o); } if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyTuple_GET_SIZE(o)))) { PyObject *r = PyTuple_GET_ITEM(o, wrapped_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(__Pyx_is_valid_index(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(__Pyx_is_valid_index(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)); } /* ObjectGetItem */ #if CYTHON_USE_TYPE_SLOTS static PyObject *__Pyx_PyObject_GetIndex(PyObject *obj, PyObject* index) { PyObject *runerr; Py_ssize_t key_value; PySequenceMethods *m = Py_TYPE(obj)->tp_as_sequence; if (unlikely(!(m && m->sq_item))) { PyErr_Format(PyExc_TypeError, "'%.200s' object is not subscriptable", Py_TYPE(obj)->tp_name); return NULL; } key_value = __Pyx_PyIndex_AsSsize_t(index); if (likely(key_value != -1 || !(runerr = PyErr_Occurred()))) { return __Pyx_GetItemInt_Fast(obj, key_value, 0, 1, 1); } if (PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError)) { PyErr_Clear(); PyErr_Format(PyExc_IndexError, "cannot fit '%.200s' into an index-sized integer", Py_TYPE(index)->tp_name); } return NULL; } static PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key) { PyMappingMethods *m = Py_TYPE(obj)->tp_as_mapping; if (likely(m && m->mp_subscript)) { return m->mp_subscript(obj, key); } return __Pyx_PyObject_GetIndex(obj, key); } #endif /* BytesEquals */ static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { #if CYTHON_COMPILING_IN_PYPY return PyObject_RichCompareBool(s1, s2, equals); #else if (s1 == s2) { return (equals == Py_EQ); } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) { const char *ps1, *ps2; Py_ssize_t length = PyBytes_GET_SIZE(s1); if (length != PyBytes_GET_SIZE(s2)) return (equals == Py_NE); ps1 = PyBytes_AS_STRING(s1); ps2 = PyBytes_AS_STRING(s2); if (ps1[0] != ps2[0]) { return (equals == Py_NE); } else if (length == 1) { return (equals == Py_EQ); } else { int result; #if CYTHON_USE_UNICODE_INTERNALS Py_hash_t hash1, hash2; hash1 = ((PyBytesObject*)s1)->ob_shash; hash2 = ((PyBytesObject*)s2)->ob_shash; if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { return (equals == Py_NE); } #endif result = memcmp(ps1, ps2, (size_t)length); return (equals == Py_EQ) ? (result == 0) : (result != 0); } } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) { return (equals == Py_NE); } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) { return (equals == Py_NE); } else { int result; PyObject* py_result = PyObject_RichCompare(s1, s2, equals); if (!py_result) return -1; result = __Pyx_PyObject_IsTrue(py_result); Py_DECREF(py_result); return result; } #endif } /* UnicodeEquals */ static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) { #if CYTHON_COMPILING_IN_PYPY return PyObject_RichCompareBool(s1, s2, equals); #else #if PY_MAJOR_VERSION < 3 PyObject* owned_ref = NULL; #endif int s1_is_unicode, s2_is_unicode; if (s1 == s2) { goto return_eq; } s1_is_unicode = PyUnicode_CheckExact(s1); s2_is_unicode = PyUnicode_CheckExact(s2); #if PY_MAJOR_VERSION < 3 if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) { owned_ref = PyUnicode_FromObject(s2); if (unlikely(!owned_ref)) return -1; s2 = owned_ref; s2_is_unicode = 1; } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) { owned_ref = PyUnicode_FromObject(s1); if (unlikely(!owned_ref)) return -1; s1 = owned_ref; s1_is_unicode = 1; } else if (((!s2_is_unicode) & (!s1_is_unicode))) { return __Pyx_PyBytes_Equals(s1, s2, equals); } #endif if (s1_is_unicode & s2_is_unicode) { Py_ssize_t length; int kind; void *data1, *data2; if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0)) return -1; length = __Pyx_PyUnicode_GET_LENGTH(s1); if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) { goto return_ne; } #if CYTHON_USE_UNICODE_INTERNALS { Py_hash_t hash1, hash2; #if CYTHON_PEP393_ENABLED hash1 = ((PyASCIIObject*)s1)->hash; hash2 = ((PyASCIIObject*)s2)->hash; #else hash1 = ((PyUnicodeObject*)s1)->hash; hash2 = ((PyUnicodeObject*)s2)->hash; #endif if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { goto return_ne; } } #endif kind = __Pyx_PyUnicode_KIND(s1); if (kind != __Pyx_PyUnicode_KIND(s2)) { goto return_ne; } data1 = __Pyx_PyUnicode_DATA(s1); data2 = __Pyx_PyUnicode_DATA(s2); if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) { goto return_ne; } else if (length == 1) { goto return_eq; } else { int result = memcmp(data1, data2, (size_t)(length * kind)); #if PY_MAJOR_VERSION < 3 Py_XDECREF(owned_ref); #endif return (equals == Py_EQ) ? (result == 0) : (result != 0); } } else if ((s1 == Py_None) & s2_is_unicode) { goto return_ne; } else if ((s2 == Py_None) & s1_is_unicode) { goto return_ne; } else { int result; PyObject* py_result = PyObject_RichCompare(s1, s2, equals); #if PY_MAJOR_VERSION < 3 Py_XDECREF(owned_ref); #endif if (!py_result) return -1; result = __Pyx_PyObject_IsTrue(py_result); Py_DECREF(py_result); return result; } return_eq: #if PY_MAJOR_VERSION < 3 Py_XDECREF(owned_ref); #endif return (equals == Py_EQ); return_ne: #if PY_MAJOR_VERSION < 3 Py_XDECREF(owned_ref); #endif return (equals == Py_NE); #endif } /* PyIntBinop */ #if !CYTHON_COMPILING_IN_PYPY static PyObject* __Pyx_PyInt_AddCObj(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, int inplace, int zerodivision_check) { (void)inplace; (void)zerodivision_check; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_CheckExact(op2))) { const long a = intval; long x; long b = PyInt_AS_LONG(op2); x = (long)((unsigned long)a + b); if (likely((x^a) >= 0 || (x^b) >= 0)) return PyInt_FromLong(x); return PyLong_Type.tp_as_number->nb_add(op1, op2); } #endif #if CYTHON_USE_PYLONG_INTERNALS if (likely(PyLong_CheckExact(op2))) { const long a = intval; long b, x; #ifdef HAVE_LONG_LONG const PY_LONG_LONG lla = intval; PY_LONG_LONG llb, llx; #endif const digit* digits = ((PyLongObject*)op2)->ob_digit; const Py_ssize_t size = Py_SIZE(op2); if (likely(__Pyx_sst_abs(size) <= 1)) { b = likely(size) ? digits[0] : 0; if (size == -1) b = -b; } else { switch (size) { case -2: if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { b = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { llb = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; case 2: if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { b = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { llb = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; case -3: if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { b = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { llb = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; case 3: if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { b = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { llb = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; case -4: if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { b = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { llb = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; case 4: if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { b = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { llb = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; default: return PyLong_Type.tp_as_number->nb_add(op1, op2); } } x = a + b; return PyLong_FromLong(x); #ifdef HAVE_LONG_LONG long_long: llx = lla + llb; return PyLong_FromLongLong(llx); #endif } #endif if (PyFloat_CheckExact(op2)) { const long a = intval; double b = PyFloat_AS_DOUBLE(op2); double result; PyFPE_START_PROTECT("add", return NULL) result = ((double)a) + (double)b; PyFPE_END_PROTECT(result) return PyFloat_FromDouble(result); } return (inplace ? PyNumber_InPlaceAdd : PyNumber_Add)(op1, op2); } #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) || __Pyx_CyFunction_Check(func))) #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 /* GetTopmostException */ #if CYTHON_USE_EXC_INFO_STACK static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate) { _PyErr_StackItem *exc_info = tstate->exc_info; while ((exc_info->exc_type == NULL || exc_info->exc_type == Py_None) && exc_info->previous_item != NULL) { exc_info = exc_info->previous_item; } return exc_info; } #endif /* SaveResetException */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { #if CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); *type = exc_info->exc_type; *value = exc_info->exc_value; *tb = exc_info->exc_traceback; #else *type = tstate->exc_type; *value = tstate->exc_value; *tb = tstate->exc_traceback; #endif 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; #if CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = tstate->exc_info; tmp_type = exc_info->exc_type; tmp_value = exc_info->exc_value; tmp_tb = exc_info->exc_traceback; exc_info->exc_type = type; exc_info->exc_value = value; exc_info->exc_traceback = tb; #else 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; #endif Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); } #endif /* FastTypeChecks */ #if CYTHON_COMPILING_IN_CPYTHON static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { while (a) { a = a->tp_base; if (a == b) return 1; } return b == &PyBaseObject_Type; } static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { PyObject *mro; if (a == b) return 1; mro = a->tp_mro; if (likely(mro)) { Py_ssize_t i, n; n = PyTuple_GET_SIZE(mro); for (i = 0; i < n; i++) { if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b) return 1; } return 0; } return __Pyx_InBases(a, b); } #if PY_MAJOR_VERSION == 2 static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { PyObject *exception, *value, *tb; int res; __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ErrFetch(&exception, &value, &tb); res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0; if (unlikely(res == -1)) { PyErr_WriteUnraisable(err); res = 0; } if (!res) { res = PyObject_IsSubclass(err, exc_type2); if (unlikely(res == -1)) { PyErr_WriteUnraisable(err); res = 0; } } __Pyx_ErrRestore(exception, value, tb); return res; } #else static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0; if (!res) { res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); } return res; } #endif static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { Py_ssize_t i, n; assert(PyExceptionClass_Check(exc_type)); n = PyTuple_GET_SIZE(tuple); #if PY_MAJOR_VERSION >= 3 for (i=0; icurexc_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 #if CYTHON_USE_EXC_INFO_STACK { _PyErr_StackItem *exc_info = tstate->exc_info; tmp_type = exc_info->exc_type; tmp_value = exc_info->exc_value; tmp_tb = exc_info->exc_traceback; exc_info->exc_type = local_type; exc_info->exc_value = local_value; exc_info->exc_traceback = local_tb; } #else 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; #endif 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; } /* PyObjectGetMethod */ static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method) { PyObject *attr; #if CYTHON_UNPACK_METHODS && CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_PYTYPE_LOOKUP PyTypeObject *tp = Py_TYPE(obj); PyObject *descr; descrgetfunc f = NULL; PyObject **dictptr, *dict; int meth_found = 0; assert (*method == NULL); if (unlikely(tp->tp_getattro != PyObject_GenericGetAttr)) { attr = __Pyx_PyObject_GetAttrStr(obj, name); goto try_unpack; } if (unlikely(tp->tp_dict == NULL) && unlikely(PyType_Ready(tp) < 0)) { return 0; } descr = _PyType_Lookup(tp, name); if (likely(descr != NULL)) { Py_INCREF(descr); #if PY_MAJOR_VERSION >= 3 #ifdef __Pyx_CyFunction_USED if (likely(PyFunction_Check(descr) || (Py_TYPE(descr) == &PyMethodDescr_Type) || __Pyx_CyFunction_Check(descr))) #else if (likely(PyFunction_Check(descr) || (Py_TYPE(descr) == &PyMethodDescr_Type))) #endif #else #ifdef __Pyx_CyFunction_USED if (likely(PyFunction_Check(descr) || __Pyx_CyFunction_Check(descr))) #else if (likely(PyFunction_Check(descr))) #endif #endif { meth_found = 1; } else { f = Py_TYPE(descr)->tp_descr_get; if (f != NULL && PyDescr_IsData(descr)) { attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); Py_DECREF(descr); goto try_unpack; } } } dictptr = _PyObject_GetDictPtr(obj); if (dictptr != NULL && (dict = *dictptr) != NULL) { Py_INCREF(dict); attr = __Pyx_PyDict_GetItemStr(dict, name); if (attr != NULL) { Py_INCREF(attr); Py_DECREF(dict); Py_XDECREF(descr); goto try_unpack; } Py_DECREF(dict); } if (meth_found) { *method = descr; return 1; } if (f != NULL) { attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); Py_DECREF(descr); goto try_unpack; } if (descr != NULL) { *method = descr; return 0; } PyErr_Format(PyExc_AttributeError, #if PY_MAJOR_VERSION >= 3 "'%.50s' object has no attribute '%U'", tp->tp_name, name); #else "'%.50s' object has no attribute '%.400s'", tp->tp_name, PyString_AS_STRING(name)); #endif return 0; #else attr = __Pyx_PyObject_GetAttrStr(obj, name); goto try_unpack; #endif try_unpack: #if CYTHON_UNPACK_METHODS if (likely(attr) && PyMethod_Check(attr) && likely(PyMethod_GET_SELF(attr) == obj)) { PyObject *function = PyMethod_GET_FUNCTION(attr); Py_INCREF(function); Py_DECREF(attr); *method = function; return 1; } #endif *method = attr; return 0; } /* PyObjectCallMethod1 */ static PyObject* __Pyx__PyObject_CallMethod1(PyObject* method, PyObject* arg) { PyObject *result = __Pyx_PyObject_CallOneArg(method, arg); Py_DECREF(method); return result; } static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg) { PyObject *method = NULL, *result; int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method); if (likely(is_method)) { result = __Pyx_PyObject_Call2Args(method, obj, arg); Py_DECREF(method); return result; } if (unlikely(!method)) return NULL; return __Pyx__PyObject_CallMethod1(method, arg); } /* 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; } /* 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 (cause) { 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 = __Pyx_PyThreadState_Current; 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); } /* PyIntCompare */ static CYTHON_INLINE PyObject* __Pyx_PyInt_EqObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, CYTHON_UNUSED long inplace) { if (op1 == op2) { Py_RETURN_TRUE; } #if PY_MAJOR_VERSION < 3 if (likely(PyInt_CheckExact(op1))) { const long b = intval; long a = PyInt_AS_LONG(op1); if (a == b) Py_RETURN_TRUE; else Py_RETURN_FALSE; } #endif #if CYTHON_USE_PYLONG_INTERNALS if (likely(PyLong_CheckExact(op1))) { int unequal; unsigned long uintval; Py_ssize_t size = Py_SIZE(op1); const digit* digits = ((PyLongObject*)op1)->ob_digit; if (intval == 0) { if (size == 0) Py_RETURN_TRUE; else Py_RETURN_FALSE; } else if (intval < 0) { if (size >= 0) Py_RETURN_FALSE; intval = -intval; size = -size; } else { if (size <= 0) Py_RETURN_FALSE; } uintval = (unsigned long) intval; #if PyLong_SHIFT * 4 < SIZEOF_LONG*8 if (uintval >> (PyLong_SHIFT * 4)) { unequal = (size != 5) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[3] != ((uintval >> (3 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[4] != ((uintval >> (4 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); } else #endif #if PyLong_SHIFT * 3 < SIZEOF_LONG*8 if (uintval >> (PyLong_SHIFT * 3)) { unequal = (size != 4) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[3] != ((uintval >> (3 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); } else #endif #if PyLong_SHIFT * 2 < SIZEOF_LONG*8 if (uintval >> (PyLong_SHIFT * 2)) { unequal = (size != 3) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); } else #endif #if PyLong_SHIFT * 1 < SIZEOF_LONG*8 if (uintval >> (PyLong_SHIFT * 1)) { unequal = (size != 2) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); } else #endif unequal = (size != 1) || (((unsigned long) digits[0]) != (uintval & (unsigned long) PyLong_MASK)); if (unequal == 0) Py_RETURN_TRUE; else Py_RETURN_FALSE; } #endif if (PyFloat_CheckExact(op1)) { const long b = intval; double a = PyFloat_AS_DOUBLE(op1); if ((double)a == (double)b) Py_RETURN_TRUE; else Py_RETURN_FALSE; } return ( PyObject_RichCompare(op1, op2, Py_EQ)); } /* 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 = __Pyx_PyThreadState_Current; PyObject* exc_type = tstate->curexc_type; if (unlikely(exc_type)) { if (likely(__Pyx_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; } /* 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 /* UnpackUnboundCMethod */ static int __Pyx_TryUnpackUnboundCMethod(__Pyx_CachedCFunction* target) { PyObject *method; method = __Pyx_PyObject_GetAttrStr(target->type, *target->method_name); if (unlikely(!method)) return -1; target->method = method; #if CYTHON_COMPILING_IN_CPYTHON #if PY_MAJOR_VERSION >= 3 if (likely(__Pyx_TypeCheck(method, &PyMethodDescr_Type))) #endif { PyMethodDescrObject *descr = (PyMethodDescrObject*) method; target->func = descr->d_method->ml_meth; target->flag = descr->d_method->ml_flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_STACKLESS); } #endif return 0; } /* CallUnboundCMethod1 */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_CallUnboundCMethod1(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg) { if (likely(cfunc->func)) { int flag = cfunc->flag; if (flag == METH_O) { return (*(cfunc->func))(self, arg); } else if (PY_VERSION_HEX >= 0x030600B1 && flag == METH_FASTCALL) { if (PY_VERSION_HEX >= 0x030700A0) { return (*(__Pyx_PyCFunctionFast)(void*)(PyCFunction)cfunc->func)(self, &arg, 1); } else { return (*(__Pyx_PyCFunctionFastWithKeywords)(void*)(PyCFunction)cfunc->func)(self, &arg, 1, NULL); } } else if (PY_VERSION_HEX >= 0x030700A0 && flag == (METH_FASTCALL | METH_KEYWORDS)) { return (*(__Pyx_PyCFunctionFastWithKeywords)(void*)(PyCFunction)cfunc->func)(self, &arg, 1, NULL); } } return __Pyx__CallUnboundCMethod1(cfunc, self, arg); } #endif static PyObject* __Pyx__CallUnboundCMethod1(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg){ PyObject *args, *result = NULL; if (unlikely(!cfunc->func && !cfunc->method) && unlikely(__Pyx_TryUnpackUnboundCMethod(cfunc) < 0)) return NULL; #if CYTHON_COMPILING_IN_CPYTHON if (cfunc->func && (cfunc->flag & METH_VARARGS)) { args = PyTuple_New(1); if (unlikely(!args)) goto bad; Py_INCREF(arg); PyTuple_SET_ITEM(args, 0, arg); if (cfunc->flag & METH_KEYWORDS) result = (*(PyCFunctionWithKeywords)(void*)(PyCFunction)cfunc->func)(self, args, NULL); else result = (*cfunc->func)(self, args); } else { args = PyTuple_New(2); if (unlikely(!args)) goto bad; Py_INCREF(self); PyTuple_SET_ITEM(args, 0, self); Py_INCREF(arg); PyTuple_SET_ITEM(args, 1, arg); result = __Pyx_PyObject_Call(cfunc->method, args, NULL); } #else args = PyTuple_Pack(2, self, arg); if (unlikely(!args)) goto bad; result = __Pyx_PyObject_Call(cfunc->method, args, NULL); #endif bad: Py_XDECREF(args); return result; } /* SliceObject */ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice(PyObject* obj, Py_ssize_t cstart, Py_ssize_t cstop, PyObject** _py_start, PyObject** _py_stop, PyObject** _py_slice, int has_cstart, int has_cstop, CYTHON_UNUSED int wraparound) { #if CYTHON_USE_TYPE_SLOTS PyMappingMethods* mp; #if PY_MAJOR_VERSION < 3 PySequenceMethods* ms = Py_TYPE(obj)->tp_as_sequence; if (likely(ms && ms->sq_slice)) { if (!has_cstart) { if (_py_start && (*_py_start != Py_None)) { cstart = __Pyx_PyIndex_AsSsize_t(*_py_start); if ((cstart == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; } else cstart = 0; } if (!has_cstop) { if (_py_stop && (*_py_stop != Py_None)) { cstop = __Pyx_PyIndex_AsSsize_t(*_py_stop); if ((cstop == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; } else cstop = PY_SSIZE_T_MAX; } if (wraparound && unlikely((cstart < 0) | (cstop < 0)) && likely(ms->sq_length)) { Py_ssize_t l = ms->sq_length(obj); if (likely(l >= 0)) { if (cstop < 0) { cstop += l; if (cstop < 0) cstop = 0; } if (cstart < 0) { cstart += l; if (cstart < 0) cstart = 0; } } else { if (!PyErr_ExceptionMatches(PyExc_OverflowError)) goto bad; PyErr_Clear(); } } return ms->sq_slice(obj, cstart, cstop); } #endif mp = Py_TYPE(obj)->tp_as_mapping; if (likely(mp && mp->mp_subscript)) #endif { PyObject* result; PyObject *py_slice, *py_start, *py_stop; if (_py_slice) { py_slice = *_py_slice; } else { PyObject* owned_start = NULL; PyObject* owned_stop = NULL; if (_py_start) { py_start = *_py_start; } else { if (has_cstart) { owned_start = py_start = PyInt_FromSsize_t(cstart); if (unlikely(!py_start)) goto bad; } else py_start = Py_None; } if (_py_stop) { py_stop = *_py_stop; } else { if (has_cstop) { owned_stop = py_stop = PyInt_FromSsize_t(cstop); if (unlikely(!py_stop)) { Py_XDECREF(owned_start); goto bad; } } else py_stop = Py_None; } py_slice = PySlice_New(py_start, py_stop, Py_None); Py_XDECREF(owned_start); Py_XDECREF(owned_stop); if (unlikely(!py_slice)) goto bad; } #if CYTHON_USE_TYPE_SLOTS result = mp->mp_subscript(obj, py_slice); #else result = PyObject_GetItem(obj, py_slice); #endif if (!_py_slice) { Py_DECREF(py_slice); } return result; } PyErr_Format(PyExc_TypeError, "'%.200s' object is unsliceable", Py_TYPE(obj)->tp_name); bad: return NULL; } /* SliceObject */ static CYTHON_INLINE int __Pyx_PyObject_SetSlice(PyObject* obj, PyObject* value, Py_ssize_t cstart, Py_ssize_t cstop, PyObject** _py_start, PyObject** _py_stop, PyObject** _py_slice, int has_cstart, int has_cstop, CYTHON_UNUSED int wraparound) { #if CYTHON_USE_TYPE_SLOTS PyMappingMethods* mp; #if PY_MAJOR_VERSION < 3 PySequenceMethods* ms = Py_TYPE(obj)->tp_as_sequence; if (likely(ms && ms->sq_ass_slice)) { if (!has_cstart) { if (_py_start && (*_py_start != Py_None)) { cstart = __Pyx_PyIndex_AsSsize_t(*_py_start); if ((cstart == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; } else cstart = 0; } if (!has_cstop) { if (_py_stop && (*_py_stop != Py_None)) { cstop = __Pyx_PyIndex_AsSsize_t(*_py_stop); if ((cstop == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; } else cstop = PY_SSIZE_T_MAX; } if (wraparound && unlikely((cstart < 0) | (cstop < 0)) && likely(ms->sq_length)) { Py_ssize_t l = ms->sq_length(obj); if (likely(l >= 0)) { if (cstop < 0) { cstop += l; if (cstop < 0) cstop = 0; } if (cstart < 0) { cstart += l; if (cstart < 0) cstart = 0; } } else { if (!PyErr_ExceptionMatches(PyExc_OverflowError)) goto bad; PyErr_Clear(); } } return ms->sq_ass_slice(obj, cstart, cstop, value); } #endif mp = Py_TYPE(obj)->tp_as_mapping; if (likely(mp && mp->mp_ass_subscript)) #endif { int result; PyObject *py_slice, *py_start, *py_stop; if (_py_slice) { py_slice = *_py_slice; } else { PyObject* owned_start = NULL; PyObject* owned_stop = NULL; if (_py_start) { py_start = *_py_start; } else { if (has_cstart) { owned_start = py_start = PyInt_FromSsize_t(cstart); if (unlikely(!py_start)) goto bad; } else py_start = Py_None; } if (_py_stop) { py_stop = *_py_stop; } else { if (has_cstop) { owned_stop = py_stop = PyInt_FromSsize_t(cstop); if (unlikely(!py_stop)) { Py_XDECREF(owned_start); goto bad; } } else py_stop = Py_None; } py_slice = PySlice_New(py_start, py_stop, Py_None); Py_XDECREF(owned_start); Py_XDECREF(owned_stop); if (unlikely(!py_slice)) goto bad; } #if CYTHON_USE_TYPE_SLOTS result = mp->mp_ass_subscript(obj, py_slice, value); #else result = value ? PyObject_SetItem(obj, py_slice, value) : PyObject_DelItem(obj, py_slice); #endif if (!_py_slice) { Py_DECREF(py_slice); } return result; } PyErr_Format(PyExc_TypeError, "'%.200s' object does not support slice %.10s", Py_TYPE(obj)->tp_name, value ? "assignment" : "deletion"); bad: return -1; } /* PyObject_GenericGetAttrNoDict */ #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) { PyErr_Format(PyExc_AttributeError, #if PY_MAJOR_VERSION >= 3 "'%.50s' object has no attribute '%U'", tp->tp_name, attr_name); #else "'%.50s' object has no attribute '%.400s'", tp->tp_name, PyString_AS_STRING(attr_name)); #endif return NULL; } static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) { PyObject *descr; PyTypeObject *tp = Py_TYPE(obj); if (unlikely(!PyString_Check(attr_name))) { return PyObject_GenericGetAttr(obj, attr_name); } assert(!tp->tp_dictoffset); descr = _PyType_Lookup(tp, attr_name); if (unlikely(!descr)) { return __Pyx_RaiseGenericGetAttributeError(tp, attr_name); } Py_INCREF(descr); #if PY_MAJOR_VERSION < 3 if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS))) #endif { descrgetfunc f = Py_TYPE(descr)->tp_descr_get; if (unlikely(f)) { PyObject *res = f(descr, obj, (PyObject *)tp); Py_DECREF(descr); return res; } } return descr; } #endif /* PyObject_GenericGetAttr */ #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) { if (unlikely(Py_TYPE(obj)->tp_dictoffset)) { return PyObject_GenericGetAttr(obj, attr_name); } return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name); } #endif /* SetupReduce */ static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { int ret; PyObject *name_attr; name_attr = __Pyx_PyObject_GetAttrStr(meth, __pyx_n_s_name); if (likely(name_attr)) { ret = PyObject_RichCompareBool(name_attr, name, Py_EQ); } else { ret = -1; } if (unlikely(ret < 0)) { PyErr_Clear(); ret = 0; } Py_XDECREF(name_attr); return ret; } static int __Pyx_setup_reduce(PyObject* type_obj) { int ret = 0; PyObject *object_reduce = NULL; PyObject *object_reduce_ex = NULL; PyObject *reduce = NULL; PyObject *reduce_ex = NULL; PyObject *reduce_cython = NULL; PyObject *setstate = NULL; PyObject *setstate_cython = NULL; #if CYTHON_USE_PYTYPE_LOOKUP if (_PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate)) goto __PYX_GOOD; #else if (PyObject_HasAttr(type_obj, __pyx_n_s_getstate)) goto __PYX_GOOD; #endif #if CYTHON_USE_PYTYPE_LOOKUP object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; #else object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; #endif reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_BAD; if (reduce_ex == object_reduce_ex) { #if CYTHON_USE_PYTYPE_LOOKUP object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; #else object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; #endif reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto __PYX_BAD; if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_n_s_reduce_cython)) { reduce_cython = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_cython); if (unlikely(!reduce_cython)) goto __PYX_BAD; ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; setstate = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_setstate); if (!setstate) PyErr_Clear(); if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) { setstate_cython = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_setstate_cython); if (unlikely(!setstate_cython)) goto __PYX_BAD; ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; } PyType_Modified((PyTypeObject*)type_obj); } } goto __PYX_GOOD; __PYX_BAD: if (!PyErr_Occurred()) PyErr_Format(PyExc_RuntimeError, "Unable to initialize pickling for %s", ((PyTypeObject*)type_obj)->tp_name); ret = -1; __PYX_GOOD: #if !CYTHON_USE_PYTYPE_LOOKUP Py_XDECREF(object_reduce); Py_XDECREF(object_reduce_ex); #endif Py_XDECREF(reduce); Py_XDECREF(reduce_ex); Py_XDECREF(reduce_cython); Py_XDECREF(setstate); Py_XDECREF(setstate_cython); return ret; } /* TypeImport */ #ifndef __PYX_HAVE_RT_ImportType #define __PYX_HAVE_RT_ImportType static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size) { PyObject *result = 0; char warning[200]; Py_ssize_t basicsize; #ifdef Py_LIMITED_API PyObject *py_basicsize; #endif result = PyObject_GetAttrString(module, class_name); if (!result) goto bad; if (!PyType_Check(result)) { PyErr_Format(PyExc_TypeError, "%.200s.%.200s is not a type object", module_name, class_name); goto bad; } #ifndef Py_LIMITED_API basicsize = ((PyTypeObject *)result)->tp_basicsize; #else py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); if (!py_basicsize) goto bad; basicsize = PyLong_AsSsize_t(py_basicsize); Py_DECREF(py_basicsize); py_basicsize = 0; if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred()) goto bad; #endif if ((size_t)basicsize < size) { PyErr_Format(PyExc_ValueError, "%.200s.%.200s size changed, may indicate binary incompatibility. " "Expected %zd from C header, got %zd from PyObject", module_name, class_name, size, basicsize); goto bad; } if (check_size == __Pyx_ImportType_CheckSize_Error && (size_t)basicsize != size) { PyErr_Format(PyExc_ValueError, "%.200s.%.200s size changed, may indicate binary incompatibility. " "Expected %zd from C header, got %zd from PyObject", module_name, class_name, size, basicsize); goto bad; } else if (check_size == __Pyx_ImportType_CheckSize_Warn && (size_t)basicsize > size) { PyOS_snprintf(warning, sizeof(warning), "%s.%s size changed, may indicate binary incompatibility. " "Expected %zd from C header, got %zd from PyObject", module_name, class_name, size, basicsize); if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad; } return (PyTypeObject *)result; bad: Py_XDECREF(result); return NULL; } #endif /* 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_MAJOR_VERSION < 3 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, '.')) { module = PyImport_ImportModuleLevelObject( name, global_dict, empty_dict, list, 1); if (!module) { if (!PyErr_ExceptionMatches(PyExc_ImportError)) goto bad; PyErr_Clear(); } } level = 0; } #endif if (!module) { #if PY_MAJOR_VERSION < 3 PyObject *py_level = PyInt_FromLong(level); if (!py_level) goto bad; module = PyObject_CallFunctionObjArgs(py_import, name, global_dict, empty_dict, list, py_level, (PyObject *)NULL); Py_DECREF(py_level); #else module = PyImport_ImportModuleLevelObject( name, global_dict, empty_dict, list, level); #endif } } bad: #if PY_MAJOR_VERSION < 3 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; } /* PyErrExceptionMatches */ #if CYTHON_FAST_THREAD_STATE static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { Py_ssize_t i, n; n = PyTuple_GET_SIZE(tuple); #if PY_MAJOR_VERSION >= 3 for (i=0; icurexc_type; if (exc_type == err) return 1; if (unlikely(!exc_type)) return 0; if (unlikely(PyTuple_Check(err))) return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); return __Pyx_PyErr_GivenExceptionMatches(exc_type, err); } #endif /* 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; } /* 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 */ #include 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, CYTHON_UNUSED void *context) { 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, CYTHON_UNUSED void *context) { 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, CYTHON_UNUSED void *context) { 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, CYTHON_UNUSED void *context) { Py_INCREF(op->func_qualname); return op->func_qualname; } static int __Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, CYTHON_UNUSED void *context) { 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, CYTHON_UNUSED void *context) { 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, CYTHON_UNUSED void *context) { 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, CYTHON_UNUSED void *context) { Py_INCREF(op->func_globals); return op->func_globals; } static PyObject * __Pyx_CyFunction_get_closure(CYTHON_UNUSED __pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) { Py_INCREF(Py_None); return Py_None; } static PyObject * __Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) { 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, CYTHON_UNUSED void *context) { 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, CYTHON_UNUSED void *context) { 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, CYTHON_UNUSED void *context) { 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, CYTHON_UNUSED void *context) { 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, CYTHON_UNUSED void *context) { 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, CYTHON_UNUSED void *context) { 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(PyCFunctionObject, 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_size = 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) { if (__Pyx_CyFunction_weakreflist(m) != NULL) PyObject_ClearWeakRefs((PyObject *) m); __Pyx_CyFunction_clear(m); PyObject_GC_Del(m); } static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m) { PyObject_GC_UnTrack(m); __Pyx__CyFunction_dealloc(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)(void*)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; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS arg0 = PyTuple_GET_ITEM(arg, 0); #else arg0 = PySequence_ITEM(arg, 0); if (unlikely(!arg0)) return NULL; #endif result = (*meth)(self, arg0); #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) Py_DECREF(arg0); #endif 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 #if PY_VERSION_HEX >= 0x030800b1 0, #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, #endif }; static int __pyx_CyFunction_init(void) { __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type); if (unlikely(__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 (unlikely(!m->defaults)) return PyErr_NoMemory(); memset(m->defaults, 0, size); m->defaults_pyobjects = pyobjects; m->defaults_size = size; 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); } /* 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; } /* CLineInTraceback */ #ifndef CYTHON_CLINE_IN_TRACEBACK static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) { PyObject *use_cline; PyObject *ptype, *pvalue, *ptraceback; #if CYTHON_COMPILING_IN_CPYTHON PyObject **cython_runtime_dict; #endif if (unlikely(!__pyx_cython_runtime)) { return c_line; } __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); #if CYTHON_COMPILING_IN_CPYTHON cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime); if (likely(cython_runtime_dict)) { __PYX_PY_DICT_LOOKUP_IF_MODIFIED( use_cline, *cython_runtime_dict, __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback)) } else #endif { PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); if (use_cline_obj) { use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; Py_DECREF(use_cline_obj); } else { PyErr_Clear(); use_cline = NULL; } } if (!use_cline) { c_line = 0; PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); } else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { c_line = 0; } __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); return c_line; } #endif /* 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; PyThreadState *tstate = __Pyx_PyThreadState_Current; if (c_line) { c_line = __Pyx_CLineForTraceback(tstate, c_line); } 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( tstate, /*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_long(long value) { const long neg_one = (long) ((long) 0 - (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_enum__http_errno(enum http_errno value) { const enum http_errno neg_one = (enum http_errno) ((enum http_errno) 0 - (enum http_errno) 1), const_zero = (enum http_errno) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(enum http_errno) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(enum http_errno) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(enum http_errno) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(enum http_errno) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(enum http_errno) <= 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(enum http_errno), little, !is_unsigned); } } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_char(unsigned char value) { const unsigned char neg_one = (unsigned char) ((unsigned char) 0 - (unsigned char) 1), const_zero = (unsigned char) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(unsigned char) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(unsigned char) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(unsigned char) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(unsigned char) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(unsigned char) <= 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 char), little, !is_unsigned); } } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_short(unsigned short value) { const unsigned short neg_one = (unsigned short) ((unsigned short) 0 - (unsigned short) 1), const_zero = (unsigned short) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(unsigned short) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(unsigned short) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(unsigned short) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(unsigned short) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(unsigned short) <= 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 short), little, !is_unsigned); } } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_char(char value) { const char neg_one = (char) ((char) 0 - (char) 1), const_zero = (char) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(char) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(char) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(char) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(char) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(char) <= 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(char), little, !is_unsigned); } } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { const int neg_one = (int) ((int) 0 - (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 size_t __Pyx_PyInt_As_size_t(PyObject *x) { const size_t neg_one = (size_t) ((size_t) 0 - (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 */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { const int neg_one = (int) ((int) 0 - (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 enum http_errno __Pyx_PyInt_As_enum__http_errno(PyObject *x) { const enum http_errno neg_one = (enum http_errno) ((enum http_errno) 0 - (enum http_errno) 1), const_zero = (enum http_errno) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(enum http_errno) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(enum http_errno, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (enum http_errno) 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 (enum http_errno) 0; case 1: __PYX_VERIFY_RETURN_INT(enum http_errno, digit, digits[0]) case 2: if (8 * sizeof(enum http_errno) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(enum http_errno, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(enum http_errno) >= 2 * PyLong_SHIFT) { return (enum http_errno) (((((enum http_errno)digits[1]) << PyLong_SHIFT) | (enum http_errno)digits[0])); } } break; case 3: if (8 * sizeof(enum http_errno) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(enum http_errno, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(enum http_errno) >= 3 * PyLong_SHIFT) { return (enum http_errno) (((((((enum http_errno)digits[2]) << PyLong_SHIFT) | (enum http_errno)digits[1]) << PyLong_SHIFT) | (enum http_errno)digits[0])); } } break; case 4: if (8 * sizeof(enum http_errno) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(enum http_errno, 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(enum http_errno) >= 4 * PyLong_SHIFT) { return (enum http_errno) (((((((((enum http_errno)digits[3]) << PyLong_SHIFT) | (enum http_errno)digits[2]) << PyLong_SHIFT) | (enum http_errno)digits[1]) << PyLong_SHIFT) | (enum http_errno)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 (enum http_errno) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(enum http_errno) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(enum http_errno, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(enum http_errno) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(enum http_errno, 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 (enum http_errno) 0; case -1: __PYX_VERIFY_RETURN_INT(enum http_errno, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(enum http_errno, digit, +digits[0]) case -2: if (8 * sizeof(enum http_errno) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(enum http_errno, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(enum http_errno) - 1 > 2 * PyLong_SHIFT) { return (enum http_errno) (((enum http_errno)-1)*(((((enum http_errno)digits[1]) << PyLong_SHIFT) | (enum http_errno)digits[0]))); } } break; case 2: if (8 * sizeof(enum http_errno) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(enum http_errno, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(enum http_errno) - 1 > 2 * PyLong_SHIFT) { return (enum http_errno) ((((((enum http_errno)digits[1]) << PyLong_SHIFT) | (enum http_errno)digits[0]))); } } break; case -3: if (8 * sizeof(enum http_errno) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(enum http_errno, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(enum http_errno) - 1 > 3 * PyLong_SHIFT) { return (enum http_errno) (((enum http_errno)-1)*(((((((enum http_errno)digits[2]) << PyLong_SHIFT) | (enum http_errno)digits[1]) << PyLong_SHIFT) | (enum http_errno)digits[0]))); } } break; case 3: if (8 * sizeof(enum http_errno) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(enum http_errno, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(enum http_errno) - 1 > 3 * PyLong_SHIFT) { return (enum http_errno) ((((((((enum http_errno)digits[2]) << PyLong_SHIFT) | (enum http_errno)digits[1]) << PyLong_SHIFT) | (enum http_errno)digits[0]))); } } break; case -4: if (8 * sizeof(enum http_errno) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(enum http_errno, 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(enum http_errno) - 1 > 4 * PyLong_SHIFT) { return (enum http_errno) (((enum http_errno)-1)*(((((((((enum http_errno)digits[3]) << PyLong_SHIFT) | (enum http_errno)digits[2]) << PyLong_SHIFT) | (enum http_errno)digits[1]) << PyLong_SHIFT) | (enum http_errno)digits[0]))); } } break; case 4: if (8 * sizeof(enum http_errno) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(enum http_errno, 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(enum http_errno) - 1 > 4 * PyLong_SHIFT) { return (enum http_errno) ((((((((((enum http_errno)digits[3]) << PyLong_SHIFT) | (enum http_errno)digits[2]) << PyLong_SHIFT) | (enum http_errno)digits[1]) << PyLong_SHIFT) | (enum http_errno)digits[0]))); } } break; } #endif if (sizeof(enum http_errno) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(enum http_errno, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(enum http_errno) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(enum http_errno, 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 enum http_errno 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 (enum http_errno) -1; } } else { enum http_errno val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (enum http_errno) -1; val = __Pyx_PyInt_As_enum__http_errno(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to enum http_errno"); return (enum http_errno) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to enum http_errno"); return (enum http_errno) -1; } /* CIntFromPy */ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { const long neg_one = (long) ((long) 0 - (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; if (PyObject_Hash(*t->p) == -1) 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 const char* __Pyx_PyObject_AsString(PyObject* o) { Py_ssize_t ignore; return __Pyx_PyObject_AsStringAndSize(o, &ignore); } #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT #if !CYTHON_PEP393_ENABLED static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { 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 static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII if (likely(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 #endif static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { #if __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)) { return __Pyx_PyUnicode_AsStringAndSize(o, length); } 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 int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { int retval; if (unlikely(!x)) return -1; retval = __Pyx_PyObject_IsTrue(x); Py_DECREF(x); return retval; } static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { #if PY_MAJOR_VERSION >= 3 if (PyLong_Check(result)) { if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, "__int__ returned non-int (type %.200s). " "The ability to return an instance of a strict subclass of int " "is deprecated, and may be removed in a future version of Python.", Py_TYPE(result)->tp_name)) { Py_DECREF(result); return NULL; } return result; } #endif PyErr_Format(PyExc_TypeError, "__%.4s__ returned non-%.4s (type %.200s)", type_name, type_name, Py_TYPE(result)->tp_name); Py_DECREF(result); return NULL; } 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 (likely(PyInt_Check(x) || PyLong_Check(x))) #else if (likely(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 = m->nb_int(x); } else if (m && m->nb_long) { name = "long"; res = m->nb_long(x); } #else if (likely(m && m->nb_int)) { name = "int"; res = m->nb_int(x); } #endif #else if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { res = PyNumber_Int(x); } #endif if (likely(res)) { #if PY_MAJOR_VERSION < 3 if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) { #else if (unlikely(!PyLong_CheckExact(res))) { #endif return __Pyx_PyNumber_IntOrLongWrongResultType(res, name); } } 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(b); } #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_PyBool_FromLong(long b) { return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False); } static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { return PyInt_FromSize_t(ival); } #endif /* Py_PYTHON_H */ http-parser-0.9.0/http_parser/parser.cpython-37m-darwin.so0000755000076500000240000046323013642731431024321 0ustar benoitcstaff00000000000000 (__TEXTPP__text__TEXTp@p__stubs__TEXT'|'__stub_helper__TEXT,*6,*__cstring__TEXTb.b.__const__TEXT@Gf@G__unwind_info__TEXTNXN__DATA_CONSTP P __got__DATA_CONSTP Pj__const__DATA_CONST Q Q__DATAp p __la_symbol_ptr__DATApPp__data__DATAPsPs__common__DATA@__bss__DATA0H__LINKEDIT"0``8 x8HPq PgguhJAݨl/9%>!x<2   ,* 8d/usr/lib/libSystem.B.dylib&h)0UHAWAVAUATSHxDOAtE1LHx[A\A]A^A_]IIILoGMIր*HDڀ,ALDƒ HBMLULEH]HuL}LmMzL`O&IKHhIJHMIJHx1HMHLuML]ADHcA<5HMsABAB=@LmLHEAH9Hc HAA A A"IBAHA#3A tA )A A뇀} A tA4@uAzAAHEDHEH@(Ht3LLpH{L]LULpt A HEDA} yA.1H}HEHH 1HLpLHuH)LLUEJtAAHED1ALpL]HsMIBLL)H9HBHuHIDNDH)IBAA:1HEH}IH#HEHH01HEIH LpLH)HLLUEJtAAHEDLm1HEALpL]HA u_A3A+AHEHHvLLLUEJtAAHEDIAL]B\H&*AQHMHIDHMHxA*s3cpHE tr tm u?AwtuHE wH$HDMhA<MALUL]rAB } 4)ABH}tKHEHHHt>LLHuH)LLUEJtAAHEDAIL]*1HEHEHEA A sAE/AT,A$ AABA"IB  HA}TAdATAQAPyA>}/fA +HE< XfArAB A.A Ѐ 'fArAB A A AF< fArAB AF< {ABDFfAB=~ A WA ` } A)HEHHHA LLLUEJAAA  A  A"IBA AƟAhABABHMHM3?H(ABABHEHH LLLUEJtAAHEDAI#Hu@AJH0HAB@ A$ } % DHEHMIDHEAzkA]  HQA ATA! }TA" APA# A/A$ AF< fArAB%m A.bA&Z AD$< fArAB'; A tA aA(" A A) A  A  HEHIDHEA,HxA A pHEA.A A-HE<<< A  Hn%IHIBAB0a A R A  ABIz]A5, IBLL)H9HBHUHIDHUNDH)IB A6 A E A7H}tKHEHH0Ht>LLHuH)LLUEJtAAHEDAIL] 1HE A  ABAB/j HEHIDHELhO EMLLDH #AHM ɀ HHc HA HE} A2A  ABEc A LIBHHEMLDHEEAF< yl A &  tt  AAD$< 0 ABDFfAB4H"I HLIRHHHH9 H IBAA"ABABAB~8k Zm@H<AB(EMLDIAHEHH8H_A A A: A+A AB)HE<  ABDFfAB= A A A/}A;t A  A1dAHEHH8HLULLUEJtAAHEDMA)A.H}tKHEHHHt>LLHuH)LLUEJtAAHEDAIL]1HEA)H}tKHEHH Ht>LLHuH)LLUEJtAAHEDAIL]1HEZHE<kA H HcHAcAk@HEAOY<QAB Z@Eb<ZABEMLi LUA9A8Hx} eA.MHEHH HQMLL)LLLDKtDɀကHEAɈAJ1HEMqHuEMLS D AHEHH8HLU EMAD$< HEHAcHE eA @ABW@-<AB<<ARLUABL]HEHEHD HHc HLLmA MAHEHH8HLULLUEJtAAHEDAM@A<ABDAP AB *HE,ABABASABHxIM9pAHN1HE_A,HELmɀ} AA  HEHHHHUHDBH9HLUIBLmHx w{H5:2ulunHEeHx wLH5l:2u= u?HE6Hx wH5H:2uuHEHELm\<9HH9IG8HLЅAE$ AE1HEMLuLmL`L}HuH]LEHtJIGHtALEHuL]LH)LHLUAJt ကAML]HuLEuMt@IG Ht7HuLLL)LLLUAJt ကAMIHuu:Ht@IGHt7LLH)LLUAJt ကAMIt M)MH}IO0HLLHuH)LMAOt ကAMbIM)MTAA !AA EMA3D$ AHUHuD$ AAEI)ML+EIAAAAAA AAAHUHuMD$ AAAAwAAjAA ]D$ NAA DAA7MLLt'DHMЊ$ L+E LHAHEH@8HLutHЊKt ကHEЈLL)HIAAL+eID$ %8K^q#<-m/Baz{;J+p=2MwH?TH@~u@HH a $иs@#D@?B@HH  $и/@#D@?E @HH  $и#?3dXUHftft 1t 1t 1]UHt#OQdrɁt 0tt1]1HwUHH H]HFUH1HHGHG$EȈOg]UHHH -H]UHHH HD]UHAWAVAUATSHIHHAHH}H9-ELe1U̅AL=`E1LuA6P 1IcLE D9uDHUfD'D+UЉH}fTfDDAfAII9wEAELeAL$E\$ IfAD$ 1}tHEHIL9ًUE1LI?@~PD1Ic@I<AD$OAA  AD$A[+D ßrAv@ rAA+EfAD$"Av@ rD ßr Av@sAfEL$  A:@A]A~@ rD ßrA.t A: t +EfAD$AfEL$ X+EfAD$ fAD$AfE<$1fAD$ ++EfAD$fAD$A@fE<$1fAD$HL9"A~vunULesrLtfAt :1At2AD$ H}H1 HHwfAL$1H[A\A]A^A_]Ð$$$$$;pUHGtuD$ȈG]UH1:]UH]ÐUHH=!8]sUHAWAVATSI HxH 8Ht H9t,HH8H5Hk8HL%IMt I$H5YLaHHHIH u HCHP0MLHIH H LHA'xfHH LLAg'xCHH LLAD'x HH LLE1$'yI $u ID$LP0E1L[A\A^A_]UHAWAVAUATSH(IHCHHE1HHHH ^HHt)L9a HYH8H5A H6LLA1HHHH1{A:u:tIHL HHLH141HkHH@ HHG1HGH H= 1HkGH H=s 1HUGH H=HtaIHH5.6HHtWHH@H5sH: HFFFSHGGHkH89tv*H=5xaH55H|5LHcxDHf5=HC H;y5t0H5HYH8HW51H u HCHP01Iu IGLP0HFHL5EILLHFH HH=HEHI HH=~HEHQ HH=EHEH5`}`H4H9HC! C t{"tH{4H{HsH"HSH{HsHHt 1zH HHH8HHH{(H[(u1HEHHEHzHEH`HEHF=Dt"H=eDH5DHDVYH HH5HHuHDH5gH`H=xE4HlDH"H=G4HGHTH=E4HGH_H=F4HpGHjH=HE4H\GHuH5E1HAGH7H5DHD1HGH4H5DHD1ZHFH1H5FH.D10HFH.H5[F1 HFH2H58F1HFH6H5D1HFH:L BHBH11AAQh5B5DSSPSSHPH;FH H5SD1MH FHL BH BH11AAQh5B5fDSSPSS,HPHEHH5YE1HVBHH5DHCH C1HEHL mAH^AH11AAQh5B5CSSPSSHPHAHH H1%HAHH=(51HJ5H9+6uH5H; uH H{5H=4H5, LHHHH; uiHH(HQ H@HQ0H @HQ(H @HQH?HQH?HHIH ?H?H ?H5H?HH(H=?H5[AHD4H5PBH=)4|HH5CH=] `HIH5BH3HH=3H-E1HML91E1E1HHM?K?E?[FHH)?'?!?"HtH??>1E1HHt HuHGP0HHt HuHGP0HHt HuHGP0MtIMu IELP0HtH u HCHP0H=l>HtNH=>t+5k>a>H R>H=8sH=7>Ht9H'>Hu)HGP0 HuHH8H5H==H H H;MH([A\A]A^A_]H2H== =H H===HHu=s=m=kHHN=L=F=DHH'=%=C=HaH=<<HHH<<<H!H<<<HH<<<WHHd<b<\<XZHH=<;<5<Y31E1E1E11HHuHH8He0H51AHHyH-H;;;H5>H=?BHiHH5>H/HH=/HHH*H9tH5>HH5o>Hx/HH=b/HIHH=L0H5->LkH=.0H5>8AH58>H /HH=.HUIHtuH5>L9ug1HH`:^:X:VHH9:7:1:/1E1E1H5=H`.HH=J.HHHH=4/H5U=HSH=/H5?= ADžH=-2HH99{9yE1E1E11HHuHGP0LMtHu HHHQ0MtIu IFLP0MtIMu IELP0HtH u HCHP0EH=HHH5#`HH=H]H u HCHP0H=eHHH5 HH=H%H u HCHP0H=_HHH5 HaHV=HH u HCHP0H=_81HHH=8H5:8HhHHuHGP0HDžYHHH BHL:Mt I9HPHuHHHH@HMA HKH8HH"7 77HqH6 66H HCHP0H.H666HHHH@HIE1Ht HHHt HHHH'H 6HH@HH=6HHHHHHuHGP0HDžH5L6HHHH=5H5&6HLHHuHGP0HDžH u HCHP0HDžEuIu IGLP0HtHHuHHGP0HHH|HHGP0iH qH 55 4HHt HuHGP0HDžHtH u HCHP0HDžL55HL`XM9t-MIFLL葊5r4h4H Y4H=zHHHH;DHIHg4HIMHH=n4LHHIMu IELP0H5+4HHIH=3H5 4H/IMu IELP0H u HCHP0HHt HuHGP0HDžHHt HuHGP0HDžHHt HuHGP0HDžHHH8HXLpL8HHHHHHHt HuHGP0HtH u HCHP0Mt I$H=%31{HH H=2H53H9HHuHGP0HDžrHHe H 2HH@HH2HHHIHAH2HHHIHAH2HHHIHAH=}2HHH HHuHGP0HHDžH52HOHH H=1H51HGHHuHGP0HDžHH51HH H=?1H51H8HHuHGP0HDžHH5d1HH H=0H5A1H/HHuHGP0HDžHH5 12HHz H=0H50HdHHuHGP0HDžHHuHGP0HDžH0H=1SHH" H=0H50HQ?HHuHGP0HDžHF0H=_1HH H=/H5*0HHHuHGP0HDžL%/Mt$E1M~H1IDLxMt&LLQuLLBMuMHL9|L%/MuL-LIELL5/L=k/H51IEHLHB IHLL1H# ILH1HIMu IELP0I $dID$LP0THH).'. !.0HqH..-MHJH-- -1E1IH!H---QHH-- -HHH8L`LpL8HHHHHHHt HuHGP0MtI $u ID$LP0M)I IFLP0H^H,,,UH7H,,,YHH,,,IFL_HHn,l,f,fdHHG,E,?,r=HH,,,HcH++0+H<H++:+HH++y+HH+}+w+uHHX+V+P+!NHH1+/+)+,'HyH +++/HRH***8H+H***;HH***DHHn*l*f*OdHHG*E*?*R=HH ***SHH8hHHH5,HL0H5,HLHH=p*L%q*L-:*L=)L5d*HHǀ1HC(H DHKH[HC`MtIELk 1HC0HC8I$Lc@HCHHChL{PIMtILsXCx1HHCpHHHHHHH)HHHHGH5)H;mHNH+H u HCHP0HDžLH3)HH)LH5O+LIIHuHH8BME1HHL17Ht"HLH1zIH u HCHP0MtIu IFLP0LMH='H5p(L&.I $u ID$LP0HDžHHuHGP0HDžHHuHGP0HDžHH!H=L'H5(H>HHuHGP0HDžHDžH8H&&&HH&&&HH{&y&s&qHHT&R&L&JHH-&+& %&#H-H8H5HHDžHTH%%%|E11H(H%%%H H%%%HHk%i%c%aHH:%8%2%01HeH$$ $.1E1H4H$$$:H H$$$HHHw$u$o$KmK1E1E1-HH%$#$$O1IFHH 1M9dnHH;|11HHItLy;HHHAHHH;|HHn#l# f#HHG#E# ?#1HH## #@HfH"""SH?H"""WHH"""dH uJHCH>HHt"r"l"pjIMu IELP0HDžHH("&" "~HoHcH!!!HDžH1H!!!UHAWAVATSEIIHYHt@HEu E1H;tLLHAH u HCHP0D[A\A^A_]HH8t E1AUHAWAVAUATSPIHtHE1E11%HIHH= FHtcILeQHtRIH}LHHAHu-HH8At"2H}LLHE1IE1E1MtIu IFLP0MtI $u ID$LP0LH[A\A]A^A_]UHAVSIHGHHtHHtH[A^]HH8tHH8H5EL1UHAWAVAUATSH8HMHUAIYEHEL}H=HmH@X)ELhh1HCXHC`HChHt^IH8HGH;$L=$ML;=L;=LE1H=BH5 HGHHIHtILL=vH5 HVCIH#IH@H#K/H=H5q HqE1H{XL{`Lsh(ECXLkhHt HuHGP0MtIu IGLP0MtIu IFLP0EAEDD}EHk#HD5K#HDD&D9HHD9|usL,IEMtfHH}L1HHtHEЉClHIMu IELP0HH ~HCHH8[A\A]A^A_]`0H}HTIEtH=HHuD1 H}HHL (HH1111E1AQuSAVPPPPPPHPIIu IFLP0H u HCHP0MEH "HD5!HDDŬAD9}IcHD9|D;5!u4A@IcHH袿HHH!D5!D5!E9~AIcIcHHHHHrHzHzH2HH9It2H8[A\A]A^A_]IcHD|L,AD5%!IEIFLKL=QIhIFLP0YݾHH  @ DxL(H<L,HHGP0VUHAWAVAUATSHIIIHHGXH}HHC`HuHHChHUHE1LkhLk`LkX衽L9kXHuHtH}HuHtHHEHtHHMHtHI$II6HH9HYLyHHEHAHEHAHt HuHGP0HtH u HCHP0E1MtIu IGLP0DH[A\A]A^A_]1I$IIH}Ht HuHGP0H}Ht HuHGP0H}AHtHuHGUHSPH膽H{(tHYH HH[]UUHHHw@H=1]UHAWAVATSIIHuXIT$L腽HtjIL1mHtIHHLLHIu IGLP0H[A\A^A_]HsHLL[A\A^A_]xIu IGLP01UHAWAVAUATSPIIHH`HtLAׅH{ HtLAׅH{0HtLAׅH{8HtLAׅH{@HtLAׅH{HHtLAׅH{PHtLAׅH{XHt LAׅuwH{hHt LAׅudHHt LAׅuNHHt LAׅu8Lcp1Mt-Kx~&E1KH]UHSPHHt HH[]HHtHxHH1UHSPH Ht6H;5t-HFHuH4H8H5]ճ'HHH1HtHu HHHQ0H[]UHSPHHt HH[]HHtH>xHH11UHSPH Ht6H;5t-HF HuHqH8H5'HHH1HtHu HHHQ0H[]UHSPHHt HH[]HiHt H1UHSP1۹Ht9H;5dt0HF uHH8H5Fg(HHHHHtHu HHHQ0H[]UHSPHHt6HHHHHH HH1Hu HHHQ0H[]ûUHAVSIH=5HGHLHtHHtH[A^]虲HH8H5L1bUHSPHHGtHHHH{pHtHCpHuHGP0H{xHtHCxHuHGP0HHtHǃHuHGP0HHtHǃHuHGP0HHtHǃHuHGP0HCHH[]@C8H\(H[]UHAWAVSPIIHHpHt LAׅuHHt LAׅu1H[A^A_]UHAVSHHpL5LspIHt HuHGP0HLIHt HuHGP01[A^]UHAWAVAUATSHHIHHHEL-Lm~}fpDEH^HpHHUH Hc HHUIHF(HEHEL~ L}LnLmL}H5 L9t7IEH;IEH~HuL5A}tL5L5IL;5DIu IFLP0EH5 L9t7IEH;?IEH~HuL5A}tL5eL5lIL;5bDIu IFLP0EH5 L9IEH;AI}L5HwWIHHc HLϭHEHdH5 HVL觯H.HEHMHIHHH?HL@HH !HHHH8H$H5HaL F1XH H   YYH= H /H;sLCHIH;L;5 L;5L;5LALnLmL般HHHMH5 HVL]H!IHEHEHHF IHELnLmL1HHEHF(HEHEL~ L}LnLmLH;{L2HIH;L;5pL;5cL;5VLABA~Ef.HxL5LELJH]HEI/HJHEL=:H5 HVLHEHtHMHMHEHHH5LHULHSLmL}HMHMH;UtxLH,IH;tzL;5tqL;5thL˫y\A~Ef.H_L5hLELJA~Eff.5/L5:I1Iu IFLP0I|$荸H H H;AAL5 MYI輩H<HH5/ HHU詩nH5 HHU莩ZH5 LHZH3IIu IFLP0H u HCHP0I|$pHuHGP0M|$pM|$(HBHI$HuHGP0I$HHI|$xHuHGP0HID$xHI$HuHGP0HfI$HI$HuHGP0H@I$H[`ID$8H5cID$`H{fHnHowfHnflAL$HHID$XHJID$0HĒID$h1qH H Iu IFLP0HtH u HCHP05^TH EH=fH H H;MHH[A\A]A^A_]H=H5 H U1PH=IHH2HR]HHwy]HHZXRHH31+EEHlH M1fHBHbf{3& UHu>10Ht/H HfHnfpD@pHHH]HH5W18UHAWAVAUATSHHIIffEH^HHKAoEfEfI~I|$H;=tH5tID$HEHtM|$(!L=D.HuHULx L}MuNHfE1H}QHHu+H<I~I0LLHfH舥HH H /-'H=,IHt4HtfH:AE)E)ELrIfoEfI~jL[HEH5HVL<HEHILmIMeLeLIH5OHVLHEHtiIMhH5LpHULHLLe:H}H 5 HH8H$H57HH !L ^A1jI]HH8H$H5HH ߶L A1(HHnlfH=fH j1HH[A\A]A^A_]þUHSP'LHHt HH[]H _H H=UHAWAVSPH Ht6I{"٢IHtFãHt>LxLp H[A^A_]HHec]ZM\^H H 531Iu IGLP0MtIu IFLP05H H=:1^UHAWAVAUATSPHHH H;AL5MI{&蚯HHtwHIFH;LHPIH u HCHP0MIu IFLP0LH[A\A]A^A_]H=H5QHRN8HtHH=pIH/H 0H MnM MfIEI$Iu HLP0LLHMIIMu IELP0MH H A?9Mt2ItH z$IFLP05 H H=a E1UHSP$HHt HH[]H H H=}UHSPHpH5HGHHtHHtHH[] H H 31 +5H=55 6UHAWAVAUATSPIH5WHGHHJIHFIMH; "iI]HrMeHI$IMu HLP0LH MIH u HCHP0MMIMu IELP0IH;=tGH;=t>H;=t5y8H H 1H;=t0HHMtIu IFLP0HH[A\A]A^A_]L;5btOL;5atFL;5Ht=L肞y=H H |1L;5dHH wH;AtL-~MIEIEH;~kLLKIMIMu IELP0IHuHGP0MH5ID$HLHIHL;-Kt%L;-JtL;-1tLkyN1L;-#tHIEL;- tXH;tOH oH9HHH5H1ߛIMu IELP0L-=IE I}uLP0IxHuHGP0MoxIH5HGHHIHL;-Wt%L;-VtL;-=tLwyN1L;-/tHIEL;-tXH;tOH {H9HHH5H1IMu IELP0L-IIE I}uLP0IHuHGP0MIH5.HGHHDIH@L;-]t%L;-\tL;-CtL}yZ1L;-5IEL;-H;H uH9HHH5H1H H !#5!Mt#IMuIELP05H H=H1IMu IELP0L-IE I}uLP0IHuHGP0MRH H ywqvvE1fH; tpH; HH9HXHHJH~1H9DHH9|H5L1IL11@HH="H5HEtI]HIEHIHIMu HLP0MLHLEIH YHCHP0JH=+IHH H 轘IH u HCHP0MMV Iu I@LP0Iu IGLP0豎Hv IHlH EH;A H\H HH5!HCHHHv A0Ho H uHKHHQ0HMH5HHHIHH HH IMu IELP0H5KH1+?HM HEH u HCHP0HXHxpH5HGHH HH H5HCHHH IA1H H u HCHP0INH; " I^H LMvHIHu HP0LH"<H uHKHHQ0HH IuINLHQ0HHHH; Lxt H;  HHH1HH1IHUHHu HHHQ01HE1HEE1E1LhHHsIFH I9NLexI9 IFNIII@H;Let H;IPHIHH;AHHHH HH`HIuLP0MtIu IGLP0MtIMu IELP0H5HCHHHpHILmH2IOH; CMwMI_IHIu LHP0HLC:IIu IFLP0ILhMIu IGLP0MtIMu IELP0H5L?L`t4H5HxL踊LLeHpIυ#H5=Lt?Hprt-H5%HxLdLLeI߅gH5XL'?wt-H5?HxLLLeI߅H5ID$HLHvHH50H1H;HIH u HHCP0H=qH;=IGH;tH%HLJHHIuIGLHP0HHxLI=ILLeHpILLhLIHGP0LeLHIHLe_ I9 OD4H HQH; _H; ҰHH9HXHHJH~1H9DHH9|H5L19LM腉HpHIu LIFP0HCHHH@HpHLhH@H`HtHPH@H׉L`XMudHPHuHGP0HpL11k7IdLs襈HHH9uHL}LmHH0L:HHXLs`H[h1HPHPHI $u ID$LP0MtIu IFLP0HLmL}LhH HCHP0H;ˮOIG@AL1`9IiL}LmHH H8H5D1LwILx HH2[1E1ULmHH2yi1+HʧH[Y3Sv1E1Le1HEH`HEHpeLHH41HHLxx4HH8HH H ]HDH5R1LaIHH1'1E11HEHE HݦHnl5fILHHGE6?_HH#!7H1E1Le1HMLm;LHUH8H1E1Le1HUHMHELxHE^ H H:1E1wHHqo:iE1Le1HELmHpHELxHEI1 HH:1Le1HELmHVH:1E1Le1HELmHpHELxHEMLh0 \HH-{H; KH; H!H9HXH_HJH~1H9D[HH9|H5#1H3UH]H-E111HM1HM1HM1HME1E11@ HH/E11HEH=H5Hp/-%Hp1HMH=)HH3HH0yłlH[H01E1E11HE1HE1HE1MM1HM@ Hp1HE1HMeRmHHyw1q1HE1HE1HE1HEP PHp1HM1HM1HM1HME1E111H; DH; sHH9cHXHAHJH~1H9D=HH9|H5L1l1*HH11E11HE1HE1HE1HEHH&HiIH@HHHHHHH H11Hx/ZL11g/}Ht6L}LmH H1H2_LmL}LhL}LmIu IFLP0H}H;=6LxtBH;=.t9H;=t0Ry3HˠH\Z<T1H;=HXHIxHMH5HEH@HH H}HH HGH;D LeLM H_IHHAu HP0HHGDH;ݦH}LeH;Hu\HG@=uKL}HEHEHrHEHHAHOHAI HHEHALVHpH MH}LptM}HEHIDHHID L1.H IIMIEL}L}HEHEHHEHHHtAL,H IMt@Iu;/1HtLA IH< MH}tIuIGLP0H}HLxuHGP0IFH;\t3H;{t?H@hHH@HLHE.I~iIFHHI~TIN HHMHH}tIu IFLP0|H:HEH5HXHGHH;IHLE3IOH; QI_H^LMHIHu HzP0LH*IH u HCHP0MLElIuIGLP0LEH5kLLV{Iu IFLP0H5HXHGHHIHLEIOH; ңI_HLMHIHu HP0LH)IH u HCHP0LEMIu IGLP08|H/HHmHHCLs H=E1H1+ACHIH u HCHP0H=vL$|HHI $u ID$LP0H=H{HIH H}uHCHP0H}H5Ly?LMHuHGP0H5LmLHUy?H5LHUyHH5mHXHL]yH{pH5lHGHHMYIHLEQH5LLyIu IFLP0HuHuHH { H]LH~H B^"HZHBE11HELEXH)HB"HHBE11HEMME1Mt!IuMIHI@LP0HLMMt!IuMIHIFLP0HLMHEMtIu IGLP0HtH u HCHP05H H=MtIEE1LLmHHuHGP0LmE1H}HLeH]t HuHGP0HtH u HCHP0MtI $u ID$LP0H}Ht HuHGP0MtIMu IELP0HHH;EHLHĘ[A\A]A^A_]HuHBE11HELEjHAHBH]HuLH]HuL1IM H}HuHGP0Iu IFLP0IEHIEMH]HHA?B9K0vHHBM1E1E1jH; (H; HH9HXH`HJH~1H9D\HH9|H5L1P&VLp[BiuHt*HLH vHEH HCHP0HH$"=%1HEE11HEH}uHOH=tLeE1E1 yu!HHDhE1E1H; H; -bH8H9RHXH0HJH~1H9D,HH9|H5:L1$&LpvDE1H`H E1Hp1!H)HCHpLIMIMu IELP0H5IGHLHIHIu IGLP0H{pH5HGHHIHH]IEH;ӓMuMI]IHIMu HLP0HLLIIu IFLP0ILuI $u ID$LP0MqIMu IELP01kHHI~pH5HGHHHЅxIH u HCHP0I~pH5HGHH+HbЅxAIHIL~HϋH`^OXJH u.HCHP0"HH-+P%T5H H='MtI1HIuIGLP01HH[A\A]A^A_]LLWIH=6H5HmMuMwMeII$IMu HԑLP0HLLIIu IFLP0M?&H=IHHHN i%HPHN)IuoIGLci'HHN,(;H H ~|NzMtIMu IELP0E18HHCAO;H!ieiUHAWAVAUATSH8IHuHiHIHRH H;AL%BM(I$ID$H;L}H5L2HHI $u ID$LP0H5,HCHHHIHH u HCHP0LuI~pH5HGHHIHID$H;cMl$MI\$IEHI $u H6LP0HLL6IIMu IELP0IMIu IGLP0MI $u ID$LP0LgHIHEL9LNIEL`pMI|$LfHHH=ЎHH7gIH u HCHP0MLLAT$HIu IFLP0HH]IEL`pMI|$LeHHHHHHfIH u HCHP0MLLAT$HIu IFLP0H]H]H=HuHIHEH@HXpHH{1UeZHIH]L3eHHLmH|LHeIIu IFLP0H u HCHP0MH}LLHEPIMu IELP0LmxhI $u ID$LP0H}H;=H;=t{H;=treyuHH)'[!WLmZHcH I $%ID$LP01H;=utrcHIHEHHID$HHEHxpH5gHGHLHyЅI $ID$LP01ocHvIHEHxpH5 HGHLHtЅxqI $u ID$LP0HEHxpH5 HGHH{H=Ѕx?L cHIH]L}!?_\HH}]w&LLIH lH9HPH5Mz1aHH)'Y!NH ,H9HPH5 z1aHXHYH}HuHGP01HE1HEȋ5H H=yǞE1MH]L}tIMu IELP0HtH u HCHP0MtIu IGLP0LH8[A\A]A^A_]HH20V*H=H5{H| pMl$MHM|$IEII $u H6LP0HLL2HIMu IELP0MH=IHHHsqWk;aHHECW=H u HCHP0E1U`WE11HE1HEH NH ߼ݼWۼE1HEиHEMH HXH H9HPH5wH w1_QHHOMZG}I!IFLP0HH_:>_HNH߻ݻ`׻L H'H\__UHSP'H^HHt HH[]H H XVePH=ve[UHSPHpH5HGHHtHHtHH[]^H QH iںH=VviUHSPHpH5ŽHGHHtHHtHH[]B^H ~H ljmd H=v moUHSPHpH5'HGHHtHHtHH[]]H e~H qFH=uFqUHSPHpH5HGHHtHHtHH[]V]H }H ~uxH=uu胙UHAWAVATSHpH5λHGHH^HHZH5mHCHHHcIH_H u HCHP0H5ʼL1 H=HIu IFLP0H5HCHHH4IH0H u HCHP0INH; σHI^HUMfHI$Iu HLP0LH IH u HCHP0MMcIu IFLP0H5L[HHIu IGLP0H[A\A^A_][H#|Hy\[6H{H|zyt$[H {H FDyBH HCHH; ZH; ́ HطH9HXHHJH~1H9DHH9|H5ڶL1 H{HyMtIu IFLP0E15vH gH=r舖1MisHzH=;z5L116HH9tHuH;2IF@$L1> IUHSPH`fHcYHHt HH[]H zH $H=r$觕UHAVSH=:H5[1& HtZHHH A`u HCHP0H fH )'D5$H=qD11[A^]A\UHAVSH=H51HtZHH:H Au HCHP0H fH D5H=qD讔1[A^]AUHAWAVAUATSH8MIHUI1HUHHMHHuHH}VLuOLvL1Huu*IHGzHH;EuLH [A\A^A_]E11(SUHAWAVSPHHuHGH;yt-IH;xuGHCHt7HLH[A^A_]vHuH|HHH[A^A_]Äx:#RHtNIILpHH1HIuIGLP0H@ uH{1Huu11UHAWAVAUATSPIIILoHGHEH_ QH H Hx;~H=eQt1A}u'A} Cu HtIMu:IcUH9Su0HLH@MV(M^0HtPL5xHuLCHKMV(M^0IcEL9uLLLHMyHL5Ox=MV(M^011L5:xHuLHL1EE1ASARPSjgOH0HPH ɉH APΉ=vO9} lP@$HH[A\A]A^A_]UHAWAVAUATSPIIHHGLM&PH H L-wA;M~H=dPu}HLLAHOH ɉH AEPΉ=vO9} O@$Ht.HH[A\A]A^A_]HLLH[A\A]A^A_]O'NHt1HqvH8H5dNUHAWAVAUATSPIHIIOIHLE1L1NHtWIH~LH 1IHHHH9uL1MIAF AF IuIGLP0AF AF LH[A\A]A^A_]UHAWAVATSIHGLx@ uH_1NH H L%vA; $~H=cOuXHLAHfNH ɉH A$PΉ=vO9} >N@$Ht H[A\A^A_]LHt1H uH8H5bLUHH9u]HG3@&HFHyY@tPHXHt.HQH11H9ttHH9|HH9tHu1H;5sxLVM1H9|OHL9|E1LsN\ICy=A@t3I9HXHt-HJH~1L9\HH9|I1M9|HHtHL9uM9u1];KUHAWAVSPAH9IHHGHNH;su~H; suu{ A~ HSE1I;VIFHtHKHt H9ps AN 9Q@ H[HHTsH1H1HosHH1H L1E1H HLKHHH;)stH;(stH;st HIKAE1H;sAH HCHP0H{0HH@@HE uMvHIv0IH@LEtu A6 A6 A69uNAHtBHHLKE1A(HsKoLaKhADH[A^A_]UHAWAVSPHHHr-y @u2H}qH8H5qcH[A^A_]IHH[A^A_]H1cJHtaIHH1IIIu IGLP0Mt:IN@uH qH8H5bH1H HLHIt H[A^A_]IFLH[A^A_]`0UHAWAVAUATSPIHLwIH54IFHLHkIHgHH H;AsL-ةMIEHLGHgHIEH;qpLHIH u HCHP0MIMu IELP0LLBHHIIu IGLP0I $u ID$LP0H5GIFHLLHЅxIMuOIELP0CHhHWUNONIMu IELP0H=a1MtIu IFLP01H[A\A]A^A_]GHYhHN4H=]H5VHW8H=7蔔IHc6E1dMeMtIMI$HIMuHnHMLP0HMIHLHLIHHDDAƅy=HdHKIC MpE1H;kAH u HCHP0HEEL}tLDHEHH kHL:Mt I9MHPHuHHLhM;9H5ID$HLH IHEH H5IFHLH IHEH Iu IFLP0HEIEH;jSI]H]HBM}HIL}IMu H[jLP0LHHUZIHEH u HCHP0ML}HEM IMu IELP0HEIu IGLP0HEHHLhI1HtHMtIEHMH5sID$HLHIHEHLeLm]H5'IFHLHHHEHIu IFLP0HEHCH;4iLcLeMLkI$IELmH u HiHP0LLHUIHEI $u ID$LP0LLeLmHEM1H u HCHP0HEH}HuHGP0HE}uIu IGLP0H}Ht HuHGP0MtIMu IELP0H5ID$HHphLHЅH5ID$HLHcHHEH[LkL;-gqHCHK H9~ HH9~IHKL4HHCH]HLd? H u HCHP0HEMtI $u ID$LP0MtIu IFLP01HX[A\A]A^A_]HG`H؛֛Л 1HE1E11HE)H`H 1HE1E11HEE1j?*?6H_HQOI >H_H  CL=؜IH;ZfLe5 I@ LL}L{?IH: IIGH;eH;eH oH9HUHXH HrH~1H}1H9LHH9|H1HMHHUH}HpHHuIHELe=hH\^H ;LLcIHE1HEиHEj=^H^H 1HEHE/=^H]HVTN 1HEHEIuRIFLP0FH]H HEHtH u HCHP0HEHMLqXLuHQ`HULihLm1HAhHA`HAXHPH ٘H;AHUH=<HHH5ɚHGHHH}sHHoH}HuHGP0LH]EH u HCHP0HEHxXHX`L`hLpXHMHH`LhhHt HuHGP0HtH u HCHP0MtI $u ID$LP01H]H]H]AHEЃ}_5H H=\UwHuHUHMH}8|MHH H;ALeH=H HH5MHGHHH}AHH}HHEuHGP0HH H;AH HHH5>HAHHHMHHHH}HuHGP0H :HIH u HCHP0H}HGH;aLIIu IFLP0MH}HuHGP0H53ID$HLLHЅ~IMu IELP0H5ID$HLHHH5HHHHHHHHEHH u HHCP0H}HGH;`H_HLgHI$HuH`H}P0LHHUIH u HCHP0LeMDH}HuHGP0H}HuHGP0H}Ht HuHGP0HEH}Ht HuHGP0HEH}Ht HuHGP0HEHEHH8HXL`L8HMHHHMHHHt HuHGP0HtH u HCHP0MtI $u ID$LP0Le>8\1 11E11HMA7hHXXH 77gH'XH HXH Z 111HMAH WH UD5VTH]HHEHH8L`LpL8HMHHHMHHHt HuHGP0ML}tI $u ID$LP0MtILeSIFLP0DMLe;HE1HEHM7HtbL MtZI$HuHVL7Ht0IHI $u ID$LP0MtIu IGLP0MUI $u ID$LP0}H}HSLHUIIu IGLP0MMLeIGH;S]t#LLIIu IGLP0LeJLI9_/HLIHu H ]P0LeLHL IIu IGLP0MtFIM=IELP0.MlH&\H8IUH55OHM13LeHUH+)# NH=H5H'4( 11E1H=THH;& AHLH,IL4L1HuIXH=H5H]'4,? 11E1H=HHLe= A11_H=H5H"3:D 1E1OH=P轀HHLeAH}B 1E11HM9G E11HMAH}H_HLgHI$HuHZH}P0LHLIH u HCHP0LeLeW 1E132?d 11E11HM42Mf E11HMAH1eu 11E1AN1HUHHtHH9uIH; +Y'92UHAWAVAUATSHHHH0HIL{IH5IGHLHIHL;5Yt6L;5Yt-L;5Yt$L1Åy"LmиVE1@1L;5xYIu IFLP0t/H5sHԎIGHLHYЅyH5DIGHLH IHH H yH;ALmL% MnI$ID$H;{XLLIŻXM2I $u ID$LP0LLU0H>IIu IFLP0IMu IELP0H5sIGHLLHSLmЅxHI $u ID$LP0H5?IGHHWLH'ЅyqY?HPH1/X)I $u1ID$LP0$WHaPH H=IvIMu IELP0MtIu IGLP01H[A\A]A^A_]HPHSH=I6/OV\/XCH=̋H5H3vI\$HIL$HHI $uHaVHMLP0HMIHHLVIH HCHP0E1/H=F{IH~XE1H NH Iu IFLP0MtIMu IELP0MLm&X5.+.!.UHAWAVAUATSHIHLIHێH $H;AL%ˎM3I$HL/,HHID$H;UNLH<MLeLmȺiE1MI&&A`bE1&QbbH/GH ‚E11HERg&rcLmIL$HH?H!HH9IL$H+fJIL$HH?H!HH9sYIDHddH +MH9HPH5[@E11$db\H$%H>HLH%HEH u HCHP0HEYL%H\IH$HIM>IELP0/Ht!Hu/A^AFHH *1#A^AFHH L^$HIMH2LHx]H H LH1H#t*#HKH8IFHPH5V?E11u#E11HEйbd0HKH8I#t :#dbE11HEHDHt vtIu IFLP0MtI $u ID$LP0MLetIMu IELP0H=[> MLm-7UHAWAVAUATSPLgI$H5ID$HHKLHЅxkH5ˁID$HLHIE1HL;=;KttL;=:KtkL;=!KtbL[#Åy`& qE1XHCHQOoI E1H== E1M1L;=JIu IGLP0XH5ID$HLHIHH5IEHLHIHIMu IELP0IFH;II^HM~HIIu HILP0HHLHIH u HCHP0MMIu IFLP0H5LA[HނH ~H;AL5΂MILmH5IFHLHIHIu IFLP0HH }H;AL5tMIH5~IFHLHIǺtHIu IFLP0H=9~IGH;^HIGHHHLHHAOHHHHEH HHIu IGLP0IEH;HLH/IH Au HCHP0M$IMu IELP0H5u~ID$HLLH/LmЅIu IGLP0H5.~ID$HHGLHЅvH5~~ID$HLHIHH5}La; vE13H5}L LmHH {H;AL-rMIEH5^}IEHLHtIHpIMu IELP0INH; fFH; 9FLmH; EH{H9HXHHJH~1H9DHH9|H5zL1]{v t u:H5t|ID$HHELHЅ {H>H+z -z+zH=8L11t%H5{L~I)$ q1 rE1qk3 r1HME1H=HzyxyrryB E1E1UO sE1HH9tHuH;CIF@yL1nIMIu IFLP0H5 {ID$HLLHE1 Iu IGLP0H5C{ID$HLHIHH5~zL&Iu IGLP0H5zID$HLHIHL;=CtKL;=CtBL;=Ct9LÅy7 }Hh<Hw wwMuLY1L;=CIu IGLP0E1AB xH<Hw wwIu IGLP0H=96E1I $u ID$LP0MtIMu IELP0DH[A\A]A^A_] }H=wH5|H|DaHh;Hvvtv[ E1LmH=RwgIHY taH=+wH5{H{ WL` E1NH=vhgIH ^ tH;AXLuc E1tH :H &v(v&vIMu IELP0LmMtIu IFLP0MIIGLP0HHAAGHH HMuMM}IIIMu H@LP0LLHMIIIFLP0H9HBu@ut:us MQE1E110  w vH=PuH5yHy%| xH=ueIH= xLm>I^HLmMnHIEIu H?LP0LHIH u HCHP0MLmH8Httx t E1AGX8Lm>AAGHH H?H@`Lc yP yq%UHSPH_HH5TvHCHH>HHtQЅy.H7H.s,s&s> H=1HtH u HCHP01H[]UHSPH_HH5uHCHHt>HHtQЅy.H7Hrrr H=1$HtH u HCHP01H[]bUHAWAVAUATSPIHLhXLp`Lxh1HCXHC`HChMtIEMtIMtILkXLs`L{hLnHEH{XLc`HKhLkXLs`L{hHtHu HGHP0HMtI $uID$LHP0HHH]tH u HAHP0HtHhH t)H[A\A]A^A_]H==H[A\A]A^A_]:HCHH[A\A]A^A_]`0UHAVSIH5wqHGHHt8HHt5HLAƅx(H u HCHP0D[A^]{E1qE1UHAWAVATSHIIHe<HHEmHtqHH@x$H;H8H5/H1H lllIu IGLP0MtIMu IELP0MtI $u ID$LP05llH rlH=-L1H0HQlOlIlZ UHAVSHGtkHGHtHtHu<_J1F_GHH HH t0H6H8H5,Hx=HH uB[A^]ݺHtIHlIuIFLP0H6H8H5o,Hu4HzUHAWAVAUATSPI1HhIHL'HsIH;6tL;-6tL;-6t L 1L;-6tSIMu IELP0HILHƺHII $u ID$LP0Iu IGLP0L;-56tJL;-46tAL;-6t8LUÅy6H.H]j[jUj E1|1L;-5IMu IELP0tsL HsHX HH[A\A]A^A_]HC.Hiii ! E1H=gmH5xm1cHHHH u HCHP0H-Hhifi`i H-HAi?i9i H-Hiii j E1 E1H S-H hhhIu IGLP0MtIMu IELP0MtI $u ID$LP05hhH hH=)H1H,Hfhdh^h UHAWAVAUATSH8IH3HHE1HEW)E~3fpDEH^H'L=3Ht&HtHH M~(L}IF HEHEL}MfLeH5lkHhID$HLHЅ1 HHH5YiID$HLHH$ЅH u HCHP0HlH ggH;AL-vlMIEIMH; n2H; A2H; 1HgH9HXHt}HJH~1H9DtyHH9|H5fL1qrH+Hfffe %p L11ո.HH9tHuH;0uIE@tL1莻HHlIMu IELP0H5hID$HLHHЅ'H u HCHP0H5]hID$HLLH'Ѕ(H5gID$HLHHUЅ"H5gID$HH1LHbЅH5\gID$HH0LH<ЅH5gID$HH0LHЅH5gID$HHy0LHЅH5gID$HHI0LHЅH5gID$HH0LHЅH5\gID$HH/LH~ЅH5fHUeID$HLHXЅH5fID$HH/LH2ЅHt/H H(Hc ccH >HCHP0/H'Hzcxcrc H'HScQcKc H'H,c*c$c Ht'Hccb HM'Hbbb lH&'Hbbb EH&Hbbb H&Hibgbab H&HBb@b:b H&Hbbb Hc&Haaa H4IHHc HLPIH5$eHVL2HEHIIMg|H%Hmakaean 5_aUaH FaH="+1H=aH5jfHkf MuMIEIHHIMu HJ,LP0IHLpHIIFLP0H%H``` M7IM-IELH= a`QIHIH$HT`R`L`z 2>MfLeLIMH5bHVLHHEHEIIF HEHEMfLeLjIMhL=a+M~(L}IF HEHEMfLeL2IUL="+L}HUlH+HEH5aHVLHtIHEIMrH5^L'HULH親,LeHEHEL}8.TzI^1HLDHH HNH)H8H"L LNH$H5H&1H"H;^9^3^I I H=H |"7>1H )H H;MuH8[A\A]A^A_]HE"H]]]6 6 %JH%LH%NH%PH%RH%TH%VH%XH%ZH%\H%^H%`H%bH%dH%fH%hH%jH%lH%nH%pH%rH%tH%vH%xH%zH%|H%~H%H%H%H%H%H%H%H%H%H%H%H%H%H%H%H%H%H%H%H%H%H%H%H%H%H%H%H%H%H%H%H%H%H%H%H%H%H%H%H%H%H%H%H%H%H%H%H%H%H%H%H%H%H%H%H%H%H%H%H%H%H%H%H%H%I%I%I%I%I% I% I%I%I%I%I%I%I%I%Ihhh9hZhshhhhhhhh!h4|hRrhfhh^hThJh@h6h,h"h5hShmhhhhhhh0hYhzhhhhhxh nh'dh<ZhRPhgFh<h2h(hhh hh1hGh]hhhhhhh#h<h[ht~hthjh`hVhLhBh'8hF.h_$huhhhhhh hh2hKhchxhhhhhzh ph> fha \hx Rh Hh >h 4h *h h, hC h\ LEAS%"h{ h h connectionproxy-connectioncontent-lengthtransfer-encodingupgradechunkedkeep-alivecloseDELETEGETHEADPOSTPUTCONNECTOPTIONSTRACECOPYLOCKMKCOLMOVEPROPFINDPROPPATCHSEARCHUNLOCKREPORTMKACTIVITYCHECKOUTMERGEM-SEARCHNOTIFYSUBSCRIBEUNSUBSCRIBEPATCHPURGEHPE_OKsuccessHPE_CB_message_beginthe on_message_begin callback failedHPE_CB_status_completethe on_status_complete callback failedHPE_CB_urlthe on_url callback failedHPE_CB_header_fieldthe on_header_field callback failedHPE_CB_header_valuethe on_header_value callback failedHPE_CB_headers_completethe on_headers_complete callback failedHPE_CB_bodythe on_body callback failedHPE_CB_message_completethe on_message_complete callback failedHPE_INVALID_EOF_STATEstream ended at an unexpected timeHPE_HEADER_OVERFLOWtoo many header bytes seen; overflow detectedHPE_CLOSED_CONNECTIONdata received after completed connection: close messageHPE_INVALID_VERSIONinvalid HTTP versionHPE_INVALID_STATUSinvalid HTTP status codeHPE_INVALID_METHODinvalid HTTP methodHPE_INVALID_URLinvalid URLHPE_INVALID_HOSTinvalid hostHPE_INVALID_PORTinvalid portHPE_INVALID_PATHinvalid pathHPE_INVALID_QUERY_STRINGinvalid query stringHPE_INVALID_FRAGMENTinvalid fragmentHPE_LF_EXPECTEDLF character expectedHPE_INVALID_HEADER_TOKENinvalid character in headerHPE_INVALID_CONTENT_LENGTHinvalid character in content-length headerHPE_INVALID_CHUNK_SIZEinvalid character in chunk size headerHPE_INVALID_CONSTANTinvalid constant stringHPE_INVALID_INTERNAL_STATEencountered unexpected internal stateHPE_STRICTstrict mode assertion failedHPE_PAUSEDparser is pausedHPE_UNKNOWNan unknown error occurredparsernameloader__loader__origin__file__parent__package__submodule_search_locations__path__Interpreter change detected - this module can only be loaded into one interpreter per process.Module 'parser' has already been imported. Re-initialisation is not supported.builtinscython_runtime__builtins__init http_parser.parser%d.%d%scompiletime version %s of module '%.100s' does not match runtime version %sstringsourcetype.pxdbool.pxdcomplex.pxd_cython_0_29_16Shared Cython type %.200s is not a type objectShared Cython type %.200s has the wrong size, try recompilingcython_function_or_method%.200s() takes no arguments (%zd given)%.200s() takes exactly one argument (%zd given)Bad call flags in __Pyx_CyFunction_Call. METH_OLDARGS is no longer supported!%.200s() takes no keyword argumentsfunc_docfunc_name__self__func_dict__dict__func_globals__globals__func_closure__closure__func_code__code__func_defaults__defaults____kwdefaults____annotations____name__ must be set to a string object__qualname__ must be set to a string objectfunction's dictionary may not be deletedsetting function's dictionary to a non-dict__defaults__ must be set to a tuple object__kwdefaults__ must be set to a dict object__annotations__ must be set to a dict objectname '%U' is not definedhttp_parser.parser.HttpParser Low level HTTP parser. executeget_errnoget_status_codeget_pathget_query_stringget_fragmentget_headersget_wsgi_environrecv_bodyrecv_body_intois_upgradeis_headers_completeis_partial_bodyis_message_beginis_message_completeis_chunkedshould_keep_alivehttp_parser.parser.HttpParser.executeat leastat mostexactly%.200s() takes %.8s %zd positional argument%.1s (%zd given)s%.200s() keywords must be strings%s() got an unexpected keyword argument '%U'%s() got multiple values for keyword argument '%U'can't convert negative value to size_tintan integer is required__int__ returned non-int (type %.200s). The ability to return an instance of a strict subclass of int is deprecated, and may be removed in a future version of Python.__%.4s__ returned non-%.4s (type %.200s)http_parser.parser.HttpParser.get_errnohttp_parser.parser.HttpParser.get_versionhttp_parser.parser.HttpParser.get_method while calling a Python objectNULL result without error in PyObject_Callhttp_parser.parser.HttpParser.get_status_codehttp_parser.parser.HttpParser.get_urlExpected %.16s, got %.200sstrhttp_parser.parser.HttpParser.maybe_parse_urlhttp_parser.parser.HttpParser.get_pathhttp_parser.parser.HttpParser.get_query_stringhttp_parser.parser.HttpParser.get_fragmenthttp_parser.parser.HttpParser.get_headershttp_parser.parser.HttpParser.get_wsgi_environtoo many values to unpack (expected %zd)need more than %zd value%.1s to unpackhttp_parser.parser.HttpParser.recv_bodyhttp_parser.parser.HttpParser.recv_body_into'%.200s' object is unsliceable'%.200s' object does not support slice %.10sassignmenthttp_parser.parser.HttpParser.is_upgradehttp_parser.parser.HttpParser.is_headers_completehttp_parser.parser.HttpParser.is_partial_bodyhttp_parser.parser.HttpParser.is_message_beginhttp_parser.parser.HttpParser.is_message_completehttp_parser.parser.HttpParser.is_chunkedhttp_parser.parser.HttpParser.should_keep_alivehttp_parser.parser.HttpParser.__reduce_cython__calling %R should have returned an instance of BaseException, not %Rraise: exception class must be a subclass of BaseExceptionhttp_parser.parser.HttpParser.__setstate_cython__http_parser.parser.HttpParser.__init__http_parser.parser.on_url_cbhttp_parser.parser.on_body_cb'%.50s' object has no attribute '%U'http_parser.parser.on_header_field_cbhttp_parser.parser.on_header_value_cb'%.200s' object is not subscriptablecannot fit '%.200s' into an index-sized integerhttp_parser.parser.on_headers_complete_cbhttp_parser.parser.on_message_begin_cbhttp_parser.parser.on_message_complete_cbUnable to initialize pickling for %stypeboolcomplex%.200s.%.200s is not a type object%.200s.%.200s size changed, may indicate binary incompatibility. Expected %zd from C header, got %zd from PyObject%s.%s size changed, may indicate binary incompatibility. Expected %zd from C header, got %zd from PyObjectcannot import name %S%s (%s:%d)http_parser/parser.chttp_parser.parser.get_errno_namevalue too large to convert to enum http_errnocan't convert negative value to enum http_errnohttp_parser.parser.get_errno_descriptionmetaclass conflict: the metaclass of a derived class must be a (non-strict) subclass of the metaclasses of all its baseshttp_parser.parser._ParserData.__init__!#$%&'*+-.0123456789abcdefghijklmnopqrstuvwxyz^_`abcdefghijklmnopqrstuvwxyz|~   @?0@http_parser.parserhttp_parser/parser.pyx__reduce____module____doc____name____qualname__CONTENT-LENGTHCONTENT_LENGTHCONTENT-TYPECONTENT_TYPEHTTP_%sHTTP/%sHttpParserIOrderedDictImportErrorMAX_WBITSPATH_INFO_ParserData_ParserData.__init__QUERY_STRINGRAW_URIREQUEST_METHODSCRIPT_NAMESERVER_PROTOCOLTypeErrorValueError-_.appendbbodybytes_to_strchunkedcline_in_tracebackcontent-encodingdatadecompress_decompress_first_trydecompressobjdeflateenvironerrnoerrno out of rangeerrorfragmentget__getstate__gzipheader_onlyheadersheaders_completehttp_parser.util__import__itemsjoinkind_last_field_last_was_valuelengthlower__main__mapmessage_beginmessage_complete__metaclass__objectospartial_bodypath__prepare__query__reduce_ex__replace%s, %s%s %sselfself._parser,self._settings cannot be converted to a Python object for pickling__setstate__split__test__transfer-encodingunquoteupdateupperurlurllib.parseurlparseurlsplitzlib__init__get_versionget_methodget_urlmaybe_parse_url__reduce_cython____setstate_cython__get_errno_nameget_errno_description44X !apLL'L @ q!!?#?JJKLRGRaRSYT,VmVWW5XhXX YhYY!ZWZ\4]7^^^Phhk$l moon~~] pvu\ZC_Bx)}........../ ///!/(///6/A/J/P/Y/`/j/v/|/////// 00/0C0g0{0000011G1]111112$292L2e2x2222222223303E3V3f3|33333454J4b4}4444444I JJ)J 6J CJKJSJ ^J ȆkJ ІwJ ؆J (J 8JJ JJJ JK  K K K(K0K"K8$K)K @6KH@KP`KXqK`vK hKpKxKIKKKKK KNtNN NȇN ЇK ؇LL L LII@LQL PM \LbLgL lL (L0L8LL @LH0NPLXL`LhI I pLLxL LL I MI @N MM#MȈ*MЈ0M؈@MPM `NMXM MMMMMM ЅM M ؅M,*6*@*J*T*^*h*r*|**************+++&+0+:+D+N+X+b+l+v++++++++++++++, ,, ,*,4,>,H,R,\,f,p,z,,,,,,,,,,,,,,---$-.-8-B-L-V-`-j-t-~-------------. ...(.D.N.X. 50sE;<tNNMZ7kkk@xlm(v@vvo0IPqI T8aqqIaqq]8q rIq rIlryrg8rp8rsz8rs8s8s8s8s8s8s8st8st8tt8MuuH:vDf:ww|Fx constructor of HttpParser object. : attr kind: Int, could be 0 to parseonly requests, 1 to parse only responses or 2 if we want to let the parser detect the type. :#:60NPN|p:Nۈ0NQ:K:z0:P:ޗp:T:0:B`: ;,0;`.;?;ЃS;^;}P@N`Nc Execute the parser with the last chunk. We pass the length to let the parser know when EOF has been received. In this case length == 0. :return recved: Int, received length of the data parsed. if recvd != length you should return an error. get error state get HTTP version get HTTP method as string get status code of a response as integer get full url of the request get path of the request (url without query string and fragment get query string of the url get fragment of the url get request/response headers, headers are returned in a OrderedDict that allows you to get value using insensitive keys. get WSGI environ based on the current request return last chunk of the parsed body Receive the last chunk of the parsed body and store the data in a buffer rather than creating a new string. Do we get upgrade header in the request. Useful for websockets return True if all headers have been parsed. return True if a chunk of body have been parsed return True if the parsing start return True if the parsing is done (we get EOF) return True if Transfer-Encoding header value is chunked return True if the connection should be kept alive X0`Ј`!`XCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCRCR"`jGpREppRBRBREpp p p0RDSBpRFpHSBSBSBSBSBRCSBSBRCRCRCRCRCRCSBSBSBSHp0ppxSDp8ppRASASASASASASBRASASASASASASASASASASASASASASBR0 RBSAS>@_PyBaseObject_TypeQq@_PyByteArray_Type@_PyBytes_Type@_PyCFunction_Type@_PyDict_Type@_PyExc_AttributeError@_PyExc_DeprecationWarning@_PyExc_ImportError@_PyExc_IndexError@_PyExc_KeyError@_PyExc_NameError@_PyExc_OverflowError@_PyExc_RuntimeError@_PyExc_StopIteration@_PyExc_SystemError@_PyExc_TypeError@_PyExc_ValueError@_PyFloat_Type@_PyFrame_Type@_PyFunction_Type@_PyList_Type@_PyLong_Type@_PyMethodDescr_Type@_PyMethod_Type@_PyObject_GenericGetAttr@_PyTuple_Type@_PyType_Type@_PyUnicode_Type@_PyWrapperDescr_Type@__PyByteArray_empty_string@__Py_CheckRecursionLimit@__Py_FalseStruct@__Py_NoneStruct@__Py_TrueStruct@___stack_chk_guard@dyld_stub_binderr>@_PyBytes_AsStringAndSizer>@_PyBytes_FromStringr>@_PyBytes_FromStringAndSizer>@_PyCFunction_NewExr >@_PyCode_Newr(>@_PyDict_DelItemr0>@_PyDict_GetItemStringr8>@_PyDict_Newr@>@_PyDict_NextrH>@_PyDict_SetItemrP>@_PyDict_SetItemStringrX>@_PyDict_Sizer`>@_PyErr_Clearrh>@_PyErr_ExceptionMatchesrp>@_PyErr_Formatrx>@_PyErr_GivenExceptionMatchesr>@_PyErr_NormalizeExceptionr>@_PyErr_Occurredr>@_PyErr_PrintExr>@_PyErr_SetObjectr>@_PyErr_SetStringr>@_PyErr_WarnExr>@_PyErr_WarnFormatr>@_PyErr_WriteUnraisabler>@_PyEval_EvalCodeExr>@_PyEval_EvalFrameExr>@_PyException_SetTracebackr>@_PyFloat_FromDoubler>@_PyFrame_Newr>@_PyImport_AddModuler>@_PyImport_GetModuleDictr>@_PyImport_ImportModuler>@_PyImport_ImportModuleLevelObjectr>@_PyInterpreterState_GetIDr>@_PyList_Appendr>@_PyList_Newr>@_PyLong_AsSsize_tr>@_PyLong_AsUnsignedLongr>@_PyLong_FromLongr>@_PyLong_FromSize_tr>@_PyLong_FromSsize_tr>@_PyMem_Mallocr>@_PyMem_Reallocr>@_PyMethod_Newr>@_PyModuleDef_Initr>@_PyModule_GetDictr>@_PyModule_NewObjectr>@_PyNumber_Addr>@_PyNumber_InPlaceAddr>@_PyNumber_Indexr>@_PyNumber_Negativer>@_PyNumber_Remainderr>@_PyOS_snprintfr>@_PyObject_Callr>@_PyObject_CallFinalizerFromDeallocr>@_PyObject_ClearWeakRefsr>@_PyObject_DelItemr>@_PyObject_Freer>@_PyObject_GC_Delr>@_PyObject_GC_Trackr>@_PyObject_GC_UnTrackr>@_PyObject_GetAttrr>@_PyObject_GetAttrStringr>@_PyObject_GetItemr>@_PyObject_GetIterr>@_PyObject_Hashr>@_PyObject_IsTruer>@_PyObject_Notr>@_PyObject_RichComparer>@_PyObject_RichCompareBoolr>@_PyObject_SetAttrr>@_PyObject_SetAttrStringr>@_PyObject_SetItemr>@_PyObject_Sizer>@_PySequence_Containsr>@_PySlice_Newr>@_PyThreadState_Getr>@_PyTraceBack_Herer>@_PyTuple_GetItemr>@_PyTuple_GetSlicer>@_PyTuple_Newr>@_PyTuple_Packr>@_PyType_IsSubtyper>@_PyType_Modifiedr>@_PyType_Readyr>@_PyUnicode_AsUnicoder>@_PyUnicode_Comparer>@_PyUnicode_Decoder>@_PyUnicode_Formatr>@_PyUnicode_FromFormatr>@_PyUnicode_FromStringr>@_PyUnicode_FromStringAndSizer>@_PyUnicode_InternFromStringr>@_PyUnicode_Joinr>@_Py_GetVersionr>@__PyDict_GetItem_KnownHashr>@__PyDict_SetItem_KnownHashr>@__PyObject_GC_Newr>@__PyObject_GetDictPtrr>@__PyThreadState_UncheckedGetr>@__PyType_Lookupr>@__PyUnicode_Readyr>@__Py_CheckRecursiveCallr@___stack_chk_failr@_memcmpr@_strtoul_http_'PyInit_parser__pyx_parser_dshould_keep_alivemeerrno_body_is_finalexecuteinitpaversion2kssage_needs_eofthod_strlllnamedescriptionmmrse_urlusemuvvvmodule_is_main_http_parser__parserwrapperbase_11http_parser_6parser_10HttpParser___init__232= 7( Nc 3AD35_ _.r KxKx6vQZIVc^[vvG_vvvvcj(ti1t50:P0q  ' H3 E; < c 5d) "e; eO jd k~ k k xl m o o Pq9 aqS qm q  r lr yr r rs2sPsnssttt Mu+uMumJvvwwFxR#6)|bۈQKOzޗTFB,:y6}wc/~Ibe"u*BOx8L<on6W@G`G`H JJ)J.6JFCJWKJgSJ{^JkJwJJJJJJ"J:JOJhK{ KKKKK"K$K)K6K@K`K9qKGvK[KyKKKKKKKK KL+L@LQ Lk@LQL\LbLgLlLLLL LL&L=LWLjLzLLLLM MM#M*M 0M@MBMTMcMqMMMMMMMM M  Q! Q4 SF  PsU  `sf  s}  t  t  (t! HtV! htq! v! @v! v! y! y" @{E" |u" " 0" P # pZ# # #  $ 0L$ P$ p$ % 0@% `% % 0% `>& & Ѓ& & P@' ' ' Є( 0'( P0( X@( `N( d]( h~( p( x( ( ( ( ( ( ) ) #) ;) ȅV) Ѕj) ؅z) ) ) ) ) ) * * ?* P* (f* 0|* 8* @* H* P* X* `* h* p+ x+ $+ 1+ L+ h+ + + + + + Ȇ+ І, ؆, 1, D, ^, u, , , , , , (, 0, 8 - @- H:- PW- Xg- `}- h- p- x- - - - . ,. @. O. e. x. ȇ. Ї. ؇. . . . / ./ ?/ O/ _/ u/ (/ 0/ 8/ @/ H/ P/ X0 `&0 h80 pJ0 xb0 r0 0 0 0 0 0 0 0  1 Ȉ1 Ј/1 ؈\1 p1 1 1 1 1 1 1  2 2 (62 0F2 8V2 @f2 Hv2 P2 X2 `2 h2 p2 x2 2 <3 3 3 64 4 4 -5 ~5 ȉ5 Љ%6 ؉n6 6 6 97 v7 7 7 ?8 8 8 ( 9 0U9 89 @9 H-: P{: X: `; hg; p; x; ; "< N< < < = ,= @= T=d=d=f^.p>$p$N.H3>$H3$N.5'>$5$2N2.6?>$6$=N=.[6W>$[6$ N .{6h>${6$7N7.6z>$6$N.6>$6$N.6>$6$N.:>$:$(N(.;>$;$N.';>$';$ N >&@G?&`G?&`H?& Q&?&QdT=d9?dB?f^.4;?$4;$N.E;?$E;$jNj.<?$<$'N'.c?$c$N.5d?$5d$N."e @$"e$cNc.e@$e$N.j0@$j$gNg.kE@$k$3N3.k_@$k$N.kv@$k$N.xl@$xl$QNQ.m@$m$N.o@$o$ANA.o@$o$sNs.PqA$Pq$N.aqA$aq$DND.q4A$q$3N3.qNA$q$5N5. riA$ r$_N_.lrA$lr$ N .yrA$yr$_N_.rA$r$N.rA$r$.N..sA$s$rNr.sB$s$ N .s1B$s$N.sOB$s$N.sjB$s$KNK.tB$t$xNx.tB$t$KNK.tB$t$xNx.MuB$Mu$6N6.u C$u$vNv.u.C$u$QNQ.JvNC$Jv$ZNZ.vdC$v$N.wC$w$INI.wC$w$VNV.FxC$Fx$z Nz .3D$$cNc.#bD$#$N.6D$6$^N^.D$$N.| E$|$N.CE$$[N[.ۈE$ۈ$vNv.QE$Q$N.KE$K$/N/.z0F$z$2N2.pF$$2N2.ޗF$ޗ$vNv.TF$T$#N#.'G$$MNM.B`G$B$ N .G$$_N_.,G$,$vNv.H$$vNv.ZH$$vNv.H$$vNv.H$$yNy.}I$}$cNc.XI$$N.cI$c$N.I$$N.I$$N.~J$~$N.b*J$b$jNj.FJ$$&N&.`J$$N.{J$$XNX."J$"$N.J$$N.J$$N.uJ$u$ZNZ. K$$N.#K$$N.0K$$N.YK$$RNR.K$$NNN.8K$8$ N .LK$L$ N .L$$N.nPL$n$N.L$$$N$.L$$tNt.L$$ N .L$$iNi.L$$N.M$$N.8M$$N.oM$$ N M& JM&JM&)JM&6JN&CJN&KJ(N&SJf& 8Nf& @^f& Hnf& P~f& Xf& `f& hf& pf& xf& f& 4g& g& g& .h& h& h& %i& vi& ȉi& Љj& ؉fj& j& j& 1k& nk& k& k& 7l& xl& l& (m& 0Mm& 8m& @m& H%n& Psn& Xn& `o& h_o& po& xo& o& p& Fp& wp& p& q& $q& 8q& d4; ; z;666[6p{66:1';F5^q 0<IYo|#4BTk~1FYj|'Icr~*8GYk2DSdw!7Qc{  ! / A R ` m         . > S b }        3 K \ l |     wxy{}~uvz|wxy{}~ _PyInit_parser___pyx_module_is_main_http_parser__parser___pyx_wrapperbase_11http_parser_6parser_10HttpParser___init___http_body_is_final_http_errno_description_http_errno_name_http_message_needs_eof_http_method_str_http_parser_execute_http_parser_init_http_parser_parse_url_http_parser_pause_http_parser_version_http_should_keep_alive_PyBaseObject_Type_PyByteArray_Type_PyBytes_AsStringAndSize_PyBytes_FromString_PyBytes_FromStringAndSize_PyBytes_Type_PyCFunction_NewEx_PyCFunction_Type_PyCode_New_PyDict_DelItem_PyDict_GetItemString_PyDict_New_PyDict_Next_PyDict_SetItem_PyDict_SetItemString_PyDict_Size_PyDict_Type_PyErr_Clear_PyErr_ExceptionMatches_PyErr_Format_PyErr_GivenExceptionMatches_PyErr_NormalizeException_PyErr_Occurred_PyErr_PrintEx_PyErr_SetObject_PyErr_SetString_PyErr_WarnEx_PyErr_WarnFormat_PyErr_WriteUnraisable_PyEval_EvalCodeEx_PyEval_EvalFrameEx_PyExc_AttributeError_PyExc_DeprecationWarning_PyExc_ImportError_PyExc_IndexError_PyExc_KeyError_PyExc_NameError_PyExc_OverflowError_PyExc_RuntimeError_PyExc_StopIteration_PyExc_SystemError_PyExc_TypeError_PyExc_ValueError_PyException_SetTraceback_PyFloat_FromDouble_PyFloat_Type_PyFrame_New_PyFrame_Type_PyFunction_Type_PyImport_AddModule_PyImport_GetModuleDict_PyImport_ImportModule_PyImport_ImportModuleLevelObject_PyInterpreterState_GetID_PyList_Append_PyList_New_PyList_Type_PyLong_AsSsize_t_PyLong_AsUnsignedLong_PyLong_FromLong_PyLong_FromSize_t_PyLong_FromSsize_t_PyLong_Type_PyMem_Malloc_PyMem_Realloc_PyMethodDescr_Type_PyMethod_New_PyMethod_Type_PyModuleDef_Init_PyModule_GetDict_PyModule_NewObject_PyNumber_Add_PyNumber_InPlaceAdd_PyNumber_Index_PyNumber_Negative_PyNumber_Remainder_PyOS_snprintf_PyObject_Call_PyObject_CallFinalizerFromDealloc_PyObject_ClearWeakRefs_PyObject_DelItem_PyObject_Free_PyObject_GC_Del_PyObject_GC_Track_PyObject_GC_UnTrack_PyObject_GenericGetAttr_PyObject_GetAttr_PyObject_GetAttrString_PyObject_GetItem_PyObject_GetIter_PyObject_Hash_PyObject_IsTrue_PyObject_Not_PyObject_RichCompare_PyObject_RichCompareBool_PyObject_SetAttr_PyObject_SetAttrString_PyObject_SetItem_PyObject_Size_PySequence_Contains_PySlice_New_PyThreadState_Get_PyTraceBack_Here_PyTuple_GetItem_PyTuple_GetSlice_PyTuple_New_PyTuple_Pack_PyTuple_Type_PyType_IsSubtype_PyType_Modified_PyType_Ready_PyType_Type_PyUnicode_AsUnicode_PyUnicode_Compare_PyUnicode_Decode_PyUnicode_Format_PyUnicode_FromFormat_PyUnicode_FromString_PyUnicode_FromStringAndSize_PyUnicode_InternFromString_PyUnicode_Join_PyUnicode_Type_PyWrapperDescr_Type_Py_GetVersion__PyByteArray_empty_string__PyDict_GetItem_KnownHash__PyDict_SetItem_KnownHash__PyObject_GC_New__PyObject_GetDictPtr__PyThreadState_UncheckedGet__PyType_Lookup__PyUnicode_Ready__Py_CheckRecursionLimit__Py_CheckRecursiveCall__Py_FalseStruct__Py_NoneStruct__Py_TrueStruct___stack_chk_fail___stack_chk_guard_memcmp_strtouldyld_stub_binder_parse_url_char___pyx_pymod_create___pyx_pymod_exec_parser___Pyx_copy_spec_to_module___Pyx_Import___Pyx_ImportFrom___Pyx_AddTraceback___Pyx__GetException___Pyx_CyFunction_dealloc___Pyx_CyFunction_repr___Pyx_CyFunction_CallAsMethod___Pyx_CyFunction_traverse___Pyx_CyFunction_clear___Pyx_CyFunction_descr_get___Pyx_CyFunction_CallMethod___Pyx_CyFunction_reduce___Pyx_CyFunction_get_doc___Pyx_CyFunction_set_doc___Pyx_CyFunction_get_name___Pyx_CyFunction_set_name___Pyx_CyFunction_get_qualname___Pyx_CyFunction_set_qualname___Pyx_CyFunction_get_self___Pyx_CyFunction_get_dict___Pyx_CyFunction_set_dict___Pyx_CyFunction_get_globals___Pyx_CyFunction_get_closure___Pyx_CyFunction_get_code___Pyx_CyFunction_get_defaults___Pyx_CyFunction_set_defaults___Pyx_CyFunction_get_kwdefaults___Pyx_CyFunction_set_kwdefaults___Pyx_CyFunction_get_annotations___Pyx_CyFunction_set_annotations___Pyx_CyFunction_init_defaults___Pyx_GetBuiltinName___pyx_tp_dealloc_11http_parser_6parser_HttpParser___pyx_tp_traverse_11http_parser_6parser_HttpParser___pyx_tp_clear_11http_parser_6parser_HttpParser___pyx_pw_11http_parser_6parser_10HttpParser_1__init_____pyx_tp_new_11http_parser_6parser_HttpParser___pyx_pw_11http_parser_6parser_10HttpParser_3execute___pyx_pw_11http_parser_6parser_10HttpParser_5get_errno___pyx_pw_11http_parser_6parser_10HttpParser_7get_version___pyx_pw_11http_parser_6parser_10HttpParser_9get_method___pyx_pw_11http_parser_6parser_10HttpParser_11get_status_code___pyx_pw_11http_parser_6parser_10HttpParser_13get_url___pyx_pw_11http_parser_6parser_10HttpParser_15maybe_parse_url___pyx_pw_11http_parser_6parser_10HttpParser_17get_path___pyx_pw_11http_parser_6parser_10HttpParser_19get_query_string___pyx_pw_11http_parser_6parser_10HttpParser_21get_fragment___pyx_pw_11http_parser_6parser_10HttpParser_23get_headers___pyx_pw_11http_parser_6parser_10HttpParser_25get_wsgi_environ___pyx_pw_11http_parser_6parser_10HttpParser_27recv_body___pyx_pw_11http_parser_6parser_10HttpParser_29recv_body_into___pyx_pw_11http_parser_6parser_10HttpParser_31is_upgrade___pyx_pw_11http_parser_6parser_10HttpParser_33is_headers_complete___pyx_pw_11http_parser_6parser_10HttpParser_35is_partial_body___pyx_pw_11http_parser_6parser_10HttpParser_37is_message_begin___pyx_pw_11http_parser_6parser_10HttpParser_39is_message_complete___pyx_pw_11http_parser_6parser_10HttpParser_41is_chunked___pyx_pw_11http_parser_6parser_10HttpParser_43should_keep_alive___pyx_pw_11http_parser_6parser_10HttpParser_45__reduce_cython_____pyx_pw_11http_parser_6parser_10HttpParser_47__setstate_cython_____Pyx_ParseOptionalKeywords___Pyx_PyInt_As_size_t___Pyx_PyNumber_IntOrLong___Pyx__GetModuleGlobalName___Pyx_PyObject_Call2Args___Pyx_PyObject_CallOneArg___Pyx_PyFunction_FastCallDict___Pyx_PyObject_Call___Pyx_PyFunction_FastCallNoKw___Pyx_PyObject_CallMethO___Pyx_PyErr_GivenExceptionMatches___Pyx_PyUnicode_Equals___Pyx_Raise___pyx_f_11http_parser_6parser_on_url_cb___pyx_f_11http_parser_6parser_on_body_cb___pyx_f_11http_parser_6parser_on_header_field_cb___pyx_f_11http_parser_6parser_on_header_value_cb___pyx_f_11http_parser_6parser_on_headers_complete_cb___pyx_f_11http_parser_6parser_on_message_begin_cb___pyx_f_11http_parser_6parser_on_message_complete_cb___Pyx_WriteUnraisable___Pyx_setup_reduce_is_named___Pyx_ImportType___pyx_bisect_code_objects___pyx_pw_11http_parser_6parser_1get_errno_name___Pyx_PyInt_As_enum__http_errno___pyx_pw_11http_parser_6parser_3get_errno_description___pyx_pw_11http_parser_6parser_11_ParserData_1__init___normal_url_char_tokens_unhex___pyx_k_CONTENT_LENGTH___pyx_k_CONTENT_LENGTH_2___pyx_k_CONTENT_TYPE___pyx_k_CONTENT_TYPE_2___pyx_k_HTTP__s___pyx_k_HTTP_s___pyx_k_HttpParser___pyx_k_IOrderedDict___pyx_k_ImportError___pyx_k_MAX_WBITS___pyx_k_PATH_INFO___pyx_k_ParserData___pyx_k_ParserData___init___pyx_k_QUERY_STRING___pyx_k_RAW_URI___pyx_k_REQUEST_METHOD___pyx_k_SCRIPT_NAME___pyx_k_SERVER_PROTOCOL___pyx_k_TypeError___pyx_k_ValueError___pyx_k__4___pyx_k__5___pyx_k__7___pyx_k_append___pyx_k_b___pyx_k_body___pyx_k_bytes_to_str___pyx_k_chunked___pyx_k_cline_in_traceback___pyx_k_content_encoding___pyx_k_data___pyx_k_decompress___pyx_k_decompress_first_try___pyx_k_decompressobj___pyx_k_deflate___pyx_k_environ___pyx_k_errno___pyx_k_errno_out_of_range___pyx_k_error___pyx_k_fragment___pyx_k_get___pyx_k_getstate___pyx_k_gzip___pyx_k_header_only___pyx_k_headers___pyx_k_headers_complete___pyx_k_http_parser_util___pyx_k_import___pyx_k_items___pyx_k_join___pyx_k_kind___pyx_k_last_field___pyx_k_last_was_value___pyx_k_length___pyx_k_lower___pyx_k_main___pyx_k_map___pyx_k_message_begin___pyx_k_message_complete___pyx_k_metaclass___pyx_k_object___pyx_k_os___pyx_k_partial_body___pyx_k_path___pyx_k_prepare___pyx_k_query___pyx_k_reduce_ex___pyx_k_replace___pyx_k_s_s___pyx_k_s_s_2___pyx_k_self___pyx_k_self__parser_self__settings_cann___pyx_k_setstate___pyx_k_split___pyx_k_test___pyx_k_transfer_encoding___pyx_k_unquote___pyx_k_update___pyx_k_upper___pyx_k_url___pyx_k_urllib_parse___pyx_k_urlparse___pyx_k_urlsplit___pyx_k_zlib_method_strings_http_strerror_tab___pyx_string_tab__dyld_private___pyx_moduledef___pyx_moduledef_slots___Pyx_check_single_interpreter.main_interpreter_id___pyx_mdef_11http_parser_6parser_1get_errno_name___pyx_mdef_11http_parser_6parser_3get_errno_description___pyx_mdef_11http_parser_6parser_11_ParserData_1__init_____pyx_CyFunctionType_type___pyx_CyFunction_methods___pyx_CyFunction_members___pyx_CyFunction_getsets___pyx_umethod_PyDict_Type_update___pyx_type_11http_parser_6parser_HttpParser___pyx_doc_11http_parser_6parser_10HttpParser___init_____pyx_methods_11http_parser_6parser_HttpParser___pyx_doc_11http_parser_6parser_10HttpParser_2execute___pyx_doc_11http_parser_6parser_10HttpParser_4get_errno___pyx_doc_11http_parser_6parser_10HttpParser_6get_version___pyx_doc_11http_parser_6parser_10HttpParser_8get_method___pyx_doc_11http_parser_6parser_10HttpParser_10get_status_code___pyx_doc_11http_parser_6parser_10HttpParser_12get_url___pyx_doc_11http_parser_6parser_10HttpParser_16get_path___pyx_doc_11http_parser_6parser_10HttpParser_18get_query_string___pyx_doc_11http_parser_6parser_10HttpParser_20get_fragment___pyx_doc_11http_parser_6parser_10HttpParser_22get_headers___pyx_doc_11http_parser_6parser_10HttpParser_24get_wsgi_environ___pyx_doc_11http_parser_6parser_10HttpParser_26recv_body___pyx_doc_11http_parser_6parser_10HttpParser_28recv_body_into___pyx_doc_11http_parser_6parser_10HttpParser_30is_upgrade___pyx_doc_11http_parser_6parser_10HttpParser_32is_headers_complete___pyx_doc_11http_parser_6parser_10HttpParser_34is_partial_body___pyx_doc_11http_parser_6parser_10HttpParser_36is_message_begin___pyx_doc_11http_parser_6parser_10HttpParser_38is_message_complete___pyx_doc_11http_parser_6parser_10HttpParser_40is_chunked___pyx_doc_11http_parser_6parser_10HttpParser_42should_keep_alive___pyx_pw_11http_parser_6parser_10HttpParser_3execute.__pyx_pyargnames___pyx_pw_11http_parser_6parser_10HttpParser_1__init__.__pyx_pyargnames___pyx_pw_11http_parser_6parser_11_ParserData_1__init__.__pyx_pyargnames___pyx_methods___pyx_m___pyx_filename___pyx_lineno___pyx_clineno___pyx_pyframe_localsplus_offset___pyx_empty_tuple___pyx_empty_bytes___pyx_empty_unicode___pyx_d___pyx_b___pyx_cython_runtime___pyx_n_s_name___pyx_n_s_main___pyx_n_s_os___pyx_n_s_urlsplit___pyx_n_s_urllib_parse___pyx_builtin_ImportError___pyx_n_s_urlparse___pyx_n_s_zlib___pyx_n_s_b___pyx_n_s_bytes_to_str___pyx_n_s_IOrderedDict___pyx_n_s_unquote___pyx_n_s_http_parser_util___pyx_n_s_http_parser_parser___pyx_n_s_get_errno_name___pyx_n_s_get_errno_description___pyx_tuple__15___pyx_n_s_ParserData___pyx_CyFunctionType___pyx_n_s_ParserData___init___pyx_codeobj__17___pyx_tuple__18___pyx_n_s_init___pyx_n_s_test___pyx_int_0___pyx_int_1___pyx_int_2___pyx_int_16___pyx_n_s_update___pyx_kp_s____pyx_kp_s_CONTENT_LENGTH___pyx_n_s_CONTENT_LENGTH_2___pyx_kp_s_CONTENT_TYPE___pyx_n_s_CONTENT_TYPE_2___pyx_kp_s_HTTP__s___pyx_kp_s_HTTP_s___pyx_n_s_HttpParser___pyx_n_s_ImportError___pyx_n_s_MAX_WBITS___pyx_n_s_PATH_INFO___pyx_n_s_QUERY_STRING___pyx_n_s_RAW_URI___pyx_n_s_REQUEST_METHOD___pyx_n_s_SCRIPT_NAME___pyx_n_s_SERVER_PROTOCOL___pyx_n_s_TypeError___pyx_n_s_ValueError___pyx_kp_s__4___pyx_n_s__5___pyx_kp_s__7___pyx_n_s_append___pyx_n_s_body___pyx_n_s_chunked___pyx_n_s_cline_in_traceback___pyx_kp_s_content_encoding___pyx_n_s_data___pyx_n_s_decompress___pyx_n_s_decompress_first_try___pyx_n_s_decompressobj___pyx_n_s_deflate___pyx_n_s_doc___pyx_n_s_environ___pyx_n_s_errno___pyx_kp_s_errno_out_of_range___pyx_n_s_error___pyx_n_s_fragment___pyx_n_s_get___pyx_n_s_get_method___pyx_n_s_get_url___pyx_n_s_get_version___pyx_n_s_getstate___pyx_n_s_gzip___pyx_n_s_header_only___pyx_n_s_headers___pyx_n_s_headers_complete___pyx_kp_s_http_parser_parser_pyx___pyx_n_s_import___pyx_n_s_items___pyx_n_s_join___pyx_n_s_kind___pyx_n_s_last_field___pyx_n_s_last_was_value___pyx_n_s_length___pyx_n_s_lower___pyx_n_s_map___pyx_n_s_maybe_parse_url___pyx_n_s_message_begin___pyx_n_s_message_complete___pyx_n_s_metaclass___pyx_n_s_module___pyx_n_s_object___pyx_n_s_partial_body___pyx_n_s_path___pyx_n_s_prepare___pyx_n_s_qualname___pyx_n_s_query___pyx_n_s_reduce___pyx_n_s_reduce_cython___pyx_n_s_reduce_ex___pyx_n_s_replace___pyx_kp_s_s_s___pyx_kp_s_s_s_2___pyx_n_s_self___pyx_kp_s_self__parser_self__settings_cann___pyx_n_s_setstate___pyx_n_s_setstate_cython___pyx_n_s_split___pyx_kp_s_transfer_encoding___pyx_n_s_upper___pyx_n_s_url___pyx_builtin_object___pyx_builtin_ValueError___pyx_builtin_map___pyx_builtin_TypeError___pyx_tuple__2___pyx_tuple__3___pyx_tuple__6___pyx_tuple__8___pyx_tuple__9___pyx_tuple__10___pyx_tuple__11___pyx_codeobj__12___pyx_tuple__13___pyx_codeobj__14___pyx_tuple__16___pyx_pf_11http_parser_6parser_10HttpParser_8get_method.__pyx_dict_version___pyx_pf_11http_parser_6parser_10HttpParser_8get_method.__pyx_dict_cached_value___pyx_pf_11http_parser_6parser_10HttpParser_14maybe_parse_url.__pyx_dict_version___pyx_pf_11http_parser_6parser_10HttpParser_14maybe_parse_url.__pyx_dict_cached_value___pyx_pf_11http_parser_6parser_10HttpParser_24get_wsgi_environ.__pyx_dict_version___pyx_pf_11http_parser_6parser_10HttpParser_24get_wsgi_environ.__pyx_dict_cached_value___pyx_pf_11http_parser_6parser_10HttpParser_26recv_body.__pyx_dict_version___pyx_pf_11http_parser_6parser_10HttpParser_26recv_body.__pyx_dict_cached_value___pyx_pf_11http_parser_6parser_10HttpParser_28recv_body_into.__pyx_dict_version___pyx_pf_11http_parser_6parser_10HttpParser_28recv_body_into.__pyx_dict_cached_value___pyx_pf_11http_parser_6parser_10HttpParser___init__.__pyx_dict_version___pyx_pf_11http_parser_6parser_10HttpParser___init__.__pyx_dict_cached_value___pyx_f_11http_parser_6parser_on_url_cb.__pyx_dict_version___pyx_f_11http_parser_6parser_on_url_cb.__pyx_dict_cached_value___pyx_f_11http_parser_6parser_on_body_cb.__pyx_dict_version___pyx_f_11http_parser_6parser_on_body_cb.__pyx_dict_cached_value___pyx_f_11http_parser_6parser_on_body_cb.__pyx_dict_version.144___pyx_f_11http_parser_6parser_on_body_cb.__pyx_dict_cached_value.145___pyx_f_11http_parser_6parser_on_body_cb.__pyx_dict_version.146___pyx_f_11http_parser_6parser_on_body_cb.__pyx_dict_cached_value.147___pyx_f_11http_parser_6parser_on_header_field_cb.__pyx_dict_version___pyx_f_11http_parser_6parser_on_header_field_cb.__pyx_dict_cached_value___pyx_f_11http_parser_6parser_on_header_value_cb.__pyx_dict_version___pyx_f_11http_parser_6parser_on_header_value_cb.__pyx_dict_cached_value___pyx_f_11http_parser_6parser_on_headers_complete_cb.__pyx_dict_version___pyx_f_11http_parser_6parser_on_headers_complete_cb.__pyx_dict_cached_value___pyx_f_11http_parser_6parser_on_headers_complete_cb.__pyx_dict_version.153___pyx_f_11http_parser_6parser_on_headers_complete_cb.__pyx_dict_cached_value.154___pyx_f_11http_parser_6parser_on_headers_complete_cb.__pyx_dict_version.155___pyx_f_11http_parser_6parser_on_headers_complete_cb.__pyx_dict_cached_value.156___pyx_ptype_7cpython_4type_type___pyx_ptype_7cpython_4bool_bool___pyx_ptype_7cpython_7complex_complex___Pyx_CLineForTraceback.__pyx_dict_version___Pyx_CLineForTraceback.__pyx_dict_cached_value___pyx_pf_11http_parser_6parser_11_ParserData___init__.__pyx_dict_version___pyx_pf_11http_parser_6parser_11_ParserData___init__.__pyx_dict_cached_value___pyx_code_cache.0___pyx_code_cache.1___pyx_code_cache.2/Users/benoitc/PycharmProjects/http-parser/http_parser/http_parser.c/Users/benoitc/PycharmProjects/http-parser/build/temp.macosx-10.15-x86_64-3.7/http_parser/http_parser.o_http_parser_execute_parse_url_char_http_should_keep_alive_http_message_needs_eof_http_method_str_http_parser_init_http_errno_name_http_errno_description_http_parser_parse_url_http_parser_pause_http_body_is_final_http_parser_version_normal_url_char_tokens_unhex_method_strings_http_strerror_tabparser.c/Users/benoitc/PycharmProjects/http-parser/build/temp.macosx-10.15-x86_64-3.7/http_parser/parser.o_PyInit_parser___pyx_pymod_create___pyx_pymod_exec_parser___Pyx_copy_spec_to_module___Pyx_Import___Pyx_ImportFrom___Pyx_AddTraceback___Pyx__GetException___Pyx_CyFunction_dealloc___Pyx_CyFunction_repr___Pyx_CyFunction_CallAsMethod___Pyx_CyFunction_traverse___Pyx_CyFunction_clear___Pyx_CyFunction_descr_get___Pyx_CyFunction_CallMethod___Pyx_CyFunction_reduce___Pyx_CyFunction_get_doc___Pyx_CyFunction_set_doc___Pyx_CyFunction_get_name___Pyx_CyFunction_set_name___Pyx_CyFunction_get_qualname___Pyx_CyFunction_set_qualname___Pyx_CyFunction_get_self___Pyx_CyFunction_get_dict___Pyx_CyFunction_set_dict___Pyx_CyFunction_get_globals___Pyx_CyFunction_get_closure___Pyx_CyFunction_get_code___Pyx_CyFunction_get_defaults___Pyx_CyFunction_set_defaults___Pyx_CyFunction_get_kwdefaults___Pyx_CyFunction_set_kwdefaults___Pyx_CyFunction_get_annotations___Pyx_CyFunction_set_annotations___Pyx_CyFunction_init_defaults___Pyx_GetBuiltinName___pyx_tp_dealloc_11http_parser_6parser_HttpParser___pyx_tp_traverse_11http_parser_6parser_HttpParser___pyx_tp_clear_11http_parser_6parser_HttpParser___pyx_pw_11http_parser_6parser_10HttpParser_1__init_____pyx_tp_new_11http_parser_6parser_HttpParser___pyx_pw_11http_parser_6parser_10HttpParser_3execute___pyx_pw_11http_parser_6parser_10HttpParser_5get_errno___pyx_pw_11http_parser_6parser_10HttpParser_7get_version___pyx_pw_11http_parser_6parser_10HttpParser_9get_method___pyx_pw_11http_parser_6parser_10HttpParser_11get_status_code___pyx_pw_11http_parser_6parser_10HttpParser_13get_url___pyx_pw_11http_parser_6parser_10HttpParser_15maybe_parse_url___pyx_pw_11http_parser_6parser_10HttpParser_17get_path___pyx_pw_11http_parser_6parser_10HttpParser_19get_query_string___pyx_pw_11http_parser_6parser_10HttpParser_21get_fragment___pyx_pw_11http_parser_6parser_10HttpParser_23get_headers___pyx_pw_11http_parser_6parser_10HttpParser_25get_wsgi_environ___pyx_pw_11http_parser_6parser_10HttpParser_27recv_body___pyx_pw_11http_parser_6parser_10HttpParser_29recv_body_into___pyx_pw_11http_parser_6parser_10HttpParser_31is_upgrade___pyx_pw_11http_parser_6parser_10HttpParser_33is_headers_complete___pyx_pw_11http_parser_6parser_10HttpParser_35is_partial_body___pyx_pw_11http_parser_6parser_10HttpParser_37is_message_begin___pyx_pw_11http_parser_6parser_10HttpParser_39is_message_complete___pyx_pw_11http_parser_6parser_10HttpParser_41is_chunked___pyx_pw_11http_parser_6parser_10HttpParser_43should_keep_alive___pyx_pw_11http_parser_6parser_10HttpParser_45__reduce_cython_____pyx_pw_11http_parser_6parser_10HttpParser_47__setstate_cython_____Pyx_ParseOptionalKeywords___Pyx_PyInt_As_size_t___Pyx_PyNumber_IntOrLong___Pyx__GetModuleGlobalName___Pyx_PyObject_Call2Args___Pyx_PyObject_CallOneArg___Pyx_PyFunction_FastCallDict___Pyx_PyObject_Call___Pyx_PyFunction_FastCallNoKw___Pyx_PyObject_CallMethO___Pyx_PyErr_GivenExceptionMatches___Pyx_PyUnicode_Equals___Pyx_Raise___pyx_f_11http_parser_6parser_on_url_cb___pyx_f_11http_parser_6parser_on_body_cb___pyx_f_11http_parser_6parser_on_header_field_cb___pyx_f_11http_parser_6parser_on_header_value_cb___pyx_f_11http_parser_6parser_on_headers_complete_cb___pyx_f_11http_parser_6parser_on_message_begin_cb___pyx_f_11http_parser_6parser_on_message_complete_cb___Pyx_WriteUnraisable___Pyx_setup_reduce_is_named___Pyx_ImportType___pyx_bisect_code_objects___pyx_pw_11http_parser_6parser_1get_errno_name___Pyx_PyInt_As_enum__http_errno___pyx_pw_11http_parser_6parser_3get_errno_description___pyx_pw_11http_parser_6parser_11_ParserData_1__init_____pyx_k_CONTENT_LENGTH___pyx_k_CONTENT_LENGTH_2___pyx_k_CONTENT_TYPE___pyx_k_CONTENT_TYPE_2___pyx_k_HTTP__s___pyx_k_HTTP_s___pyx_k_HttpParser___pyx_k_IOrderedDict___pyx_k_ImportError___pyx_k_MAX_WBITS___pyx_k_PATH_INFO___pyx_k_ParserData___pyx_k_ParserData___init___pyx_k_QUERY_STRING___pyx_k_RAW_URI___pyx_k_REQUEST_METHOD___pyx_k_SCRIPT_NAME___pyx_k_SERVER_PROTOCOL___pyx_k_TypeError___pyx_k_ValueError___pyx_k__4___pyx_k__5___pyx_k__7___pyx_k_append___pyx_k_b___pyx_k_body___pyx_k_bytes_to_str___pyx_k_chunked___pyx_k_cline_in_traceback___pyx_k_content_encoding___pyx_k_data___pyx_k_decompress___pyx_k_decompress_first_try___pyx_k_decompressobj___pyx_k_deflate___pyx_k_environ___pyx_k_errno___pyx_k_errno_out_of_range___pyx_k_error___pyx_k_fragment___pyx_k_get___pyx_k_getstate___pyx_k_gzip___pyx_k_header_only___pyx_k_headers___pyx_k_headers_complete___pyx_k_http_parser_util___pyx_k_import___pyx_k_items___pyx_k_join___pyx_k_kind___pyx_k_last_field___pyx_k_last_was_value___pyx_k_length___pyx_k_lower___pyx_k_main___pyx_k_map___pyx_k_message_begin___pyx_k_message_complete___pyx_k_metaclass___pyx_k_object___pyx_k_os___pyx_k_partial_body___pyx_k_path___pyx_k_prepare___pyx_k_query___pyx_k_reduce_ex___pyx_k_replace___pyx_k_s_s___pyx_k_s_s_2___pyx_k_self___pyx_k_self__parser_self__settings_cann___pyx_k_setstate___pyx_k_split___pyx_k_test___pyx_k_transfer_encoding___pyx_k_unquote___pyx_k_update___pyx_k_upper___pyx_k_url___pyx_k_urllib_parse___pyx_k_urlparse___pyx_k_urlsplit___pyx_k_zlib___pyx_string_tab___pyx_moduledef___pyx_moduledef_slots___Pyx_check_single_interpreter.main_interpreter_id___pyx_mdef_11http_parser_6parser_1get_errno_name___pyx_mdef_11http_parser_6parser_3get_errno_description___pyx_mdef_11http_parser_6parser_11_ParserData_1__init_____pyx_CyFunctionType_type___pyx_CyFunction_methods___pyx_CyFunction_members___pyx_CyFunction_getsets___pyx_umethod_PyDict_Type_update___pyx_type_11http_parser_6parser_HttpParser___pyx_doc_11http_parser_6parser_10HttpParser___init_____pyx_methods_11http_parser_6parser_HttpParser___pyx_doc_11http_parser_6parser_10HttpParser_2execute___pyx_doc_11http_parser_6parser_10HttpParser_4get_errno___pyx_doc_11http_parser_6parser_10HttpParser_6get_version___pyx_doc_11http_parser_6parser_10HttpParser_8get_method___pyx_doc_11http_parser_6parser_10HttpParser_10get_status_code___pyx_doc_11http_parser_6parser_10HttpParser_12get_url___pyx_doc_11http_parser_6parser_10HttpParser_16get_path___pyx_doc_11http_parser_6parser_10HttpParser_18get_query_string___pyx_doc_11http_parser_6parser_10HttpParser_20get_fragment___pyx_doc_11http_parser_6parser_10HttpParser_22get_headers___pyx_doc_11http_parser_6parser_10HttpParser_24get_wsgi_environ___pyx_doc_11http_parser_6parser_10HttpParser_26recv_body___pyx_doc_11http_parser_6parser_10HttpParser_28recv_body_into___pyx_doc_11http_parser_6parser_10HttpParser_30is_upgrade___pyx_doc_11http_parser_6parser_10HttpParser_32is_headers_complete___pyx_doc_11http_parser_6parser_10HttpParser_34is_partial_body___pyx_doc_11http_parser_6parser_10HttpParser_36is_message_begin___pyx_doc_11http_parser_6parser_10HttpParser_38is_message_complete___pyx_doc_11http_parser_6parser_10HttpParser_40is_chunked___pyx_doc_11http_parser_6parser_10HttpParser_42should_keep_alive___pyx_pw_11http_parser_6parser_10HttpParser_3execute.__pyx_pyargnames___pyx_pw_11http_parser_6parser_10HttpParser_1__init__.__pyx_pyargnames___pyx_pw_11http_parser_6parser_11_ParserData_1__init__.__pyx_pyargnames___pyx_module_is_main_http_parser__parser___pyx_wrapperbase_11http_parser_6parser_10HttpParser___init_____pyx_methods___pyx_m___pyx_filename___pyx_lineno___pyx_clineno___pyx_pyframe_localsplus_offset___pyx_empty_tuple___pyx_empty_bytes___pyx_empty_unicode___pyx_d___pyx_b___pyx_cython_runtime___pyx_n_s_name___pyx_n_s_main___pyx_n_s_os___pyx_n_s_urlsplit___pyx_n_s_urllib_parse___pyx_builtin_ImportError___pyx_n_s_urlparse___pyx_n_s_zlib___pyx_n_s_b___pyx_n_s_bytes_to_str___pyx_n_s_IOrderedDict___pyx_n_s_unquote___pyx_n_s_http_parser_util___pyx_n_s_http_parser_parser___pyx_n_s_get_errno_name___pyx_n_s_get_errno_description___pyx_tuple__15___pyx_n_s_ParserData___pyx_CyFunctionType___pyx_n_s_ParserData___init___pyx_codeobj__17___pyx_tuple__18___pyx_n_s_init___pyx_n_s_test___pyx_int_0___pyx_int_1___pyx_int_2___pyx_int_16___pyx_n_s_update___pyx_kp_s____pyx_kp_s_CONTENT_LENGTH___pyx_n_s_CONTENT_LENGTH_2___pyx_kp_s_CONTENT_TYPE___pyx_n_s_CONTENT_TYPE_2___pyx_kp_s_HTTP__s___pyx_kp_s_HTTP_s___pyx_n_s_HttpParser___pyx_n_s_ImportError___pyx_n_s_MAX_WBITS___pyx_n_s_PATH_INFO___pyx_n_s_QUERY_STRING___pyx_n_s_RAW_URI___pyx_n_s_REQUEST_METHOD___pyx_n_s_SCRIPT_NAME___pyx_n_s_SERVER_PROTOCOL___pyx_n_s_TypeError___pyx_n_s_ValueError___pyx_kp_s__4___pyx_n_s__5___pyx_kp_s__7___pyx_n_s_append___pyx_n_s_body___pyx_n_s_chunked___pyx_n_s_cline_in_traceback___pyx_kp_s_content_encoding___pyx_n_s_data___pyx_n_s_decompress___pyx_n_s_decompress_first_try___pyx_n_s_decompressobj___pyx_n_s_deflate___pyx_n_s_doc___pyx_n_s_environ___pyx_n_s_errno___pyx_kp_s_errno_out_of_range___pyx_n_s_error___pyx_n_s_fragment___pyx_n_s_get___pyx_n_s_get_method___pyx_n_s_get_url___pyx_n_s_get_version___pyx_n_s_getstate___pyx_n_s_gzip___pyx_n_s_header_only___pyx_n_s_headers___pyx_n_s_headers_complete___pyx_kp_s_http_parser_parser_pyx___pyx_n_s_import___pyx_n_s_items___pyx_n_s_join___pyx_n_s_kind___pyx_n_s_last_field___pyx_n_s_last_was_value___pyx_n_s_length___pyx_n_s_lower___pyx_n_s_map___pyx_n_s_maybe_parse_url___pyx_n_s_message_begin___pyx_n_s_message_complete___pyx_n_s_metaclass___pyx_n_s_module___pyx_n_s_object___pyx_n_s_partial_body___pyx_n_s_path___pyx_n_s_prepare___pyx_n_s_qualname___pyx_n_s_query___pyx_n_s_reduce___pyx_n_s_reduce_cython___pyx_n_s_reduce_ex___pyx_n_s_replace___pyx_kp_s_s_s___pyx_kp_s_s_s_2___pyx_n_s_self___pyx_kp_s_self__parser_self__settings_cann___pyx_n_s_setstate___pyx_n_s_setstate_cython___pyx_n_s_split___pyx_kp_s_transfer_encoding___pyx_n_s_upper___pyx_n_s_url___pyx_builtin_object___pyx_builtin_ValueError___pyx_builtin_map___pyx_builtin_TypeError___pyx_tuple__2___pyx_tuple__3___pyx_tuple__6___pyx_tuple__8___pyx_tuple__9___pyx_tuple__10___pyx_tuple__11___pyx_codeobj__12___pyx_tuple__13___pyx_codeobj__14___pyx_tuple__16___pyx_pf_11http_parser_6parser_10HttpParser_8get_method.__pyx_dict_version___pyx_pf_11http_parser_6parser_10HttpParser_8get_method.__pyx_dict_cached_value___pyx_pf_11http_parser_6parser_10HttpParser_14maybe_parse_url.__pyx_dict_version___pyx_pf_11http_parser_6parser_10HttpParser_14maybe_parse_url.__pyx_dict_cached_value___pyx_pf_11http_parser_6parser_10HttpParser_24get_wsgi_environ.__pyx_dict_version___pyx_pf_11http_parser_6parser_10HttpParser_24get_wsgi_environ.__pyx_dict_cached_value___pyx_pf_11http_parser_6parser_10HttpParser_26recv_body.__pyx_dict_version___pyx_pf_11http_parser_6parser_10HttpParser_26recv_body.__pyx_dict_cached_value___pyx_pf_11http_parser_6parser_10HttpParser_28recv_body_into.__pyx_dict_version___pyx_pf_11http_parser_6parser_10HttpParser_28recv_body_into.__pyx_dict_cached_value___pyx_pf_11http_parser_6parser_10HttpParser___init__.__pyx_dict_version___pyx_pf_11http_parser_6parser_10HttpParser___init__.__pyx_dict_cached_value___pyx_f_11http_parser_6parser_on_url_cb.__pyx_dict_version___pyx_f_11http_parser_6parser_on_url_cb.__pyx_dict_cached_value___pyx_f_11http_parser_6parser_on_body_cb.__pyx_dict_version___pyx_f_11http_parser_6parser_on_body_cb.__pyx_dict_cached_value___pyx_f_11http_parser_6parser_on_body_cb.__pyx_dict_version.144___pyx_f_11http_parser_6parser_on_body_cb.__pyx_dict_cached_value.145___pyx_f_11http_parser_6parser_on_body_cb.__pyx_dict_version.146___pyx_f_11http_parser_6parser_on_body_cb.__pyx_dict_cached_value.147___pyx_f_11http_parser_6parser_on_header_field_cb.__pyx_dict_version___pyx_f_11http_parser_6parser_on_header_field_cb.__pyx_dict_cached_value___pyx_f_11http_parser_6parser_on_header_value_cb.__pyx_dict_version___pyx_f_11http_parser_6parser_on_header_value_cb.__pyx_dict_cached_value___pyx_f_11http_parser_6parser_on_headers_complete_cb.__pyx_dict_version___pyx_f_11http_parser_6parser_on_headers_complete_cb.__pyx_dict_cached_value___pyx_f_11http_parser_6parser_on_headers_complete_cb.__pyx_dict_version.153___pyx_f_11http_parser_6parser_on_headers_complete_cb.__pyx_dict_cached_value.154___pyx_f_11http_parser_6parser_on_headers_complete_cb.__pyx_dict_version.155___pyx_f_11http_parser_6parser_on_headers_complete_cb.__pyx_dict_cached_value.156___pyx_ptype_7cpython_4type_type___pyx_ptype_7cpython_4bool_bool___pyx_ptype_7cpython_7complex_complex___Pyx_CLineForTraceback.__pyx_dict_version___Pyx_CLineForTraceback.__pyx_dict_cached_value___pyx_pf_11http_parser_6parser_11_ParserData___init__.__pyx_dict_version___pyx_pf_11http_parser_6parser_11_ParserData___init__.__pyx_dict_cached_value___pyx_code_cache.0___pyx_code_cache.1___pyx_code_cache.2http-parser-0.9.0/http_parser/parser.pyx0000644000076500000240000002750313642725626021154 0ustar benoitcstaff00000000000000# -*- coding: utf-8 - # # This file is part of http-parser released under the MIT license. # See the NOTICE for more information. from libc.stdlib cimport * import os try: from urllib.parse import urlsplit except ImportError: from urlparse import urlsplit import zlib from http_parser.util import b, bytes_to_str, IOrderedDict, unquote cdef extern from "pyversion_compat.h": pass from cpython cimport PyBytes_FromStringAndSize cdef extern from "http_parser.h" nogil: cdef enum http_errno: HPE_OK, HPE_UNKNOWN cdef enum http_method: HTTP_DELETE, HTTP_GET, HTTP_HEAD, HTTP_POST, HTTP_PUT, HTTP_CONNECT, HTTP_OPTIONS, HTTP_TRACE, HTTP_COPY, HTTP_LOCK, HTTP_MKCOL, HTTP_MOVE, HTTP_PROPFIND, HTTP_PROPPATCH, HTTP_UNLOCK, HTTP_REPORT, HTTP_MKACTIVITY, HTTP_CHECKOUT, HTTP_MERGE, HTTP_MSEARCH, HTTP_NOTIFY, HTTP_SUBSCRIBE, HTTP_UNSUBSCRIBE, HTTP_PATCH, HTTP_PURGE cdef enum http_parser_type: HTTP_REQUEST, HTTP_RESPONSE, HTTP_BOTH cdef struct http_parser: int content_length unsigned short http_major unsigned short http_minor unsigned short status_code unsigned char method unsigned char http_errno char upgrade void *data ctypedef int (*http_data_cb) (http_parser*, char *at, size_t length) ctypedef int (*http_cb) (http_parser*) struct http_parser_settings: http_cb on_message_begin http_data_cb on_url http_data_cb on_header_field http_data_cb on_header_value http_cb on_headers_complete http_data_cb on_body http_cb on_message_complete void http_parser_init(http_parser *parser, http_parser_type ptype) size_t http_parser_execute(http_parser *parser, http_parser_settings *settings, char *data, size_t len) int http_should_keep_alive(http_parser *parser) char *http_method_str(http_method) char *http_errno_name(http_errno) char *http_errno_description(http_errno) cdef int on_url_cb(http_parser *parser, char *at, size_t length): res = parser.data res.url += bytes_to_str(PyBytes_FromStringAndSize(at, length)) return 0 cdef int on_header_field_cb(http_parser *parser, char *at, size_t length): header_field = PyBytes_FromStringAndSize(at, length) res = parser.data if res._last_was_value: res._last_field = "" res._last_field += bytes_to_str(header_field) res._last_was_value = False return 0 cdef int on_header_value_cb(http_parser *parser, char *at, size_t length): res = parser.data header_value = bytes_to_str(PyBytes_FromStringAndSize(at, length)) if res._last_field in res.headers: hval = res.headers[res._last_field] if not res._last_was_value: header_value = "%s, %s" % (hval, header_value) else: header_value = "%s %s" % (hval, header_value) # add to headers res.headers[res._last_field] = header_value res._last_was_value = True return 0 cdef int on_headers_complete_cb(http_parser *parser): res = parser.data res.headers_complete = True if res.decompress: encoding = res.headers.get('content-encoding') if encoding == 'gzip': res.decompressobj = zlib.decompressobj(16+zlib.MAX_WBITS) res._decompress_first_try = False del res.headers['content-encoding'] elif encoding == 'deflate': res.decompressobj = zlib.decompressobj() del res.headers['content-encoding'] else: res.decompress = False return res.header_only and 1 or 0 cdef int on_message_begin_cb(http_parser *parser): res = parser.data res.message_begin = True return 0 cdef int on_body_cb(http_parser *parser, char *at, size_t length): res = parser.data value = PyBytes_FromStringAndSize(at, length) res.partial_body = True # decompress the value if needed if res.decompress: if not res._decompress_first_try: value = res.decompressobj.decompress(value) else: try: value = res.decompressobj.decompress(value) except zlib.error: res.decompressobj = zlib.decompressobj(-zlib.MAX_WBITS) value = res.decompressobj.decompress(value) res._decompress_first_try = False res.body.append(value) return 0 cdef int on_message_complete_cb(http_parser *parser): res = parser.data res.message_complete = True return 0 def get_errno_name(errno): if not HPE_OK <= errno <= HPE_UNKNOWN: raise ValueError('errno out of range') return http_errno_name(errno) def get_errno_description(errno): if not HPE_OK <= errno <= HPE_UNKNOWN: raise ValueError('errno out of range') return http_errno_description(errno) class _ParserData(object): def __init__(self, decompress=False, header_only=False): self.url = "" self.body = [] self.headers = IOrderedDict() self.header_only = header_only self.decompress = decompress self.decompressobj = None self._decompress_first_try = True self.chunked = False self.headers_complete = False self.partial_body = False self.message_begin = False self.message_complete = False self._last_field = "" self._last_was_value = False cdef class HttpParser: """ Low level HTTP parser. """ cdef http_parser _parser cdef http_parser_settings _settings cdef object _data cdef str _path cdef str _query_string cdef str _fragment cdef object _parsed_url def __init__(self, kind=2, decompress=False, header_only=False): """ constructor of HttpParser object. : attr kind: Int, could be 0 to parseonly requests, 1 to parse only responses or 2 if we want to let the parser detect the type. """ # set parser type if kind == 2: parser_type = HTTP_BOTH elif kind == 1: parser_type = HTTP_RESPONSE elif kind == 0: parser_type = HTTP_REQUEST # initialize parser http_parser_init(&self._parser, parser_type) self._data = _ParserData(decompress=decompress, header_only=header_only) self._parser.data = self._data self._parsed_url = None self._path = "" self._query_string = "" self._fragment = "" # set callback self._settings.on_url = on_url_cb self._settings.on_body = on_body_cb self._settings.on_header_field = on_header_field_cb self._settings.on_header_value = on_header_value_cb self._settings.on_headers_complete = on_headers_complete_cb self._settings.on_message_begin = on_message_begin_cb self._settings.on_message_complete = on_message_complete_cb def execute(self, char *data, size_t length): """ Execute the parser with the last chunk. We pass the length to let the parser know when EOF has been received. In this case length == 0. :return recved: Int, received length of the data parsed. if recvd != length you should return an error. """ return http_parser_execute(&self._parser, &self._settings, data, length) def get_errno(self): """ get error state """ return self._parser.http_errno def get_version(self): """ get HTTP version """ return (self._parser.http_major, self._parser.http_minor) def get_method(self): """ get HTTP method as string""" return bytes_to_str(http_method_str(self._parser.method)) def get_status_code(self): """ get status code of a response as integer """ return self._parser.status_code def get_url(self): """ get full url of the request """ return self._data.url def maybe_parse_url(self): raw_url = self.get_url() if not self._parsed_url and raw_url: self._parsed_url = urlsplit(raw_url) self._path = self._parsed_url.path or "" self._query_string = self._parsed_url.query or "" self._fragment = self._parsed_url.fragment or "" def get_path(self): """ get path of the request (url without query string and fragment """ self.maybe_parse_url() return self._path def get_query_string(self): """ get query string of the url """ self.maybe_parse_url() return self._query_string def get_fragment(self): """ get fragment of the url """ self.maybe_parse_url() return self._fragment def get_headers(self): """ get request/response headers, headers are returned in a OrderedDict that allows you to get value using insensitive keys. """ return self._data.headers def get_wsgi_environ(self): """ get WSGI environ based on the current request """ self.maybe_parse_url() environ = dict() script_name = os.environ.get("SCRIPT_NAME", "") for key, val in self._data.headers.items(): ku = key.upper() if ku == "CONTENT-TYPE": environ['CONTENT_TYPE'] = val elif ku == "CONTENT-LENGTH": environ['CONTENT_LENGTH'] = val elif ku == "SCRIPT_NAME": environ['SCRIPT_NAME'] = val else: environ['HTTP_%s' % ku.replace('-','_')] = val if script_name: path_info = self._path.split(script_name, 1)[1] else: path_info = self._path environ.update({ 'REQUEST_METHOD': self.get_method(), 'SERVER_PROTOCOL': "HTTP/%s" % ".".join(map(str, self.get_version())), 'PATH_INFO': path_info, 'SCRIPT_NAME': script_name, 'QUERY_STRING': self._query_string, 'RAW_URI': self._data.url}) return environ def recv_body(self): """ return last chunk of the parsed body""" body = b("").join(self._data.body) self._data.body = [] self._data.partial_body = False return body def recv_body_into(self, barray): """ Receive the last chunk of the parsed body and store the data in a buffer rather than creating a new string. """ l = len(barray) body = b("").join(self._data.body) m = min(len(body), l) data, rest = body[:m], body[m:] barray[0:m] = bytes(data) if not rest: self._data.body = [] self._data.partial_body = False else: self._data.body = [rest] return m def is_upgrade(self): """ Do we get upgrade header in the request. Useful for websockets """ return self._parser.upgrade def is_headers_complete(self): """ return True if all headers have been parsed. """ return self._data.headers_complete def is_partial_body(self): """ return True if a chunk of body have been parsed """ return self._data.partial_body def is_message_begin(self): """ return True if the parsing start """ return self._data.message_begin def is_message_complete(self): """ return True if the parsing is done (we get EOF) """ return self._data.message_complete def is_chunked(self): """ return True if Transfer-Encoding header value is chunked""" te = self._data.headers.get('transfer-encoding', '').lower() return te == 'chunked' def should_keep_alive(self): """ return True if the connection should be kept alive """ return http_should_keep_alive(&self._parser) http-parser-0.9.0/http_parser/pyparser.py0000644000076500000240000003614213642730666021334 0ustar benoitcstaff00000000000000# -*- coding: utf-8 - # # This file is part of http-parser released under the MIT license. # See the NOTICE for more information. import os import re import sys if sys.version_info >= (3,): import urllib.parse as urlparse else: import urlparse import zlib from http_parser.util import (b, bytes_to_str, IOrderedDict, StringIO, unquote, MAXSIZE) METHOD_RE = re.compile("[A-Z0-9$-_.]{3,20}") VERSION_RE = re.compile("HTTP/(\d+).(\d+)") STATUS_RE = re.compile("(\d{3})\s*(\w*)") HEADER_RE = re.compile("[\x00-\x1F\x7F()<>@,;:\[\]={} \t\\\\\"]") # errors BAD_FIRST_LINE = 0 INVALID_HEADER = 1 INVALID_CHUNK = 2 class InvalidRequestLine(Exception): """ error raised when first line is invalid """ class InvalidHeader(Exception): """ error raised on invalid header """ class InvalidChunkSize(Exception): """ error raised when we parse an invalid chunk size """ class HttpParser(object): def __init__(self, kind=2, decompress=False): self.kind = kind self.decompress = decompress # errors vars self.errno = None self.errstr = "" # protected variables self._buf = [] self._version = None self._method = None self._status_code = None self._status = None self._reason = None self._url = None self._path = None self._query_string = None self._fragment= None self._headers = IOrderedDict() self._environ = dict() self._chunked = False self._body = [] self._trailers = None self._partial_body = False self._clen = None self._clen_rest = None # private events self.__on_firstline = False self.__on_headers_complete = False self.__on_message_begin = False self.__on_message_complete = False self.__decompress_obj = None self.__decompress_first_try = True def get_version(self): return self._version def get_method(self): return self._method def get_status_code(self): return self._status_code def get_url(self): return self._url def get_path(self): return self._path def get_query_string(self): return self._query_string def get_fragment(self): return self._fragment def get_headers(self): return self._headers def get_wsgi_environ(self): if not self.__on_headers_complete: return None environ = self._environ.copy() # clean special keys for key in ("CONTENT_LENGTH", "CONTENT_TYPE", "SCRIPT_NAME"): hkey = "HTTP_%s" % key if hkey in environ: environ[key] = environ.pop(hkey) script_name = environ.get('SCRIPT_NAME', os.environ.get("SCRIPT_NAME", "")) if script_name: path_info = self._path.split(script_name, 1)[1] environ.update({ "PATH_INFO": unquote(path_info), "SCRIPT_NAME": script_name}) else: environ['SCRIPT_NAME'] = "" if environ.get('HTTP_X_FORWARDED_PROTOCOL', '').lower() == "ssl": environ['wsgi.url_scheme'] = "https" elif environ.get('HTTP_X_FORWARDED_SSL', '').lower() == "on": environ['wsgi.url_scheme'] = "https" else: environ['wsgi.url_scheme'] = "http" return environ def recv_body(self): """ return last chunk of the parsed body""" body = b("").join(self._body) self._body = [] self._partial_body = False return body def recv_body_into(self, barray): """ Receive the last chunk of the parsed body and store the data in a buffer rather than creating a new string. """ l = len(barray) body = b("").join(self._body) m = min(len(body), l) data, rest = body[:m], body[m:] barray[0:m] = data if not rest: self._body = [] self._partial_body = False else: self._body = [rest] return m def is_upgrade(self): """ Do we get upgrade header in the request. Useful for websockets """ hconn = self._headers.get('connection', "").lower() hconn_parts = [x.strip() for x in hconn.split(',')] return "upgrade" in hconn_parts def is_headers_complete(self): """ return True if all headers have been parsed. """ return self.__on_headers_complete def is_partial_body(self): """ return True if a chunk of body have been parsed """ return self._partial_body def is_message_begin(self): """ return True if the parsing start """ return self.__on_message_begin def is_message_complete(self): """ return True if the parsing is done (we get EOF) """ return self.__on_message_complete def is_chunked(self): """ return True if Transfer-Encoding header value is chunked""" return self._chunked def should_keep_alive(self): """ return True if the connection should be kept alive """ hconn = self._headers.get('connection', "").lower() if hconn == "close": return False elif hconn == "keep-alive": return True return self._version == (1, 1) def execute(self, data, length): # end of body can be passed manually by putting a length of 0 if length == 0: self.__on_message_complete = True return length # start to parse nb_parsed = 0 while True: if not self.__on_firstline: idx = data.find(b("\r\n")) if idx < 0: self._buf.append(data) return len(data) else: self.__on_firstline = True self._buf.append(data[:idx]) first_line = bytes_to_str(b("").join(self._buf)) nb_parsed = nb_parsed + idx + 2 rest = data[idx+2:] data = b("") if self._parse_firstline(first_line): self._buf = [rest] else: return nb_parsed elif not self.__on_headers_complete: if data: self._buf.append(data) data = b("") try: to_parse = b("").join(self._buf) ret = self._parse_headers(to_parse) if type(ret) is bool and not ret: return length nb_parsed = nb_parsed + (len(to_parse) - ret) except InvalidHeader as e: self.errno = INVALID_HEADER self.errstr = str(e) return nb_parsed elif not self.__on_message_complete: if not self.__on_message_begin: self.__on_message_begin = True if data: self._buf.append(data) data = b("") ret = self._parse_body() if ret is None: return length elif ret < 0: return ret elif ret == 0: self.__on_message_complete = True return length else: nb_parsed = max(length, ret) else: return 0 def _parse_firstline(self, line): try: if self.kind == 2: # auto detect try: self._parse_request_line(line) except InvalidRequestLine: self._parse_response_line(line) elif self.kind == 1: self._parse_response_line(line) elif self.kind == 0: self._parse_request_line(line) except InvalidRequestLine as e: self.errno = BAD_FIRST_LINE self.errstr = str(e) return False return True def _parse_response_line(self, line): bits = line.split(None, 1) if len(bits) != 2: raise InvalidRequestLine(line) # version matchv = VERSION_RE.match(bits[0]) if matchv is None: raise InvalidRequestLine("Invalid HTTP version: %s" % bits[0]) self._version = (int(matchv.group(1)), int(matchv.group(2))) # status matchs = STATUS_RE.match(bits[1]) if matchs is None: raise InvalidRequestLine("Invalid status %" % bits[1]) self._status = bits[1] self._status_code = int(matchs.group(1)) self._reason = matchs.group(2) def _parse_request_line(self, line): bits = line.split(None, 2) if len(bits) != 3: raise InvalidRequestLine(line) # Method if not METHOD_RE.match(bits[0]): raise InvalidRequestLine("invalid Method: %s" % bits[0]) self._method = bits[0].upper() # URI self._url = bits[1] parts = urlparse.urlsplit(bits[1]) self._path = parts.path or "" self._query_string = parts.query or "" self._fragment = parts.fragment or "" # Version match = VERSION_RE.match(bits[2]) if match is None: raise InvalidRequestLine("Invalid HTTP version: %s" % bits[2]) self._version = (int(match.group(1)), int(match.group(2))) # update environ if hasattr(self,'_environ'): self._environ.update({ "PATH_INFO": self._path, "QUERY_STRING": self._query_string, "RAW_URI": self._url, "REQUEST_METHOD": self._method, "SERVER_PROTOCOL": bits[2]}) def _parse_headers(self, data): idx = data.find(b("\r\n\r\n")) if idx < 0: # we don't have all headers if self._status_code == 204 and data == b("\r\n"): self._buf = [] self.__on_headers_complete = True return 0 else: return False # Split lines on \r\n keeping the \r\n on each line lines = [bytes_to_str(line) + "\r\n" for line in data[:idx].split(b("\r\n"))] # Parse headers into key/value pairs paying attention # to continuation lines. while len(lines): # Parse initial header name : value pair. curr = lines.pop(0) if curr.find(":") < 0: raise InvalidHeader("invalid line %s" % curr.strip()) name, value = curr.split(":", 1) name = name.rstrip(" \t").upper() if HEADER_RE.search(name): raise InvalidHeader("invalid header name %s" % name) if value.endswith("\r\n"): value = value[:-2] name, value = name.strip(), [value.lstrip()] # Consume value continuation lines while len(lines) and lines[0].startswith((" ", "\t")): curr = lines.pop(0) if curr.endswith("\r\n"): curr = curr[:-2] value.append(curr) value = ''.join(value).rstrip() # multiple headers if name in self._headers: value = "%s, %s" % (self._headers[name], value) # store new header value self._headers[name] = value # update WSGI environ key = 'HTTP_%s' % name.upper().replace('-','_') self._environ[key] = value # detect now if body is sent by chunks. clen = self._headers.get('content-length') te = self._headers.get('transfer-encoding', '').lower() if clen is not None: try: self._clen_rest = self._clen = int(clen) except ValueError: pass else: self._chunked = (te == 'chunked') if not self._chunked: self._clen_rest = MAXSIZE # detect encoding and set decompress object encoding = self._headers.get('content-encoding') if self.decompress: if encoding == "gzip": self.__decompress_obj = zlib.decompressobj(16+zlib.MAX_WBITS) self.__decompress_first_try = False elif encoding == "deflate": self.__decompress_obj = zlib.decompressobj() rest = data[idx+4:] self._buf = [rest] self.__on_headers_complete = True return len(rest) def _parse_body(self): if self._status_code == 204 and len(self._buf) == 0: self.__on_message_complete = True return elif not self._chunked: body_part = b("").join(self._buf) self._clen_rest -= len(body_part) # maybe decompress if self.__decompress_obj is not None: if not self.__decompress_first_try: body_part = self.__decompress_obj.decompress(body_part) else: try: body_part = self.__decompress_obj.decompress(body_part) except zlib.error: self.__decompress_obj.decompressobj = zlib.decompressobj(-zlib.MAX_WBITS) body_part = self.__decompress_obj.decompress(body_part) self.__decompress_first_try = False self._partial_body = True self._body.append(body_part) self._buf = [] if self._clen_rest <= 0: self.__on_message_complete = True return else: data = b("").join(self._buf) try: size, rest = self._parse_chunk_size(data) except InvalidChunkSize as e: self.errno = INVALID_CHUNK self.errstr = "invalid chunk size [%s]" % str(e) return -1 if size == 0: return size if size is None or len(rest) < size + 2: # wait till terminator return None body_part, rest = rest[:size], rest[size:] if len(rest) < 2: self.errno = INVALID_CHUNK self.errstr = "chunk missing terminator [%s]" % data return -1 # maybe decompress if self.__decompress_obj is not None: body_part = self.__decompress_obj.decompress(body_part) self._partial_body = True self._body.append(body_part) self._buf = [rest[2:]] return len(rest) def _parse_chunk_size(self, data): idx = data.find(b("\r\n")) if idx < 0: return None, None line, rest_chunk = data[:idx], data[idx+2:] chunk_size = line.split(b(";"), 1)[0].strip() try: chunk_size = int(chunk_size, 16) except ValueError: raise InvalidChunkSize(chunk_size) if chunk_size == 0: self._parse_trailers(rest_chunk) return 0, None return chunk_size, rest_chunk def _parse_trailers(self, data): idx = data.find(b("\r\n\r\n")) if data[:2] == b("\r\n"): self._trailers = self._parse_headers(data[:idx]) http-parser-0.9.0/http_parser/pyversion_compat.h0000644000076500000240000000417513642725626022670 0ustar benoitcstaff00000000000000#include "Python.h" #if PY_VERSION_HEX < 0x02070000 #if PY_VERSION_HEX < 0x02060000 #define PyObject_CheckBuffer(object) (0) #define PyObject_GetBuffer(obj, view, flags) (PyErr_SetString(PyExc_NotImplementedError, \ "new buffer interface is not available"), -1) #define PyBuffer_FillInfo(view, obj, buf, len, readonly, flags) (PyErr_SetString(PyExc_NotImplementedError, \ "new buffer interface is not available"), -1) #define PyBuffer_Release(obj) (PyErr_SetString(PyExc_NotImplementedError, \ "new buffer interface is not available"), -1) // Bytes->String #define PyBytes_FromStringAndSize PyString_FromStringAndSize #define PyBytes_FromString PyString_FromString #define PyBytes_AsString PyString_AsString #define PyBytes_Size PyString_Size #endif #define PyMemoryView_FromBuffer(info) (PyErr_SetString(PyExc_NotImplementedError, \ "new buffer interface is not available"), (PyObject *)NULL) #define PyMemoryView_FromObject(object) (PyErr_SetString(PyExc_NotImplementedError, \ "new buffer interface is not available"), (PyObject *)NULL) #endif #if PY_VERSION_HEX >= 0x03000000 // for buffers #define Py_END_OF_BUFFER ((Py_ssize_t) 0) #define PyObject_CheckReadBuffer(object) (0) #define PyBuffer_FromMemory(ptr, s) (PyErr_SetString(PyExc_NotImplementedError, \ "old buffer interface is not available"), (PyObject *)NULL) #define PyBuffer_FromReadWriteMemory(ptr, s) (PyErr_SetString(PyExc_NotImplementedError, \ "old buffer interface is not available"), (PyObject *)NULL) #define PyBuffer_FromObject(object, offset, size) (PyErr_SetString(PyExc_NotImplementedError, \ "old buffer interface is not available"), (PyObject *)NULL) #define PyBuffer_FromReadWriteObject(object, offset, size) (PyErr_SetString(PyExc_NotImplementedError, \ "old buffer interface is not available"), (PyObject *)NULL) #endif http-parser-0.9.0/http_parser/reader.py0000644000076500000240000000571113642725626020727 0ustar benoitcstaff00000000000000# -*- coding: utf-8 - # # This file is part of http-parser released under the MIT license. # See the NOTICE for more information. from io import DEFAULT_BUFFER_SIZE, RawIOBase from http_parser.util import StringIO import types class HttpBodyReader(RawIOBase): """ Raw implementation to stream http body """ def __init__(self, http_stream): self.http_stream = http_stream self.eof = False def readinto(self, b): if self.http_stream.parser.is_message_complete() or self.eof: if self.http_stream.parser.is_partial_body(): return self.http_stream.parser.recv_body_into(b) return 0 self._checkReadable() try: self._checkClosed() except AttributeError: pass while True: buf = bytearray(DEFAULT_BUFFER_SIZE) recved = self.http_stream.stream.readinto(buf) if recved is None: break del buf[recved:] nparsed = self.http_stream.parser.execute(bytes(buf), recved) if nparsed != recved: return None if self.http_stream.parser.is_partial_body() or recved == 0: break elif self.http_stream.parser.is_message_complete(): break if not self.http_stream.parser.is_partial_body(): self.eof = True b = b'' return len(b'') return self.http_stream.parser.recv_body_into(b) def readable(self): return not self.closed or self.http_stream.parser.is_partial_body() def close(self): if self.closed: return RawIOBase.close(self) self.http_stream = None class IterReader(RawIOBase): """ A raw reader implementation for iterable """ def __init__(self, iterable): self.iter = iter(iterable) self._buffer = "" def readinto(self, b): self._checkClosed() self._checkReadable() l = len(b) try: chunk = self.iter.next() self._buffer += chunk m = min(len(self._buffer), l) data, self._buffer = self._buffer[:m], self._buffer[m:] b[0:m] = data return len(data) except StopIteration: del b[0:] return 0 def readable(self): return not self.closed def close(self): if self.closed: return RawIOBase.close(self) self.iter = None class StringReader(IterReader): """ a raw reader for strings or StringIO.StringIO, cStringIO.StringIO objects """ def __init__(self, string): if isinstance(string, types.StringTypes): iterable = StringIO(string) else: iterable = string IterReader.__init__(self, iterable) from http_parser._socketio import SocketIO class SocketReader(SocketIO): def __init__(self, sock): super(SocketReader, self).__init__(sock, mode='rb') http-parser-0.9.0/http_parser/util.py0000644000076500000240000002052713642725626020444 0ustar benoitcstaff00000000000000# -*- coding: utf-8 - # # This file is part of http-parser released under the MIT license. # See the NOTICE for more information. import sys try: # Python 3.3+ from collections.abc import MutableMapping except ImportError: from collections import MutableMapping if sys.version_info[0] >= 3: from urllib.parse import unquote def b(s): return s.encode("latin-1") def bytes_to_str(b): return str(b, 'latin1') string_types = str, import io StringIO = io.StringIO MAXSIZE = sys.maxsize else: from urllib import unquote def b(s): return s def bytes_to_str(s): return s string_types = basestring, try: import cStringIO StringIO = BytesIO = cStringIO.StringIO except ImportError: import StringIO StringIO = BytesIO = StringIO.StringIO # It's possible to have sizeof(long) != sizeof(Py_ssize_t). class X(object): def __len__(self): return 1 << 31 try: len(X()) except OverflowError: # 32-bit MAXSIZE = int((1 << 31) - 1) else: # 64-bit MAXSIZE = int((1 << 63) - 1) del X class IOrderedDict(dict, MutableMapping): 'Dictionary that remembers insertion order with insensitive key' # An inherited dict maps keys to values. # The inherited dict provides __getitem__, __len__, __contains__, and get. # The remaining methods are order-aware. # Big-O running times for all methods are the same as for regular dictionaries. # The internal self.__map dictionary maps keys to links in a doubly linked list. # The circular doubly linked list starts and ends with a sentinel element. # The sentinel element never gets deleted (this simplifies the algorithm). # Each link is stored as a list of length three: [PREV, NEXT, KEY]. def __init__(self, *args, **kwds): '''Initialize an ordered dictionary. Signature is the same as for regular dictionaries, but keyword arguments are not recommended because their insertion order is arbitrary. ''' if len(args) > 1: raise TypeError('expected at most 1 arguments, got %d' % len(args)) try: self.__root except AttributeError: self.__root = root = [None, None, None] # sentinel node PREV = 0 NEXT = 1 root[PREV] = root[NEXT] = root self.__map = {} self.__lower = {} self.update(*args, **kwds) def __setitem__(self, key, value, PREV=0, NEXT=1, dict_setitem=dict.__setitem__): 'od.__setitem__(i, y) <==> od[i]=y' # Setting a new item creates a new link which goes at the end of the linked # list, and the inherited dictionary is updated with the new key/value pair. if key not in self: root = self.__root last = root[PREV] last[NEXT] = root[PREV] = self.__map[key] = [last, root, key] self.__lower[key.lower()] = key key = self.__lower[key.lower()] dict_setitem(self, key, value) def __delitem__(self, key, PREV=0, NEXT=1, dict_delitem=dict.__delitem__): 'od.__delitem__(y) <==> del od[y]' # Deleting an existing item uses self.__map to find the link which is # then removed by updating the links in the predecessor and successor nodes. if key in self: key = self.__lower.pop(key.lower()) dict_delitem(self, key) link = self.__map.pop(key) link_prev = link[PREV] link_next = link[NEXT] link_prev[NEXT] = link_next link_next[PREV] = link_prev def __getitem__(self, key, dict_getitem=dict.__getitem__): if key in self: key = self.__lower.get(key.lower()) return dict_getitem(self, key) def __contains__(self, key): return key.lower() in self.__lower def __iter__(self, NEXT=1, KEY=2): 'od.__iter__() <==> iter(od)' # Traverse the linked list in order. root = self.__root curr = root[NEXT] while curr is not root: yield curr[KEY] curr = curr[NEXT] def __reversed__(self, PREV=0, KEY=2): 'od.__reversed__() <==> reversed(od)' # Traverse the linked list in reverse order. root = self.__root curr = root[PREV] while curr is not root: yield curr[KEY] curr = curr[PREV] def __reduce__(self): 'Return state information for pickling' items = [[k, self[k]] for k in self] tmp = self.__map, self.__root del self.__map, self.__root inst_dict = vars(self).copy() self.__map, self.__root = tmp if inst_dict: return (self.__class__, (items,), inst_dict) return self.__class__, (items,) def clear(self): 'od.clear() -> None. Remove all items from od.' try: for node in self.__map.values(): del node[:] self.__root[:] = [self.__root, self.__root, None] self.__map.clear() except AttributeError: pass dict.clear(self) def get(self, key, default=None): if key in self: return self[key] return default setdefault = MutableMapping.setdefault update = MutableMapping.update pop = MutableMapping.pop keys = MutableMapping.keys values = MutableMapping.values items = MutableMapping.items __ne__ = MutableMapping.__ne__ def popitem(self, last=True): '''od.popitem() -> (k, v), return and remove a (key, value) pair. Pairs are returned in LIFO order if last is true or FIFO order if false. ''' if not self: raise KeyError('dictionary is empty') key = next(reversed(self) if last else iter(self)) value = self.pop(key) return key, value def __repr__(self): 'od.__repr__() <==> repr(od)' if not self: return '%s()' % (self.__class__.__name__,) return '%s(%r)' % (self.__class__.__name__, list(self.items())) def copy(self): 'od.copy() -> a shallow copy of od' return self.__class__(self) @classmethod def fromkeys(cls, iterable, value=None): '''OD.fromkeys(S[, v]) -> New ordered dictionary with keys from S and values equal to v (which defaults to None). ''' d = cls() for key in iterable: d[key] = value return d def __eq__(self, other): '''od.__eq__(y) <==> od==y. Comparison to another OD is order-sensitive while comparison to a regular mapping is order-insensitive. ''' if isinstance(other, IOrderedDict): return len(self)==len(other) and \ set(self.items()) == set(other.items()) return dict.__eq__(self, other) def __del__(self): self.clear() # eliminate cyclical references status_reasons = { # Status Codes # Informational 100: 'Continue', 101: 'Switching Protocols', 102: 'Processing', # Successful 200: 'OK', 201: 'Created', 202: 'Accepted', 203: 'Non Authoritative Information', 204: 'No Content', 205: 'Reset Content', 206: 'Partial Content', 207: 'Multi Status', 226: 'IM Used', # Redirection 300: 'Multiple Choices', 301: 'Moved Permanently', 302: 'Found', 303: 'See Other', 304: 'Not Modified', 305: 'Use Proxy', 307: 'Temporary Redirect', # Client Error 400: 'Bad Request', 401: 'Unauthorized', 402: 'Payment Required', 403: 'Forbidden', 404: 'Not Found', 405: 'Method Not Allowed', 406: 'Not Acceptable', 407: 'Proxy Authentication Required', 408: 'Request Timeout', 409: 'Conflict', 410: 'Gone', 411: 'Length Required', 412: 'Precondition Failed', 413: 'Request Entity Too Large', 414: 'Request URI Too Long', 415: 'Unsupported Media Type', 416: 'Requested Range Not Satisfiable', 417: 'Expectation Failed', 422: 'Unprocessable Entity', 423: 'Locked', 424: 'Failed Dependency', 426: 'Upgrade Required', # Server Error 500: 'Internal Server Error', 501: 'Not Implemented', 502: 'Bad Gateway', 503: 'Service Unavailable', 504: 'Gateway Timeout', 505: 'HTTP Version Not Supported', 507: 'Insufficient Storage', 510: 'Not Extended', } http-parser-0.9.0/setup.py0000644000076500000240000001360213642725626016270 0ustar benoitcstaff00000000000000# -*- coding: utf-8 - # # This file is part of http-parser released under the MIT license. # See the NOTICE for more information. from __future__ import with_statement from distutils.errors import CCompilerError, DistutilsExecError, \ DistutilsPlatformError from distutils.command.build_ext import build_ext from distutils.command.sdist import sdist as _sdist import glob from imp import load_source import io import os import shutil import sys import traceback from setuptools import setup, find_packages, Extension if not hasattr(sys, 'version_info') or \ sys.version_info < (2, 6, 0, 'final'): raise SystemExit("http-parser requires Python 2.6x or later") ext_errors = (CCompilerError, DistutilsExecError, DistutilsPlatformError) if sys.platform == 'win32' and sys.version_info > (2, 6): # 2.6's distutils.msvc9compiler can raise an IOError when failing to # find the compiler ext_errors += (IOError,) http_parser = load_source("http_parser", os.path.join("http_parser", "__init__.py")) IS_PYPY = hasattr(sys, 'pypy_version_info') CLASSIFIERS = [ 'Development Status :: 4 - Beta', 'Environment :: Other Environment', 'Intended Audience :: Developers', 'License :: OSI Approved :: MIT License', 'Operating System :: MacOS :: MacOS X', 'Operating System :: POSIX', 'Programming Language :: Python', 'Programming Language :: Python :: 2', 'Programming Language :: Python :: 2.6', 'Programming Language :: Python :: 2.7', 'Programming Language :: Python :: 3', 'Programming Language :: Python :: 3.2', 'Programming Language :: Python :: 3.3', 'Programming Language :: Python :: 3.4', 'Programming Language :: Python :: 3.5', 'Programming Language :: Python :: 3.6', 'Programming Language :: Python :: 3.7', 'Programming Language :: Python :: 3.8', 'Topic :: Internet', 'Topic :: Utilities', 'Topic :: Software Development :: Libraries :: Python Modules', ] VERSION = http_parser.__version__ # get long description with io.open(os.path.join(os.path.dirname(__file__), 'README.rst'), encoding='utf8') as f: LONG_DESCRIPTION = f.read() def _system(cmd): cmd = ' '.join(cmd) sys.stderr.write('Running %r in %s\n' % (cmd, os.getcwd())) return os.system(cmd) def make(done=[]): if not done: if os.path.exists('Makefile'): if "PYTHON" not in os.environ: os.environ["PYTHON"] = sys.executable if os.system('make'): sys.exit(1) done.append(1) class sdist(_sdist): def run(self): renamed = False if os.path.exists('Makefile'): make() os.rename('Makefile', 'Makefile.ext') os.rename('pyproject.toml', 'pyproject.toml.dev') os.rename('pyproject.toml.release', 'pyproject.toml') renamed = True try: return _sdist.run(self) finally: if renamed: os.rename('Makefile.ext', 'Makefile') os.rename('pyproject.toml', 'pyproject.toml.release') os.rename('pyproject.toml.dev', 'pyproject.toml') class BuildFailed(Exception): pass class my_build_ext(build_ext): def build_extension(self, ext): make() try: result = build_ext.build_extension(self, ext) except ext_errors: if getattr(ext, 'optional', False): raise BuildFailed else: raise # hack: create a symlink from build/../core.so to # http_parser/parser.so # to prevent "ImportError: cannot import name core" failures try: fullname = self.get_ext_fullname(ext.name) modpath = fullname.split('.') filename = self.get_ext_filename(ext.name) filename = os.path.split(filename)[-1] if not self.inplace: filename = os.path.join(*modpath[:-1] + [filename]) path_to_build_core_so = os.path.abspath(os.path.join(self.build_lib, filename)) path_to_core_so = os.path.abspath(os.path.join('http_parser', os.path.basename(path_to_build_core_so))) if path_to_build_core_so != path_to_core_so: try: os.unlink(path_to_core_so) except OSError: pass if hasattr(os, 'symlink'): sys.stderr.write('Linking %s to %s\n' % ( path_to_build_core_so, path_to_core_so)) os.symlink(path_to_build_core_so, path_to_core_so) else: sys.stderr.write('Copying %s to %s\n' % ( path_to_build_core_so, path_to_core_so)) shutil.copyfile(path_to_build_core_so, path_to_core_so) except Exception: traceback.print_exc() return result def run_setup(with_binary): extra = {} if with_binary: extra.update(dict( ext_modules = [ Extension('http_parser.parser', [ os.path.join('http_parser', 'http_parser.c'), os.path.join('http_parser', 'parser.c') ], ['parser'])], cmdclass=dict(build_ext=my_build_ext, sdist=sdist) )) setup( name = 'http-parser', version = VERSION, description = 'http request/response parser', long_description = LONG_DESCRIPTION, author = 'Benoit Chesneau', author_email = 'benoitc@e-engura.com', license = 'MIT', url = 'http://github.com/benoitc/http-parser', classifiers = CLASSIFIERS, platforms=['any'], packages = find_packages(), ** extra ) if __name__ == "__main__": run_setup(not IS_PYPY)