--- _msgpack.pyx.orig 2011-12-21 20:51:55.549403995 +0100

+++ _msgpack.pyx 2011-12-21 21:14:06.840307133 +0100

@@ -1,22 +1,39 @@

# coding: utf-8

#cython: embedsignature=True

-from cpython cimport *

+#from cpython cimport *

cdef extern from "Python.h":

ctypedef char* const_char_ptr "const char*"

ctypedef char* const_void_ptr "const void*"

ctypedef struct PyObject

cdef int PyObject_AsReadBuffer(object o, const_void_ptr* buff, Py_ssize_t* buf_len) except -1

+ cdef char* PyBytes_AsString(object o)

+ Py_ssize_t PyBytes_Size(object o)

+ int PyLong_Check(object o)

+ int PyInt_Check(object o)

+ int PyFloat_Check(object o)

+ int PyBytes_Check(object o)

+ int PyUnicode_Check(object o)

+ int PyDict_Check(object o)

+ int PySequence_Check(object o)

+ int PyCallable_Check(object o)

+ object PyBytes_FromStringAndSize(char* v, Py_ssize_t len)

+

+cdef extern from "stdlib.h":

+ void* malloc(size_t size)

+ void* realloc(void*p, size_t size)

+ void free(void* p)

+

-from libc.stdlib cimport *

-from libc.string cimport *

+#from libc.stdlib cimport *

+#from libc.string cimport *

import gc

_gc_disable = gc.disable

_gc_enable = gc.enable

cdef extern from "pack.h":

struct msgpack_packer:

char* buf

size_t length

size_t buf_size

@@ -26,47 +43,48 @@

int msgpack_pack_false(msgpack_packer* pk)

int msgpack_pack_long(msgpack_packer* pk, long d)

int msgpack_pack_long_long(msgpack_packer* pk, long long d)

int msgpack_pack_unsigned_long_long(msgpack_packer* pk, unsigned long long d)

int msgpack_pack_double(msgpack_packer* pk, double d)

int msgpack_pack_array(msgpack_packer* pk, size_t l)

int msgpack_pack_map(msgpack_packer* pk, size_t l)

int msgpack_pack_raw(msgpack_packer* pk, size_t l)

int msgpack_pack_raw_body(msgpack_packer* pk, char* body, size_t l)

-cdef int DEFAULT_RECURSE_LIMIT=511

+cdef int DEFAULT_RECURSE_LIMIT

+DEFAULT_RECURSE_LIMIT=511

-cdef class Packer(object):

+cdef class Packer:

"""MessagePack Packer

usage:

packer = Packer()

astream.write(packer.pack(a))

astream.write(packer.pack(b))

"""

cdef msgpack_packer pk

cdef object _default

cdef object _bencoding

cdef object _berrors

cdef char *encoding

cdef char *unicode_errors

- def __cinit__(self):

- cdef int buf_size = 1024*1024

+ def __init__(self, default=None, encoding='utf-8', unicode_errors='strict'):

+ cdef int buf_size

+ buf_size = 1024*1024

self.pk.buf = <char*> malloc(buf_size);

if self.pk.buf == NULL:

raise MemoryError("Unable to allocate internal buffer.")

self.pk.buf_size = buf_size

self.pk.length = 0

- def __init__(self, default=None, encoding='utf-8', unicode_errors='strict'):

if default is not None:

if not PyCallable_Check(default):

raise TypeError("default must be a callable.")

self._default = default

if encoding is None:

self.encoding = NULL

self.unicode_errors = NULL

else:

if isinstance(encoding, unicode):

self._bencoding = encoding.encode('ascii')

@@ -75,21 +93,21 @@

self.encoding = PyBytes_AsString(self._bencoding)

if isinstance(unicode_errors, unicode):

self._berrors = unicode_errors.encode('ascii')

else:

self._berrors = unicode_errors

self.unicode_errors = PyBytes_AsString(self._berrors)

def __dealloc__(self):

free(self.pk.buf);

- cdef int _pack(self, object o, int nest_limit=DEFAULT_RECURSE_LIMIT) except -1:

+ cdef int _pack(self, object o, int nest_limit) except -1:

cdef long long llval

cdef unsigned long long ullval

cdef long longval

cdef double fval

cdef char* rawval

cdef int ret

cdef dict d

if nest_limit < 0:

raise ValueError("Too deep.")

@@ -186,26 +204,29 @@

size_t count

unsigned int ct

PyObject* key

int template_execute(template_context* ctx, const_char_ptr data,

size_t len, size_t* off) except -1

void template_init(template_context* ctx)

object template_data(template_context* ctx)

-def unpackb(object packed, object object_hook=None, object list_hook=None, bint use_list=0, encoding=None, unicode_errors="strict"):

+def unpackb(object packed, object object_hook=None, object list_hook=None, int use_list=0, encoding=None, unicode_errors="strict"):

"""

Unpack packed_bytes to object. Returns an unpacked object."""

cdef template_context ctx

- cdef size_t off = 0

+ cdef size_t off

+ off = 0

cdef int ret

+ cdef char* enc

+ cdef char* err

cdef char* buf

cdef Py_ssize_t buf_len

PyObject_AsReadBuffer(packed, <const_void_ptr*>&buf, &buf_len)

if encoding is None:

enc = NULL

err = NULL

else:

if isinstance(encoding, unicode):

@@ -236,28 +257,28 @@

try:

ret = template_execute(&ctx, buf, buf_len, &off)

finally:

_gc_enable()

if ret == 1:

return template_data(&ctx)

else:

return None

-def unpack(object stream, object object_hook=None, object list_hook=None, bint use_list=0, encoding=None, unicode_errors="strict"):

+def unpack(object stream, object object_hook=None, object list_hook=None, int use_list=0, encoding=None, unicode_errors="strict"):

"""

unpack an object from stream.

"""

return unpackb(stream.read(), use_list=use_list,

object_hook=object_hook, list_hook=list_hook, encoding=encoding, unicode_errors=unicode_errors)

-cdef class Unpacker(object):

+cdef class Unpacker:

"""

Streaming unpacker.

read_size is used like file_like.read(read_size)

`file_like` is a file-like object having `.read(n)` method.

When `Unpacker` initialized with `file_like`, unpacker reads serialized data

from it and `.feed()` method is not usable.

`read_size` is used as `file_like.read(read_size)`. (default: 1M)

@@ -280,37 +301,35 @@

unpacker.feed(buf)

for o in unpacker:

do_something(o)

"""

cdef template_context ctx

cdef char* buf

cdef size_t buf_size, buf_head, buf_tail

cdef object file_like

cdef object file_like_read

cdef Py_ssize_t read_size

- cdef bint use_list

+ cdef int use_list

cdef object object_hook

cdef object _bencoding

cdef object _berrors

cdef char *encoding

cdef char *unicode_errors

- def __cinit__(self):

- self.buf = NULL

-

def __dealloc__(self):

free(self.buf)

self.buf = NULL

- def __init__(self, file_like=None, Py_ssize_t read_size=1024*1024, bint use_list=0,

+ def __init__(self, file_like=None, read_size=1024*1024, int use_list=0,

object object_hook=None, object list_hook=None,

encoding=None, unicode_errors='strict'):

+ self.buf = NULL

self.use_list = use_list

self.file_like = file_like

if file_like:

self.file_like_read = file_like.read

if not PyCallable_Check(self.file_like_read):

raise ValueError("`file_like.read` must be a callable.")

self.read_size = read_size

self.buf = <char*>malloc(read_size)

if self.buf == NULL:

raise MemoryError("Unable to allocate internal buffer.")

@@ -346,26 +365,29 @@

def feed(self, object next_bytes):

cdef char* buf

cdef Py_ssize_t buf_len

if self.file_like is not None:

raise AssertionError(

"unpacker.feed() is not be able to use with`file_like`.")

PyObject_AsReadBuffer(next_bytes, <const_void_ptr*>&buf, &buf_len)

self.append_buffer(buf, buf_len)

cdef append_buffer(self, void* _buf, Py_ssize_t _buf_len):

- cdef:

- char* buf = self.buf

- size_t head = self.buf_head

- size_t tail = self.buf_tail

- size_t buf_size = self.buf_size

- size_t new_size

+ cdef char* buf

+ buf = self.buf

+ cdef size_t head

+ head = self.buf_head

+ cdef size_t tail

+ tail = self.buf_tail

+ cdef size_t buf_size

+ buf_size = self.buf_size

+ cdef size_t new_size

if tail + _buf_len > buf_size:

if ((tail - head) + _buf_len)*2 < buf_size:

# move to front.

memmove(buf, buf + head, tail - head)

tail -= head

head = 0

else:

# expand buffer.

new_size = tail + _buf_len

@@ -387,21 +409,24 @@

# prepare self.buf from file_like

cdef fill_buffer(self):

if self.file_like is not None:

next_bytes = self.file_like_read(self.read_size)

if next_bytes:

self.append_buffer(PyBytes_AsString(next_bytes),

PyBytes_Size(next_bytes))

else:

self.file_like = None

- cpdef unpack(self):

+ def unpack(self):

+ return self.c_unpack()

+

+ cdef c_unpack(self):

"""unpack one object"""

cdef int ret

while 1:

_gc_disable()

ret = template_execute(&self.ctx, self.buf, self.buf_tail, &self.buf_head)

_gc_enable()

if ret == 1:

o = template_data(&self.ctx)

template_init(&self.ctx)

return o

@@ -410,18 +435,18 @@

self.fill_buffer()

continue

raise StopIteration("No more unpack data.")

else:

raise ValueError("Unpack failed: error = %d" % (ret,))

def __iter__(self):

return self

def __next__(self):

- return self.unpack()

+ return self.c_unpack()

# for debug.

#def _buf(self):

# return PyString_FromStringAndSize(self.buf, self.buf_tail)

#def _off(self):

# return self.buf_head