summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--python/MANIFEST9
-rw-r--r--python/Makefile8
-rw-r--r--python/README38
-rw-r--r--python/msgpack/__init__.py3
-rw-r--r--python/msgpack/_msgpack.pyx315
-rw-r--r--python/msgpack/pack.h102
-rw-r--r--python/msgpack/pack_define.h26
-rw-r--r--python/msgpack/pack_template.h741
-rw-r--r--python/msgpack/unpack.h177
-rw-r--r--python/msgpack/unpack_define.h142
-rw-r--r--python/msgpack/unpack_template.h366
-rwxr-xr-xpython/setup.py42
-rwxr-xr-xpython/setup_dev.py41
-rw-r--r--python/test/test_case.py101
-rw-r--r--python/test/test_format.py74
-rw-r--r--python/test/test_pack.py28
-rw-r--r--python/test/test_sequnpack.py36
17 files changed, 2249 insertions, 0 deletions
diff --git a/python/MANIFEST b/python/MANIFEST
new file mode 100644
index 0000000..1fe22ec
--- /dev/null
+++ b/python/MANIFEST
@@ -0,0 +1,9 @@
+setup.py
+msgpack/pack.h
+msgpack/unpack.h
+msgpack/_msgpack.pyx
+msgpack/__init__.py
+include/msgpack/pack_define.h
+include/msgpack/pack_template.h
+include/msgpack/unpack_define.h
+include/msgpack/unpack_template.h
diff --git a/python/Makefile b/python/Makefile
new file mode 100644
index 0000000..d90789a
--- /dev/null
+++ b/python/Makefile
@@ -0,0 +1,8 @@
+all:
+ python setup.py build_ext -i -f
+ python setup.py build
+ python setup.py sdist
+
+.PHONY: test
+test:
+ nosetests test
diff --git a/python/README b/python/README
new file mode 100644
index 0000000..2b2ebe9
--- /dev/null
+++ b/python/README
@@ -0,0 +1,38 @@
+===========================
+MessagePack Python Binding
+===========================
+
+:author: Naoki INADA
+:version: 0.1.0
+:date: 2009-07-12
+
+HOW TO USE
+-----------
+You can read document in docstring after `import msgpack`
+
+
+INSTALL
+---------
+Cython_ is required to build msgpack.
+
+.. _Cython: http://www.cython.org/
+
+posix
+''''''
+You can install msgpack in common way.
+
+ $ python setup.py install
+
+Windows
+''''''''
+MessagePack requires gcc currently. So you need to prepare
+MinGW GCC.
+
+ $ python setup.py install -c mingw32
+
+TEST
+----
+MessagePack uses nosetest for testing.
+Run test with following command:
+
+ $ nosetests test
diff --git a/python/msgpack/__init__.py b/python/msgpack/__init__.py
new file mode 100644
index 0000000..797b29c
--- /dev/null
+++ b/python/msgpack/__init__.py
@@ -0,0 +1,3 @@
+# coding: utf-8
+from _msgpack import *
+
diff --git a/python/msgpack/_msgpack.pyx b/python/msgpack/_msgpack.pyx
new file mode 100644
index 0000000..7990a18
--- /dev/null
+++ b/python/msgpack/_msgpack.pyx
@@ -0,0 +1,315 @@
+# coding: utf-8
+
+import cStringIO
+
+cdef extern from "Python.h":
+ ctypedef char* const_char_ptr "const char*"
+ ctypedef struct PyObject
+
+ cdef object PyString_FromStringAndSize(const_char_ptr b, Py_ssize_t len)
+ cdef PyObject* Py_True
+ cdef PyObject* Py_False
+
+ cdef char* PyString_AsString(object o)
+ cdef long long PyLong_AsLongLong(object o)
+ cdef unsigned long long PyLong_AsUnsignedLongLong(object o)
+
+ cdef int PyMapping_Check(object o)
+ cdef int PySequence_Check(object o)
+ cdef int PyLong_Check(object o)
+ cdef int PyInt_Check(object o)
+ cdef int PyFloat_Check(object o)
+ cdef int PyString_Check(object o)
+ cdef int PyUnicode_Check(object o)
+
+cdef extern from "stdlib.h":
+ void* malloc(size_t)
+ void* realloc(void*, size_t)
+ void free(void*)
+
+cdef extern from "string.h":
+ void* memcpy(char* dst, char* src, size_t size)
+ void* memmove(char* dst, char* src, size_t size)
+
+cdef extern from "pack.h":
+ struct msgpack_packer:
+ char* buf
+ size_t length
+ size_t buf_size
+
+ int msgpack_pack_int(msgpack_packer* pk, int d)
+ int msgpack_pack_nil(msgpack_packer* pk)
+ int msgpack_pack_true(msgpack_packer* pk)
+ 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 class Packer(object):
+ """MessagePack Packer
+
+ usage:
+
+ packer = Packer()
+ astream.write(packer.pack(a))
+ astream.write(packer.pack(b))
+ """
+ cdef msgpack_packer pk
+
+ def __cinit__(self):
+ cdef int buf_size = 1024*1024
+ self.pk.buf = <char*> malloc(buf_size);
+ self.pk.buf_size = buf_size
+ self.pk.length = 0
+
+ def __dealloc__(self):
+ free(self.pk.buf);
+
+ cdef int __pack(self, object o):
+ cdef long long llval
+ cdef unsigned long long ullval
+ cdef long longval
+ cdef double fval
+ cdef char* rawval
+ cdef int ret
+
+ if o is None:
+ ret = msgpack_pack_nil(&self.pk)
+ elif <PyObject*>o == Py_True:
+ ret = msgpack_pack_true(&self.pk)
+ elif <PyObject*>o == Py_False:
+ ret = msgpack_pack_false(&self.pk)
+ elif PyLong_Check(o):
+ if o > 0:
+ ullval = PyLong_AsUnsignedLongLong(o)
+ ret = msgpack_pack_unsigned_long_long(&self.pk, ullval)
+ else:
+ llval = PyLong_AsLongLong(o)
+ ret = msgpack_pack_long_long(&self.pk, llval)
+ elif PyInt_Check(o):
+ longval = o
+ ret = msgpack_pack_long(&self.pk, longval)
+ elif PyFloat_Check(o):
+ fval = o
+ ret = msgpack_pack_double(&self.pk, fval)
+ elif PyString_Check(o):
+ rawval = o
+ ret = msgpack_pack_raw(&self.pk, len(o))
+ if ret == 0:
+ ret = msgpack_pack_raw_body(&self.pk, rawval, len(o))
+ elif PyUnicode_Check(o):
+ o = o.encode('utf-8')
+ rawval = o
+ ret = msgpack_pack_raw(&self.pk, len(o))
+ if ret == 0:
+ ret = msgpack_pack_raw_body(&self.pk, rawval, len(o))
+ elif PyMapping_Check(o):
+ ret = msgpack_pack_map(&self.pk, len(o))
+ if ret == 0:
+ for k,v in o.iteritems():
+ ret = self.__pack(k)
+ if ret != 0: break
+ ret = self.__pack(v)
+ if ret != 0: break
+ elif PySequence_Check(o):
+ ret = msgpack_pack_array(&self.pk, len(o))
+ if ret == 0:
+ for v in o:
+ ret = self.__pack(v)
+ if ret != 0: break
+ else:
+ # TODO: Serialize with defalt() like simplejson.
+ raise TypeError, "can't serialize %r" % (o,)
+ return ret
+
+ def pack(self, object obj):
+ cdef int ret
+ ret = self.__pack(obj)
+ if ret:
+ raise TypeError
+ buf = PyString_FromStringAndSize(self.pk.buf, self.pk.length)
+ self.pk.length = 0
+ return buf
+
+
+def pack(object o, object stream):
+ """pack an object `o` and write it to stream)."""
+ packer = Packer()
+ stream.write(packer.pack(o))
+
+def packb(object o):
+ """pack o and return packed bytes."""
+ packer = Packer()
+ return packer.pack(o)
+
+packs = packb
+
+cdef extern from "unpack.h":
+ ctypedef struct template_context:
+ PyObject* obj
+ size_t count
+ unsigned int ct
+ PyObject* key
+
+ int template_execute(template_context* ctx, const_char_ptr data,
+ size_t len, size_t* off)
+ void template_init(template_context* ctx)
+ object template_data(template_context* ctx)
+
+
+def unpackb(object packed_bytes):
+ """Unpack packed_bytes to object. Returns an unpacked object."""
+ cdef const_char_ptr p = packed_bytes
+ cdef template_context ctx
+ cdef size_t off = 0
+ cdef int ret
+ template_init(&ctx)
+ ret = template_execute(&ctx, p, len(packed_bytes), &off)
+ if ret == 1:
+ return template_data(&ctx)
+ else:
+ return None
+
+unpacks = unpackb
+
+def unpack(object stream):
+ """unpack an object from stream."""
+ packed = stream.read()
+ return unpackb(packed)
+
+cdef class UnpackIterator(object):
+ cdef object unpacker
+
+ def __init__(self, unpacker):
+ self.unpacker = unpacker
+
+ def __next__(self):
+ return self.unpacker.unpack()
+
+ def __iter__(self):
+ return self
+
+cdef class Unpacker(object):
+ """Unpacker(file_like=None, read_size=1024*1024)
+
+ Streaming unpacker.
+ file_like must have read(n) method.
+ read_size is used like file_like.read(read_size)
+
+ If file_like is None, you can ``feed()`` bytes. ``feed()`` is
+ useful for unpacking from non-blocking stream.
+
+ exsample 1:
+ unpacker = Unpacker(afile)
+ for o in unpacker:
+ do_something(o)
+
+ example 2:
+ unpacker = Unpacker()
+ while 1:
+ buf = astream.read()
+ 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 int read_size
+ cdef object waiting_bytes
+
+ def __cinit__(self):
+ self.buf = NULL
+
+ def __dealloc__(self):
+ if self.buf:
+ free(self.buf);
+
+ def __init__(self, file_like=None, int read_size=1024*1024):
+ self.file_like = file_like
+ self.read_size = read_size
+ self.waiting_bytes = []
+ self.buf = <char*>malloc(read_size)
+ self.buf_size = read_size
+ self.buf_head = 0
+ self.buf_tail = 0
+ template_init(&self.ctx)
+
+ def feed(self, next_bytes):
+ if not isinstance(next_bytes, str):
+ raise ValueError, "Argument must be bytes object"
+ self.waiting_bytes.append(next_bytes)
+
+ cdef append_buffer(self):
+ cdef char* buf = self.buf
+ cdef Py_ssize_t tail = self.buf_tail
+ cdef Py_ssize_t l
+
+ for b in self.waiting_bytes:
+ l = len(b)
+ memcpy(buf + tail, PyString_AsString(b), l)
+ tail += l
+ self.buf_tail = tail
+ del self.waiting_bytes[:]
+
+ # prepare self.buf
+ cdef fill_buffer(self):
+ cdef Py_ssize_t add_size
+
+ if self.file_like is not None:
+ self.waiting_bytes.append(self.file_like.read(self.read_size))
+
+ if not self.waiting_bytes:
+ return
+
+ add_size = 0
+ for b in self.waiting_bytes:
+ add_size += len(b)
+
+ cdef char* buf = self.buf
+ cdef size_t head = self.buf_head
+ cdef size_t tail = self.buf_tail
+ cdef size_t size = self.buf_size
+
+ if self.buf_tail + add_size <= self.buf_size:
+ # do nothing.
+ pass
+ if self.buf_tail - self.buf_head + add_size < self.buf_size:
+ # move to front.
+ memmove(buf, buf + head, tail - head)
+ tail -= head
+ head = 0
+ else:
+ # expand buffer
+ size = tail + add_size
+ buf = <char*>realloc(<void*>buf, size)
+
+ self.buf = buf
+ self.buf_head = head
+ self.buf_tail = tail
+ self.buf_size = size
+
+ self.append_buffer()
+
+ cpdef unpack(self):
+ """unpack one object"""
+ cdef int ret
+ self.fill_buffer()
+ ret = template_execute(&self.ctx, self.buf, self.buf_tail, &self.buf_head)
+ if ret == 1:
+ return template_data(&self.ctx)
+ elif ret == 0:
+ raise StopIteration, "No more unpack data."
+ else:
+ raise ValueError, "Unpack failed."
+
+ def __iter__(self):
+ return UnpackIterator(self)
diff --git a/python/msgpack/pack.h b/python/msgpack/pack.h
new file mode 100644
index 0000000..58f021e
--- /dev/null
+++ b/python/msgpack/pack.h
@@ -0,0 +1,102 @@
+/*
+ * MessagePack for Python packing routine
+ *
+ * Copyright (C) 2009 Naoki INADA
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <stddef.h>
+#include <stdlib.h>
+#include "pack_define.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct msgpack_packer {
+ char *buf;
+ size_t length;
+ size_t buf_size;
+} msgpack_packer;
+
+typedef struct Packer Packer;
+
+static inline int msgpack_pack_short(msgpack_packer* pk, short d);
+static inline int msgpack_pack_int(msgpack_packer* pk, int d);
+static inline int msgpack_pack_long(msgpack_packer* pk, long d);
+static inline int msgpack_pack_long_long(msgpack_packer* pk, long long d);
+static inline int msgpack_pack_unsigned_short(msgpack_packer* pk, unsigned short d);
+static inline int msgpack_pack_unsigned_int(msgpack_packer* pk, unsigned int d);
+static inline int msgpack_pack_unsigned_long(msgpack_packer* pk, unsigned long d);
+static inline int msgpack_pack_unsigned_long_long(msgpack_packer* pk, unsigned long long d);
+
+static inline int msgpack_pack_uint8(msgpack_packer* pk, uint8_t d);
+static inline int msgpack_pack_uint16(msgpack_packer* pk, uint16_t d);
+static inline int msgpack_pack_uint32(msgpack_packer* pk, uint32_t d);
+static inline int msgpack_pack_uint64(msgpack_packer* pk, uint64_t d);
+static inline int msgpack_pack_int8(msgpack_packer* pk, int8_t d);
+static inline int msgpack_pack_int16(msgpack_packer* pk, int16_t d);
+static inline int msgpack_pack_int32(msgpack_packer* pk, int32_t d);
+static inline int msgpack_pack_int64(msgpack_packer* pk, int64_t d);
+
+static inline int msgpack_pack_float(msgpack_packer* pk, float d);
+static inline int msgpack_pack_double(msgpack_packer* pk, double d);
+
+static inline int msgpack_pack_nil(msgpack_packer* pk);
+static inline int msgpack_pack_true(msgpack_packer* pk);
+static inline int msgpack_pack_false(msgpack_packer* pk);
+
+static inline int msgpack_pack_array(msgpack_packer* pk, unsigned int n);
+
+static inline int msgpack_pack_map(msgpack_packer* pk, unsigned int n);
+
+static inline int msgpack_pack_raw(msgpack_packer* pk, size_t l);
+static inline int msgpack_pack_raw_body(msgpack_packer* pk, const void* b, size_t l);
+
+static inline int msgpack_pack_write(msgpack_packer* pk, const char *data, size_t l)
+{
+ char* buf = pk->buf;
+ size_t bs = pk->buf_size;
+ size_t len = pk->length;
+
+ if (len + l > bs) {
+ bs = (len + l) * 2;
+ buf = realloc(buf, bs);
+ if (!buf) return -1;
+ }
+ memcpy(buf + len, data, l);
+ len += l;
+
+ pk->buf = buf;
+ pk->buf_size = bs;
+ pk->length = len;
+ return 0;
+}
+
+#define msgpack_pack_inline_func(name) \
+ static inline int msgpack_pack ## name
+
+#define msgpack_pack_inline_func_cint(name) \
+ static inline int msgpack_pack ## name
+
+#define msgpack_pack_user msgpack_packer*
+
+#define msgpack_pack_append_buffer(user, buf, len) \
+ return msgpack_pack_write(user, (const char*)buf, len)
+
+#include "pack_template.h"
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/python/msgpack/pack_define.h b/python/msgpack/pack_define.h
new file mode 100644
index 0000000..33408e5
--- /dev/null
+++ b/python/msgpack/pack_define.h
@@ -0,0 +1,26 @@
+/*
+ * MessagePack unpacking routine template
+ *
+ * Copyright (C) 2008-2009 FURUHASHI Sadayuki
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef MSGPACK_PACK_DEFINE_H__
+#define MSGPACK_PACK_DEFINE_H__
+
+#include <stddef.h>
+#include <stdint.h>
+#include <limits.h>
+
+#endif /* msgpack/pack_define.h */
+
diff --git a/python/msgpack/pack_template.h b/python/msgpack/pack_template.h
new file mode 100644
index 0000000..aa620f5
--- /dev/null
+++ b/python/msgpack/pack_template.h
@@ -0,0 +1,741 @@
+/*
+ * MessagePack packing routine template
+ *
+ * Copyright (C) 2008-2009 FURUHASHI Sadayuki
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#if !defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__)
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+#define __LITTLE_ENDIAN__
+#elif __BYTE_ORDER == __BIG_ENDIAN
+#define __BIG_ENDIAN__
+#endif
+#endif
+
+
+#ifdef __LITTLE_ENDIAN__
+
+#define STORE8_BE8(d) \
+ ((uint8_t*)&d)[0]
+
+
+#define STORE16_BE8(d) \
+ ((uint8_t*)&d)[0]
+
+#define STORE16_BE16(d) \
+ ((uint8_t*)&d)[1], ((uint8_t*)&d)[0]
+
+
+#define STORE32_BE8(d) \
+ ((uint8_t*)&d)[0]
+
+#define STORE32_BE16(d) \
+ ((uint8_t*)&d)[1], ((uint8_t*)&d)[0]
+
+#define STORE32_BE32(d) \
+ ((uint8_t*)&d)[3], ((uint8_t*)&d)[2], ((uint8_t*)&d)[1], ((uint8_t*)&d)[0]
+
+
+#define STORE64_BE8(d) \
+ ((uint8_t*)&d)[0]
+
+#define STORE64_BE16(d) \
+ ((uint8_t*)&d)[1], ((uint8_t*)&d)[0]
+
+#define STORE64_BE32(d) \
+ ((uint8_t*)&d)[3], ((uint8_t*)&d)[2], ((uint8_t*)&d)[1], ((uint8_t*)&d)[0]
+
+#define STORE64_BE64(d) \
+ ((uint8_t*)&d)[7], ((uint8_t*)&d)[6], ((uint8_t*)&d)[5], ((uint8_t*)&d)[4], \
+ ((uint8_t*)&d)[3], ((uint8_t*)&d)[2], ((uint8_t*)&d)[1], ((uint8_t*)&d)[0]
+
+
+#elif __BIG_ENDIAN__
+
+#define STORE8_BE8(d) \
+ ((uint8_t*)&d)[0]
+
+
+#define STORE16_BE8(d) \
+ ((uint8_t*)&d)[1]
+
+#define STORE16_BE16(d) \
+ ((uint8_t*)&d)[0], ((uint8_t*)&d)[1]
+
+
+#define STORE32_BE8(d) \
+ ((uint8_t*)&d)[3]
+
+#define STORE32_BE16(d) \
+ ((uint8_t*)&d)[2], ((uint8_t*)&d)[3]
+
+#define STORE32_BE32(d) \
+ ((uint8_t*)&d)[0], ((uint8_t*)&d)[1], ((uint8_t*)&d)[2], ((uint8_t*)&d)[3]
+
+
+#define STORE64_BE8(d) \
+ ((uint8_t*)&d)[7]
+
+#define STORE64_BE16(d) \
+ ((uint8_t*)&d)[6], ((uint8_t*)&d)[7]
+
+#define STORE64_BE32(d) \
+ ((uint8_t*)&d)[4], ((uint8_t*)&d)[5], ((uint8_t*)&d)[6], ((uint8_t*)&d)[7]
+
+#define STORE64_BE64(d) \
+ ((uint8_t*)&d)[0], ((uint8_t*)&d)[1], ((uint8_t*)&d)[2], ((uint8_t*)&d)[3], \
+ ((uint8_t*)&d)[4], ((uint8_t*)&d)[5], ((uint8_t*)&d)[6], ((uint8_t*)&d)[7]
+
+#endif
+
+#ifndef msgpack_pack_inline_func
+#error msgpack_pack_inline_func template is not defined
+#endif
+
+#ifndef msgpack_pack_user
+#error msgpack_pack_user type is not defined
+#endif
+
+#ifndef msgpack_pack_append_buffer
+#error msgpack_pack_append_buffer callback is not defined
+#endif
+
+
+/*
+ * Integer
+ */
+
+#define msgpack_pack_real_uint8(x, d) \
+do { \
+ if(d < (1<<7)) { \
+ /* fixnum */ \
+ msgpack_pack_append_buffer(x, &STORE8_BE8(d), 1); \
+ } else { \
+ /* unsigned 8 */ \
+ const unsigned char buf[2] = {0xcc, STORE8_BE8(d)}; \
+ msgpack_pack_append_buffer(x, buf, 2); \
+ } \
+} while(0)
+
+#define msgpack_pack_real_uint16(x, d) \
+do { \
+ if(d < (1<<7)) { \
+ /* fixnum */ \
+ msgpack_pack_append_buffer(x, &STORE16_BE8(d), 1); \
+ } else if(d < (1<<8)) { \
+ /* unsigned 8 */ \
+ const unsigned char buf[2] = {0xcc, STORE16_BE8(d)}; \
+ msgpack_pack_append_buffer(x, buf, 2); \
+ } else { \
+ /* unsigned 16 */ \
+ const unsigned char buf[3] = {0xcd, STORE16_BE16(d)}; \
+ msgpack_pack_append_buffer(x, buf, 3); \
+ } \
+} while(0)
+
+#define msgpack_pack_real_uint32(x, d) \
+do { \
+ if(d < (1<<8)) { \
+ if(d < (1<<7)) { \
+ /* fixnum */ \
+ msgpack_pack_append_buffer(x, &STORE32_BE8(d), 1); \
+ } else { \
+ /* unsigned 8 */ \
+ const unsigned char buf[2] = {0xcc, STORE32_BE8(d)}; \
+ msgpack_pack_append_buffer(x, buf, 2); \
+ } \
+ } else { \
+ if(d < (1<<16)) { \
+ /* unsigned 16 */ \
+ const unsigned char buf[3] = {0xcd, STORE32_BE16(d)}; \
+ msgpack_pack_append_buffer(x, buf, 3); \
+ } else { \
+ /* unsigned 32 */ \
+ const unsigned char buf[5] = {0xce, STORE32_BE32(d)}; \
+ msgpack_pack_append_buffer(x, buf, 5); \
+ } \
+ } \
+} while(0)
+
+#define msgpack_pack_real_uint64(x, d) \
+do { \
+ if(d < (1ULL<<8)) { \
+ if(d < (1<<7)) { \
+ /* fixnum */ \
+ msgpack_pack_append_buffer(x, &STORE64_BE8(d), 1); \
+ } else { \
+ /* unsigned 8 */ \
+ const unsigned char buf[2] = {0xcc, STORE64_BE8(d)}; \
+ msgpack_pack_append_buffer(x, buf, 2); \
+ } \
+ } else { \
+ if(d < (1ULL<<16)) { \
+ /* signed 16 */ \
+ const unsigned char buf[3] = {0xcd, STORE64_BE16(d)}; \
+ msgpack_pack_append_buffer(x, buf, 3); \
+ } else if(d < (1ULL<<32)) { \
+ /* signed 32 */ \
+ const unsigned char buf[5] = {0xce, STORE64_BE32(d)}; \
+ msgpack_pack_append_buffer(x, buf, 5); \
+ } else { \
+ /* signed 64 */ \
+ const unsigned char buf[9] = {0xcf, STORE64_BE64(d)}; \
+ msgpack_pack_append_buffer(x, buf, 9); \
+ } \
+ } \
+} while(0)
+
+#define msgpack_pack_real_int8(x, d) \
+do { \
+ if(d < -(1<<5)) { \
+ /* signed 8 */ \
+ const unsigned char buf[2] = {0xd0, STORE8_BE8(d)}; \
+ msgpack_pack_append_buffer(x, buf, 2); \
+ } else { \
+ /* fixnum */ \
+ msgpack_pack_append_buffer(x, &STORE8_BE8(d), 1); \
+ } \
+} while(0)
+
+#define msgpack_pack_real_int16(x, d) \
+do { \
+ if(d < -(1<<5)) { \
+ if(d < -(1<<7)) { \
+ /* signed 16 */ \
+ const unsigned char buf[3] = {0xd1, STORE16_BE16(d)}; \
+ msgpack_pack_append_buffer(x, buf, 3); \
+ } else { \
+ /* signed 8 */ \
+ const unsigned char buf[2] = {0xd0, STORE16_BE8(d)}; \
+ msgpack_pack_append_buffer(x, buf, 2); \
+ } \
+ } else if(d < (1<<7)) { \
+ /* fixnum */ \
+ msgpack_pack_append_buffer(x, &STORE16_BE8(d), 1); \
+ } else { \
+ if(d < (1<<8)) { \
+ /* unsigned 8 */ \
+ const unsigned char buf[2] = {0xcc, STORE16_BE8(d)}; \
+ msgpack_pack_append_buffer(x, buf, 2); \
+ } else { \
+ /* unsigned 16 */ \
+ const unsigned char buf[3] = {0xcd, STORE16_BE16(d)}; \
+ msgpack_pack_append_buffer(x, buf, 3); \
+ } \
+ } \
+} while(0)
+
+#define msgpack_pack_real_int32(x, d) \
+do { \
+ if(d < -(1<<5)) { \
+ if(d < -(1<<15)) { \
+ /* signed 32 */ \
+ const unsigned char buf[5] = {0xd2, STORE32_BE32(d)}; \
+ msgpack_pack_append_buffer(x, buf, 5); \
+ } else if(d < -(1<<7)) { \
+ /* signed 16 */ \
+ const unsigned char buf[3] = {0xd1, STORE32_BE16(d)}; \
+ msgpack_pack_append_buffer(x, buf, 3); \
+ } else { \
+ /* signed 8 */ \
+ const unsigned char buf[2] = {0xd0, STORE32_BE8(d)}; \
+ msgpack_pack_append_buffer(x, buf, 2); \
+ } \
+ } else if(d < (1<<7)) { \
+ /* fixnum */ \
+ msgpack_pack_append_buffer(x, &STORE32_BE8(d), 1); \
+ } else { \
+ if(d < (1<<8)) { \
+ /* unsigned 8 */ \
+ const unsigned char buf[2] = {0xcc, STORE32_BE8(d)}; \
+ msgpack_pack_append_buffer(x, buf, 2); \
+ } else if(d < (1<<16)) { \
+ /* unsigned 16 */ \
+ const unsigned char buf[3] = {0xcd, STORE32_BE16(d)}; \
+ msgpack_pack_append_buffer(x, buf, 3); \
+ } else { \
+ /* unsigned 32 */ \
+ const unsigned char buf[5] = {0xce, STORE32_BE32(d)}; \
+ msgpack_pack_append_buffer(x, buf, 5); \
+ } \
+ } \
+} while(0)
+
+#define msgpack_pack_real_int64(x, d) \
+do { \
+ if(d < -(1LL<<5)) { \
+ if(d < -(1LL<<15)) { \
+ if(d < -(1LL<<31)) { \
+ /* signed 64 */ \
+ const unsigned char buf[9] = {0xd3, STORE64_BE64(d)}; \
+ msgpack_pack_append_buffer(x, buf, 9); \
+ } else { \
+ /* signed 32 */ \
+ const unsigned char buf[5] = {0xd2, STORE64_BE32(d)}; \
+ msgpack_pack_append_buffer(x, buf, 5); \
+ } \
+ } else { \
+ if(d < -(1<<7)) { \
+ /* signed 16 */ \
+ const unsigned char buf[3] = {0xd1, STORE64_BE16(d)}; \
+ msgpack_pack_append_buffer(x, buf, 3); \
+ } else { \
+ /* signed 8 */ \
+ const unsigned char buf[2] = {0xd0, STORE64_BE8(d)}; \
+ msgpack_pack_append_buffer(x, buf, 2); \
+ } \
+ } \
+ } else if(d < (1<<7)) { \
+ /* fixnum */ \
+ msgpack_pack_append_buffer(x, &STORE64_BE8(d), 1); \
+ } else { \
+ if(d < (1LL<<16)) { \
+ if(d < (1<<8)) { \
+ /* unsigned 8 */ \
+ const unsigned char buf[2] = {0xcc, STORE64_BE8(d)}; \
+ msgpack_pack_append_buffer(x, buf, 2); \
+ } else { \
+ /* unsigned 16 */ \
+ const unsigned char buf[3] = {0xcd, STORE64_BE16(d)}; \
+ msgpack_pack_append_buffer(x, buf, 3); \
+ } \
+ } else { \
+ if(d < (1LL<<32)) { \
+ /* unsigned 32 */ \
+ const unsigned char buf[5] = {0xce, STORE64_BE32(d)}; \
+ msgpack_pack_append_buffer(x, buf, 5); \
+ } else { \
+ /* unsigned 64 */ \
+ const unsigned char buf[9] = {0xcf, STORE64_BE64(d)}; \
+ msgpack_pack_append_buffer(x, buf, 9); \
+ } \
+ } \
+ } \
+} while(0)
+
+
+#ifdef msgpack_pack_inline_func_fastint
+
+msgpack_pack_inline_func_fastint(_uint8)(msgpack_pack_user x, uint8_t d)
+{
+ const unsigned char buf[2] = {0xcc, STORE8_BE8(d)};
+ msgpack_pack_append_buffer(x, buf, 2);
+}
+
+msgpack_pack_inline_func_fastint(_uint16)(msgpack_pack_user x, uint16_t d)
+{
+ const unsigned char buf[3] = {0xcd, STORE16_BE16(d)};
+ msgpack_pack_append_buffer(x, buf, 3);
+}
+
+msgpack_pack_inline_func_fastint(_uint32)(msgpack_pack_user x, uint32_t d)
+{
+ const unsigned char buf[5] = {0xce, STORE32_BE32(d)};
+ msgpack_pack_append_buffer(x, buf, 5);
+}
+
+msgpack_pack_inline_func_fastint(_uint64)(msgpack_pack_user x, uint64_t d)
+{
+ const unsigned char buf[9] = {0xcf, STORE64_BE64(d)};
+ msgpack_pack_append_buffer(x, buf, 9);
+}
+
+msgpack_pack_inline_func_fastint(_int8)(msgpack_pack_user x, int8_t d)
+{
+ const unsigned char buf[2] = {0xd0, STORE8_BE8(d)};
+ msgpack_pack_append_buffer(x, buf, 2);
+}
+
+msgpack_pack_inline_func_fastint(_int16)(msgpack_pack_user x, int16_t d)
+{
+ const unsigned char buf[3] = {0xd1, STORE16_BE16(d)};
+ msgpack_pack_append_buffer(x, buf, 3);
+}
+
+msgpack_pack_inline_func_fastint(_int32)(msgpack_pack_user x, int32_t d)
+{
+ const unsigned char buf[5] = {0xd2, STORE32_BE32(d)};
+ msgpack_pack_append_buffer(x, buf, 5);
+}
+
+msgpack_pack_inline_func_fastint(_int64)(msgpack_pack_user x, int64_t d)
+{
+ const unsigned char buf[9] = {0xd3, STORE64_BE64(d)};
+ msgpack_pack_append_buffer(x, buf, 9);
+}
+
+#undef msgpack_pack_inline_func_fastint
+#endif
+
+
+msgpack_pack_inline_func(_uint8)(msgpack_pack_user x, uint8_t d)
+{
+ msgpack_pack_real_uint8(x, d);
+}
+
+msgpack_pack_inline_func(_uint16)(msgpack_pack_user x, uint16_t d)
+{
+ msgpack_pack_real_uint16(x, d);
+}
+
+msgpack_pack_inline_func(_uint32)(msgpack_pack_user x, uint32_t d)
+{
+ msgpack_pack_real_uint32(x, d);
+}
+
+msgpack_pack_inline_func(_uint64)(msgpack_pack_user x, uint64_t d)
+{
+ msgpack_pack_real_uint64(x, d);
+}
+
+msgpack_pack_inline_func(_int8)(msgpack_pack_user x, int8_t d)
+{
+ msgpack_pack_real_int8(x, d);
+}
+
+msgpack_pack_inline_func(_int16)(msgpack_pack_user x, int16_t d)
+{
+ msgpack_pack_real_int16(x, d);
+}
+
+msgpack_pack_inline_func(_int32)(msgpack_pack_user x, int32_t d)
+{
+ msgpack_pack_real_int32(x, d);
+}
+
+msgpack_pack_inline_func(_int64)(msgpack_pack_user x, int64_t d)
+{
+ msgpack_pack_real_int64(x, d);
+}
+
+
+#ifdef msgpack_pack_inline_func_cint
+
+msgpack_pack_inline_func_cint(_short)(msgpack_pack_user x, short d)
+{
+#if defined(SIZEOF_SHORT) || defined(SHRT_MAX)
+#if SIZEOF_SHORT == 2 || SHRT_MAX == 0x7fff
+ msgpack_pack_real_int16(x, d);
+#elif SIZEOF_SHORT == 4 || SHRT_MAX == 0x7fffffff
+ msgpack_pack_real_int32(x, d);
+#else
+ msgpack_pack_real_int64(x, d);
+#endif
+#else
+if(sizeof(short) == 2) {
+ msgpack_pack_real_int16(x, d);
+} else if(sizeof(short) == 4) {
+ msgpack_pack_real_int32(x, d);
+} else {
+ msgpack_pack_real_int64(x, d);
+}
+#endif
+}
+
+msgpack_pack_inline_func_cint(_int)(msgpack_pack_user x, int d)
+{
+#if defined(SIZEOF_INT) || defined(INT_MAX)
+#if SIZEOF_INT == 2 || INT_MAX == 0x7fff
+ msgpack_pack_real_int16(x, d);
+#elif SIZEOF_INT == 4 || INT_MAX == 0x7fffffff
+ msgpack_pack_real_int32(x, d);
+#else
+ msgpack_pack_real_int64(x, d);
+#endif
+#else
+if(sizeof(int) == 2) {
+ msgpack_pack_real_int16(x, d);
+} else if(sizeof(int) == 4) {
+ msgpack_pack_real_int32(x, d);
+} else {
+ msgpack_pack_real_int64(x, d);
+}
+#endif
+}
+
+msgpack_pack_inline_func_cint(_long)(msgpack_pack_user x, long d)
+{
+#if defined(SIZEOF_LONG) || defined(LONG_MAX)
+#if SIZEOF_LONG == 2 || LONG_MAX == 0x7fffL
+ msgpack_pack_real_int16(x, d);
+#elif SIZEOF_LONG == 4 || LONG_MAX == 0x7fffffffL
+ msgpack_pack_real_int32(x, d);
+#else
+ msgpack_pack_real_int64(x, d);
+#endif
+#else
+if(sizeof(long) == 2) {
+ msgpack_pack_real_int16(x, d);
+} else if(sizeof(long) == 4) {
+ msgpack_pack_real_int32(x, d);
+} else {
+ msgpack_pack_real_int64(x, d);
+}
+#endif
+}
+
+msgpack_pack_inline_func_cint(_long_long)(msgpack_pack_user x, long long d)
+{
+#if defined(SIZEOF_LONG_LONG) || defined(LLONG_MAX)
+#if SIZEOF_LONG_LONG == 2 || LLONG_MAX == 0x7fffL
+ msgpack_pack_real_int16(x, d);
+#elif SIZEOF_LONG_LONG == 4 || LLONG_MAX == 0x7fffffffL
+ msgpack_pack_real_int32(x, d);
+#else
+ msgpack_pack_real_int64(x, d);
+#endif
+#else
+if(sizeof(long long) == 2) {
+ msgpack_pack_real_int16(x, d);
+} else if(sizeof(long long) == 4) {
+ msgpack_pack_real_int32(x, d);
+} else {
+ msgpack_pack_real_int64(x, d);
+}
+#endif
+}
+
+msgpack_pack_inline_func_cint(_unsigned_short)(msgpack_pack_user x, unsigned short d)
+{
+#if defined(SIZEOF_SHORT) || defined(USHRT_MAX)
+#if SIZEOF_SHORT == 2 || USHRT_MAX == 0xffffU
+ msgpack_pack_real_uint16(x, d);
+#elif SIZEOF_SHORT == 4 || USHRT_MAX == 0xffffffffU
+ msgpack_pack_real_uint32(x, d);
+#else
+ msgpack_pack_real_uint64(x, d);
+#endif
+#else
+if(sizeof(unsigned short) == 2) {
+ msgpack_pack_real_uint16(x, d);
+} else if(sizeof(unsigned short) == 4) {
+ msgpack_pack_real_uint32(x, d);
+} else {
+ msgpack_pack_real_uint64(x, d);
+}
+#endif
+}
+
+msgpack_pack_inline_func_cint(_unsigned_int)(msgpack_pack_user x, unsigned int d)
+{
+#if defined(SIZEOF_INT) || defined(UINT_MAX)
+#if SIZEOF_INT == 2 || UINT_MAX == 0xffffU
+ msgpack_pack_real_uint16(x, d);
+#elif SIZEOF_INT == 4 || UINT_MAX == 0xffffffffU
+ msgpack_pack_real_uint32(x, d);
+#else
+ msgpack_pack_real_uint64(x, d);
+#endif
+#else
+if(sizeof(unsigned int) == 2) {
+ msgpack_pack_real_uint16(x, d);
+} else if(sizeof(unsigned int) == 4) {
+ msgpack_pack_real_uint32(x, d);
+} else {
+ msgpack_pack_real_uint64(x, d);
+}
+#endif
+}
+
+msgpack_pack_inline_func_cint(_unsigned_long)(msgpack_pack_user x, unsigned long d)
+{
+#if defined(SIZEOF_LONG) || defined(ULONG_MAX)
+#if SIZEOF_LONG == 2 || ULONG_MAX == 0xffffUL
+ msgpack_pack_real_uint16(x, d);
+#elif SIZEOF_LONG == 4 || ULONG_MAX == 0xffffffffUL
+ msgpack_pack_real_uint32(x, d);
+#else
+ msgpack_pack_real_uint64(x, d);
+#endif
+#else
+if(sizeof(unsigned int) == 2) {
+ msgpack_pack_real_uint16(x, d);
+} else if(sizeof(unsigned int) == 4) {
+ msgpack_pack_real_uint32(x, d);
+} else {
+ msgpack_pack_real_uint64(x, d);
+}
+#endif
+}
+
+msgpack_pack_inline_func_cint(_unsigned_long_long)(msgpack_pack_user x, unsigned long long d)
+{
+#if defined(SIZEOF_LONG_LONG) || defined(ULLONG_MAX)
+#if SIZEOF_LONG_LONG == 2 || ULLONG_MAX == 0xffffUL
+ msgpack_pack_real_uint16(x, d);
+#elif SIZEOF_LONG_LONG == 4 || ULLONG_MAX == 0xffffffffUL
+ msgpack_pack_real_uint32(x, d);
+#else
+ msgpack_pack_real_uint64(x, d);
+#endif
+#else
+if(sizeof(unsigned long long) == 2) {
+ msgpack_pack_real_uint16(x, d);
+} else if(sizeof(unsigned long long) == 4) {
+ msgpack_pack_real_uint32(x, d);
+} else {
+ msgpack_pack_real_uint64(x, d);
+}
+#endif
+}
+
+#undef msgpack_pack_inline_func_cint
+#endif
+
+
+
+/*
+ * Float
+ */
+
+msgpack_pack_inline_func(_float)(msgpack_pack_user x, float d)
+{
+ union { char buf[4]; uint32_t num; } f;
+ *((float*)&f.buf) = d; // FIXME
+ const unsigned char buf[5] = {0xca, STORE32_BE32(f.num)};
+ msgpack_pack_append_buffer(x, buf, 5);
+}
+
+msgpack_pack_inline_func(_double)(msgpack_pack_user x, double d)
+{
+ union { char buf[8]; uint64_t num; } f;
+ *((double*)&f.buf) = d; // FIXME
+ const unsigned char buf[9] = {0xcb, STORE64_BE64(f.num)};
+ msgpack_pack_append_buffer(x, buf, 9);
+}
+
+
+/*
+ * Nil
+ */
+
+msgpack_pack_inline_func(_nil)(msgpack_pack_user x)
+{
+ static const unsigned char d = 0xc0;
+ msgpack_pack_append_buffer(x, &d, 1);
+}
+
+
+/*
+ * Boolean
+ */
+
+msgpack_pack_inline_func(_true)(msgpack_pack_user x)
+{
+ static const unsigned char d = 0xc3;
+ msgpack_pack_append_buffer(x, &d, 1);
+}
+
+msgpack_pack_inline_func(_false)(msgpack_pack_user x)
+{
+ static const unsigned char d = 0xc2;
+ msgpack_pack_append_buffer(x, &d, 1);
+}
+
+
+/*
+ * Array
+ */
+
+msgpack_pack_inline_func(_array)(msgpack_pack_user x, unsigned int n)
+{
+ if(n < 16) {
+ unsigned char d = 0x90 | n;
+ msgpack_pack_append_buffer(x, &d, 1);
+ } else if(n < 65536) {
+ uint16_t d = (uint16_t)n;
+ unsigned char buf[3] = {0xdc, STORE16_BE16(d)};
+ msgpack_pack_append_buffer(x, buf, 3);
+ } else {
+ uint32_t d = (uint32_t)n;
+ unsigned char buf[5] = {0xdd, STORE32_BE32(d)};
+ msgpack_pack_append_buffer(x, buf, 5);
+ }
+}
+
+
+/*
+ * Map
+ */
+
+msgpack_pack_inline_func(_map)(msgpack_pack_user x, unsigned int n)
+{
+ if(n < 16) {
+ unsigned char d = 0x80 | n;
+ msgpack_pack_append_buffer(x, &STORE8_BE8(d), 1);
+ } else if(n < 65536) {
+ uint16_t d = (uint16_t)n;
+ unsigned char buf[3] = {0xde, STORE16_BE16(d)};
+ msgpack_pack_append_buffer(x, buf, 3);
+ } else {
+ uint32_t d = (uint32_t)n;
+ unsigned char buf[5] = {0xdf, STORE32_BE32(d)};
+ msgpack_pack_append_buffer(x, buf, 5);
+ }
+}
+
+
+/*
+ * Raw
+ */
+
+msgpack_pack_inline_func(_raw)(msgpack_pack_user x, size_t l)
+{
+ if(l < 32) {
+ unsigned char d = 0xa0 | l;
+ msgpack_pack_append_buffer(x, &STORE8_BE8(d), 1);
+ } else if(l < 65536) {
+ uint16_t d = (uint16_t)l;
+ unsigned char buf[3] = {0xda, STORE16_BE16(d)};
+ msgpack_pack_append_buffer(x, buf, 3);
+ } else {
+ uint32_t d = (uint32_t)l;
+ unsigned char buf[5] = {0xdb, STORE32_BE32(d)};
+ msgpack_pack_append_buffer(x, buf, 5);
+ }
+}
+
+msgpack_pack_inline_func(_raw_body)(msgpack_pack_user x, const void* b, size_t l)
+{
+ msgpack_pack_append_buffer(x, (const unsigned char*)b, l);
+}
+
+#undef msgpack_pack_inline_func
+#undef msgpack_pack_user
+#undef msgpack_pack_append_buffer
+
+#undef STORE8_BE8
+
+#undef STORE16_BE8
+#undef STORE16_BE16
+
+#undef STORE32_BE8
+#undef STORE32_BE16
+#undef STORE32_BE32
+
+#undef STORE64_BE8
+#undef STORE64_BE16
+#undef STORE64_BE32
+#undef STORE64_BE64
+
+#undef msgpack_pack_real_uint8
+#undef msgpack_pack_real_uint16
+#undef msgpack_pack_real_uint32
+#undef msgpack_pack_real_uint64
+#undef msgpack_pack_real_int8
+#undef msgpack_pack_real_int16
+#undef msgpack_pack_real_int32
+#undef msgpack_pack_real_int64
+
diff --git a/python/msgpack/unpack.h b/python/msgpack/unpack.h
new file mode 100644
index 0000000..40058d0
--- /dev/null
+++ b/python/msgpack/unpack.h
@@ -0,0 +1,177 @@
+/*
+ * MessagePack for Python unpacking routine
+ *
+ * Copyright (C) 2009 Naoki INADA
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define MSGPACK_MAX_STACK_SIZE (1024)
+#include "unpack_define.h"
+
+typedef struct unpack_user {
+} unpack_user;
+
+
+#define msgpack_unpack_struct(name) \
+ struct template ## name
+
+#define msgpack_unpack_func(ret, name) \
+ static inline ret template ## name
+
+#define msgpack_unpack_callback(name) \
+ template_callback ## name
+
+#define msgpack_unpack_object PyObject*
+
+#define msgpack_unpack_user unpack_user
+
+
+struct template_context;
+typedef struct template_context template_context;
+
+static inline msgpack_unpack_object template_callback_root(unpack_user* u)
+{
+ return NULL;
+}
+
+static inline int template_callback_uint16(unpack_user* u, uint16_t d, msgpack_unpack_object* o)
+{
+ PyObject *p = PyInt_FromLong((long)d);
+ if (!p)
+ return -1;
+ *o = p;
+ return 0;
+}
+static inline int template_callback_uint8(unpack_user* u, uint8_t d, msgpack_unpack_object* o)
+{
+ return template_callback_uint16(u, d, o);
+}
+
+
+static inline int template_callback_uint32(unpack_user* u, uint32_t d, msgpack_unpack_object* o)
+{
+ PyObject *p;
+ if (d > LONG_MAX) {
+ p = PyLong_FromUnsignedLong((unsigned long)d);
+ } else {
+ p = PyInt_FromLong((long)d);
+ }
+ if (!p)
+ return -1;
+ *o = p;
+ return 0;
+}
+
+static inline int template_callback_uint64(unpack_user* u, uint64_t d, msgpack_unpack_object* o)
+{
+ PyObject *p = PyLong_FromUnsignedLongLong(d);
+ if (!p)
+ return -1;
+ *o = p;
+ return 0;
+}
+
+static inline int template_callback_int32(unpack_user* u, int32_t d, msgpack_unpack_object* o)
+{
+ PyObject *p = PyInt_FromLong(d);
+ if (!p)
+ return -1;
+ *o = p;
+ return 0;
+}
+
+static inline int template_callback_int16(unpack_user* u, int16_t d, msgpack_unpack_object* o)
+{
+ return template_callback_int32(u, d, o);
+}
+
+static inline int template_callback_int8(unpack_user* u, int8_t d, msgpack_unpack_object* o)
+{
+ return template_callback_int32(u, d, o);
+}
+
+static inline int template_callback_int64(unpack_user* u, int64_t d, msgpack_unpack_object* o)
+{
+ PyObject *p = PyLong_FromLongLong(d);
+ if (!p)
+ return -1;
+ *o = p;
+ return 0;
+}
+
+static inline int template_callback_double(unpack_user* u, double d, msgpack_unpack_object* o)
+{
+ PyObject *p = PyFloat_FromDouble(d);
+ if (!p)
+ return -1;
+ *o = p;
+ return 0;
+}
+
+static inline int template_callback_float(unpack_user* u, float d, msgpack_unpack_object* o)
+{
+ return template_callback_double(u, d, o);
+}
+
+static inline int template_callback_nil(unpack_user* u, msgpack_unpack_object* o)
+{ Py_INCREF(Py_None); *o = Py_None; return 0; }
+
+static inline int template_callback_true(unpack_user* u, msgpack_unpack_object* o)
+{ Py_INCREF(Py_True); *o = Py_True; return 0; }
+
+static inline int template_callback_false(unpack_user* u, msgpack_unpack_object* o)
+{ Py_INCREF(Py_False); *o = Py_False; return 0; }
+
+static inline int template_callback_array(unpack_user* u, unsigned int n, msgpack_unpack_object* o)
+{
+ PyObject *p = PyList_New(n);
+ if (!p)
+ return -1;
+ *o = p;
+ return 0;
+}
+
+static inline int template_callback_array_item(unpack_user* u, unsigned int current, msgpack_unpack_object* c, msgpack_unpack_object o)
+{ PyList_SET_ITEM(*c, current, o); return 0; }
+
+static inline int template_callback_map(unpack_user* u, unsigned int n, msgpack_unpack_object* o)
+{
+ PyObject *p = PyDict_New();
+ if (!p)
+ return -1;
+ *o = p;
+ return 0;
+}
+
+static inline int template_callback_map_item(unpack_user* u, msgpack_unpack_object* c, msgpack_unpack_object k, msgpack_unpack_object v)
+{
+ if (PyDict_SetItem(*c, k, v) == 0) {
+ Py_DECREF(k);
+ Py_DECREF(v);
+ return 0;
+ }
+ return -1;
+}
+
+static inline int template_callback_raw(unpack_user* u, const char* b, const char* p, unsigned int l, msgpack_unpack_object* o)
+{
+ PyObject *py;
+ py = PyString_FromStringAndSize(p, l);
+ if (!py)
+ return -1;
+ *o = py;
+ return 0;
+}
+
+#include "unpack_template.h"
diff --git a/python/msgpack/unpack_define.h b/python/msgpack/unpack_define.h
new file mode 100644
index 0000000..d997569
--- /dev/null
+++ b/python/msgpack/unpack_define.h
@@ -0,0 +1,142 @@
+/*
+ * MessagePack unpacking routine template
+ *
+ * Copyright (C) 2008-2009 FURUHASHI Sadayuki
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef MSGPACK_UNPACK_DEFINE_H__
+#define MSGPACK_UNPACK_DEFINE_H__
+
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+#include <assert.h>
+#include <stdio.h>
+#ifndef __WIN32__
+#include <arpa/inet.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#ifndef MSGPACK_MAX_STACK_SIZE
+#define MSGPACK_MAX_STACK_SIZE 16
+#endif
+
+
+#if !defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__)
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+#define __LITTLE_ENDIAN__
+#elif __BYTE_ORDER == __BIG_ENDIAN
+#define __BIG_ENDIAN__
+#endif
+#endif
+
+#ifdef __WIN32__
+static inline uint16_t msgpack_betoh16(uint16_t x) {
+ return ((x << 8) & 0xff00U) |
+ ((x >> 8) & 0x00ffU);
+}
+static inline uint32_t msgpack_betoh32(uint32_t x) {
+ return ((x << 24) & 0xff000000UL ) |
+ ((x << 8) & 0x00ff0000UL ) |
+ ((x >> 8) & 0x0000ff00UL ) |
+ ((x >> 24) & 0x000000ffUL );
+}
+#else
+#define msgpack_betoh16(x) ntohs(x)
+#define msgpack_betoh32(x) ntohl(x)
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#if defined(__bswap_64)
+# define msgpack_betoh64(x) __bswap_64(x)
+#elif defined(__DARWIN_OSSwapInt64)
+# define msgpack_betoh64(x) __DARWIN_OSSwapInt64(x)
+#else
+static inline uint64_t msgpack_betoh64(uint64_t x) {
+ return ((x << 56) & 0xff00000000000000ULL ) |
+ ((x << 40) & 0x00ff000000000000ULL ) |
+ ((x << 24) & 0x0000ff0000000000ULL ) |
+ ((x << 8) & 0x000000ff00000000ULL ) |
+ ((x >> 8) & 0x00000000ff000000ULL ) |
+ ((x >> 24) & 0x0000000000ff0000ULL ) |
+ ((x >> 40) & 0x000000000000ff00ULL ) |
+ ((x >> 56) & 0x00000000000000ffULL ) ;
+}
+#endif
+#else
+#define msgpack_betoh64(x) (x)
+#endif
+
+
+typedef enum {
+ CS_HEADER = 0x00, // nil
+
+ //CS_ = 0x01,
+ //CS_ = 0x02, // false
+ //CS_ = 0x03, // true
+
+ //CS_ = 0x04,
+ //CS_ = 0x05,
+ //CS_ = 0x06,
+ //CS_ = 0x07,
+
+ //CS_ = 0x08,
+ //CS_ = 0x09,
+ CS_FLOAT = 0x0a,
+ CS_DOUBLE = 0x0b,
+ CS_UINT_8 = 0x0c,
+ CS_UINT_16 = 0x0d,
+ CS_UINT_32 = 0x0e,
+ CS_UINT_64 = 0x0f,
+ CS_INT_8 = 0x10,
+ CS_INT_16 = 0x11,
+ CS_INT_32 = 0x12,
+ CS_INT_64 = 0x13,
+
+ //CS_ = 0x14,
+ //CS_ = 0x15,
+ //CS_BIG_INT_16 = 0x16,
+ //CS_BIG_INT_32 = 0x17,
+ //CS_BIG_FLOAT_16 = 0x18,
+ //CS_BIG_FLOAT_32 = 0x19,
+ CS_RAW_16 = 0x1a,
+ CS_RAW_32 = 0x1b,
+ CS_ARRAY_16 = 0x1c,
+ CS_ARRAY_32 = 0x1d,
+ CS_MAP_16 = 0x1e,
+ CS_MAP_32 = 0x1f,
+
+ //ACS_BIG_INT_VALUE,
+ //ACS_BIG_FLOAT_VALUE,
+ ACS_RAW_VALUE,
+} msgpack_unpack_state;
+
+
+typedef enum {
+ CT_ARRAY_ITEM,
+ CT_MAP_KEY,
+ CT_MAP_VALUE,
+} msgpack_container_type;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* msgpack/unpack_define.h */
+
diff --git a/python/msgpack/unpack_template.h b/python/msgpack/unpack_template.h
new file mode 100644
index 0000000..c960c3a
--- /dev/null
+++ b/python/msgpack/unpack_template.h
@@ -0,0 +1,366 @@
+/*
+ * MessagePack unpacking routine template
+ *
+ * Copyright (C) 2008-2009 FURUHASHI Sadayuki
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef msgpack_unpack_func
+#error msgpack_unpack_func template is not defined
+#endif
+
+#ifndef msgpack_unpack_callback
+#error msgpack_unpack_callback template is not defined
+#endif
+
+#ifndef msgpack_unpack_struct
+#error msgpack_unpack_struct template is not defined
+#endif
+
+#ifndef msgpack_unpack_struct_decl
+#define msgpack_unpack_struct_decl(name) msgpack_unpack_struct(name)
+#endif
+
+#ifndef msgpack_unpack_object
+#error msgpack_unpack_object type is not defined
+#endif
+
+#ifndef msgpack_unpack_user
+#error msgpack_unpack_user type is not defined
+#endif
+
+
+msgpack_unpack_struct_decl(_stack) {
+ msgpack_unpack_object obj;
+ size_t count;
+ unsigned int ct;
+
+ union {
+ size_t curr;
+ msgpack_unpack_object map_key;
+ };
+};
+
+msgpack_unpack_struct_decl(_context) {
+ msgpack_unpack_user user;
+ unsigned int cs;
+ unsigned int trail;
+ unsigned int top;
+ msgpack_unpack_struct(_stack) stack[MSGPACK_MAX_STACK_SIZE];
+};
+
+
+msgpack_unpack_func(void, _init)(msgpack_unpack_struct(_context)* ctx)
+{
+ ctx->cs = CS_HEADER;
+ ctx->trail = 0;
+ ctx->top = 0;
+ ctx->stack[0].obj = msgpack_unpack_callback(_root)(&ctx->user);
+}
+
+msgpack_unpack_func(msgpack_unpack_object, _data)(msgpack_unpack_struct(_context)* ctx)
+{
+ return (ctx)->stack[0].obj;
+}
+
+
+msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const char* data, size_t len, size_t* off)
+{
+ assert(len >= *off);
+
+ const unsigned char* p = (unsigned char*)data + *off;
+ const unsigned char* const pe = (unsigned char*)data + len;
+ const void* n = NULL;
+
+ unsigned int trail = ctx->trail;
+ unsigned int cs = ctx->cs;
+ unsigned int top = ctx->top;
+ msgpack_unpack_struct(_stack)* stack = ctx->stack;
+ msgpack_unpack_user* user = &ctx->user;
+
+ msgpack_unpack_object obj;
+ msgpack_unpack_struct(_stack)* c = NULL;
+
+ int ret;
+
+#define push_simple_value(func) \
+ if(msgpack_unpack_callback(func)(user, &obj) < 0) { goto _failed; } \
+ goto _push
+#define push_fixed_value(func, arg) \
+ if(msgpack_unpack_callback(func)(user, arg, &obj) < 0) { goto _failed; } \
+ goto _push
+#define push_variable_value(func, base, pos, len) \
+ if(msgpack_unpack_callback(func)(user, \
+ (const char*)base, (const char*)pos, len, &obj) < 0) { goto _failed; } \
+ goto _push
+
+#define again_fixed_trail(_cs, trail_len) \
+ trail = trail_len; \
+ cs = _cs; \
+ goto _fixed_trail_again
+#define again_fixed_trail_if_zero(_cs, trail_len, ifzero) \
+ trail = trail_len; \
+ if(trail == 0) { goto ifzero; } \
+ cs = _cs; \
+ goto _fixed_trail_again
+
+#define start_container(func, count_, ct_) \
+ if(msgpack_unpack_callback(func)(user, count_, &stack[top].obj) < 0) { goto _failed; } \
+ if((count_) == 0) { obj = stack[top].obj; goto _push; } \
+ if(top >= MSGPACK_MAX_STACK_SIZE) { goto _failed; } \
+ stack[top].ct = ct_; \
+ stack[top].curr = 0; \
+ stack[top].count = count_; \
+ /*printf("container %d count %d stack %d\n",stack[top].obj,count_,top);*/ \
+ /*printf("stack push %d\n", top);*/ \
+ ++top; \
+ goto _header_again
+
+#define NEXT_CS(p) \
+ ((unsigned int)*p & 0x1f)
+
+#define PTR_CAST_8(ptr) (*(uint8_t*)ptr)
+#define PTR_CAST_16(ptr) msgpack_betoh16(*(uint16_t*)ptr)
+#define PTR_CAST_32(ptr) msgpack_betoh32(*(uint32_t*)ptr)
+#define PTR_CAST_64(ptr) msgpack_betoh64(*(uint64_t*)ptr)
+
+ if(p == pe) { goto _out; }
+ do {
+ switch(cs) {
+ case CS_HEADER:
+ switch(*p) {
+ case 0x00 ... 0x7f: // Positive Fixnum
+ push_fixed_value(_uint8, *(uint8_t*)p);
+ case 0xe0 ... 0xff: // Negative Fixnum
+ push_fixed_value(_int8, *(int8_t*)p);
+ case 0xc0 ... 0xdf: // Variable
+ switch(*p) {
+ case 0xc0: // nil
+ push_simple_value(_nil);
+ //case 0xc1: // string
+ // again_terminal_trail(NEXT_CS(p), p+1);
+ case 0xc2: // false
+ push_simple_value(_false);
+ case 0xc3: // true
+ push_simple_value(_true);
+ //case 0xc4:
+ //case 0xc5:
+ //case 0xc6:
+ //case 0xc7:
+ //case 0xc8:
+ //case 0xc9:
+ case 0xca: // float
+ case 0xcb: // double
+ case 0xcc: // unsigned int 8
+ case 0xcd: // unsigned int 16
+ case 0xce: // unsigned int 32
+ case 0xcf: // unsigned int 64
+ case 0xd0: // signed int 8
+ case 0xd1: // signed int 16
+ case 0xd2: // signed int 32
+ case 0xd3: // signed int 64
+ again_fixed_trail(NEXT_CS(p), 1 << (((unsigned int)*p) & 0x03));
+ //case 0xd4:
+ //case 0xd5:
+ //case 0xd6: // big integer 16
+ //case 0xd7: // big integer 32
+ //case 0xd8: // big float 16
+ //case 0xd9: // big float 32
+ case 0xda: // raw 16
+ case 0xdb: // raw 32
+ case 0xdc: // array 16
+ case 0xdd: // array 32
+ case 0xde: // map 16
+ case 0xdf: // map 32
+ again_fixed_trail(NEXT_CS(p), 2 << (((unsigned int)*p) & 0x01));
+ default:
+ goto _failed;
+ }
+ case 0xa0 ... 0xbf: // FixRaw
+ again_fixed_trail_if_zero(ACS_RAW_VALUE, ((unsigned int)*p & 0x1f), _raw_zero);
+ case 0x90 ... 0x9f: // FixArray
+ start_container(_array, ((unsigned int)*p) & 0x0f, CT_ARRAY_ITEM);
+ case 0x80 ... 0x8f: // FixMap
+ start_container(_map, ((unsigned int)*p) & 0x0f, CT_MAP_KEY);
+
+ default:
+ goto _failed;
+ }
+ // end CS_HEADER
+
+
+ _fixed_trail_again:
+ ++p;
+
+ default:
+ if((size_t)(pe - p) < trail) { goto _out; }
+ n = p; p += trail - 1;
+ switch(cs) {
+ //case CS_
+ //case CS_
+ case CS_FLOAT: {
+ union { uint32_t num; char buf[4]; } f;
+ f.num = PTR_CAST_32(n); // FIXME
+ push_fixed_value(_float, *((float*)f.buf)); }
+ case CS_DOUBLE: {
+ union { uint64_t num; char buf[8]; } f;
+ f.num = PTR_CAST_64(n); // FIXME
+ push_fixed_value(_double, *((double*)f.buf)); }
+ case CS_UINT_8:
+ push_fixed_value(_uint8, (uint8_t)PTR_CAST_8(n));
+ case CS_UINT_16:
+ push_fixed_value(_uint16, (uint16_t)PTR_CAST_16(n));
+ case CS_UINT_32:
+ push_fixed_value(_uint32, (uint32_t)PTR_CAST_32(n));
+ case CS_UINT_64:
+ push_fixed_value(_uint64, (uint64_t)PTR_CAST_64(n));
+
+ case CS_INT_8:
+ push_fixed_value(_int8, (int8_t)PTR_CAST_8(n));
+ case CS_INT_16:
+ push_fixed_value(_int16, (int16_t)PTR_CAST_16(n));
+ case CS_INT_32:
+ push_fixed_value(_int32, (int32_t)PTR_CAST_32(n));
+ case CS_INT_64:
+ push_fixed_value(_int64, (int64_t)PTR_CAST_64(n));
+
+ //case CS_
+ //case CS_
+ //case CS_BIG_INT_16:
+ // again_fixed_trail_if_zero(ACS_BIG_INT_VALUE, (uint16_t)PTR_CAST_16(n), _big_int_zero);
+ //case CS_BIG_INT_32:
+ // again_fixed_trail_if_zero(ACS_BIG_INT_VALUE, (uint32_t)PTR_CAST_32(n), _big_int_zero);
+ //case ACS_BIG_INT_VALUE:
+ //_big_int_zero:
+ // // FIXME
+ // push_variable_value(_big_int, data, n, trail);
+
+ //case CS_BIG_FLOAT_16:
+ // again_fixed_trail_if_zero(ACS_BIG_FLOAT_VALUE, (uint16_t)PTR_CAST_16(n), _big_float_zero);
+ //case CS_BIG_FLOAT_32:
+ // again_fixed_trail_if_zero(ACS_BIG_FLOAT_VALUE, (uint32_t)PTR_CAST_32(n), _big_float_zero);
+ //case ACS_BIG_FLOAT_VALUE:
+ //_big_float_zero:
+ // // FIXME
+ // push_variable_value(_big_float, data, n, trail);
+
+ case CS_RAW_16:
+ again_fixed_trail_if_zero(ACS_RAW_VALUE, (uint16_t)PTR_CAST_16(n), _raw_zero);
+ case CS_RAW_32:
+ again_fixed_trail_if_zero(ACS_RAW_VALUE, (uint32_t)PTR_CAST_32(n), _raw_zero);
+ case ACS_RAW_VALUE:
+ _raw_zero:
+ push_variable_value(_raw, data, n, trail);
+
+ case CS_ARRAY_16:
+ start_container(_array, (uint16_t)PTR_CAST_16(n), CT_ARRAY_ITEM);
+ case CS_ARRAY_32:
+ /* FIXME security guard */
+ start_container(_array, (uint32_t)PTR_CAST_32(n), CT_ARRAY_ITEM);
+
+ case CS_MAP_16:
+ start_container(_map, (uint16_t)PTR_CAST_16(n), CT_MAP_KEY);
+ case CS_MAP_32:
+ /* FIXME security guard */
+ start_container(_map, (uint32_t)PTR_CAST_32(n), CT_MAP_KEY);
+
+ default:
+ goto _failed;
+ }
+ }
+
+_push:
+ if(top == 0) { goto _finish; }
+ c = &stack[top-1];
+ switch(c->ct) {
+ case CT_ARRAY_ITEM:
+ if(msgpack_unpack_callback(_array_item)(user, c->curr, &c->obj, obj) < 0) { goto _failed; }
+ if(++c->curr == c->count) {
+ obj = c->obj;
+ --top;
+ /*printf("stack pop %d\n", top);*/
+ goto _push;
+ }
+ goto _header_again;
+ case CT_MAP_KEY:
+ c->map_key = obj;
+ c->ct = CT_MAP_VALUE;
+ goto _header_again;
+ case CT_MAP_VALUE:
+ if(msgpack_unpack_callback(_map_item)(user, &c->obj, c->map_key, obj) < 0) { goto _failed; }
+ if(--c->count == 0) {
+ obj = c->obj;
+ --top;
+ /*printf("stack pop %d\n", top);*/
+ goto _push;
+ }
+ c->ct = CT_MAP_KEY;
+ goto _header_again;
+
+ default:
+ goto _failed;
+ }
+
+_header_again:
+ cs = CS_HEADER;
+ ++p;
+ } while(p != pe);
+ goto _out;
+
+
+_finish:
+ stack[0].obj = obj;
+ ++p;
+ ret = 1;
+ /*printf("-- finish --\n"); */
+ goto _end;
+
+_failed:
+ /*printf("** FAILED **\n"); */
+ ret = -1;
+ goto _end;
+
+_out:
+ ret = 0;
+ goto _end;
+
+_end:
+ ctx->cs = cs;
+ ctx->trail = trail;
+ ctx->top = top;
+ *off = p - (const unsigned char*)data;
+
+ return ret;
+}
+
+
+#undef msgpack_unpack_func
+#undef msgpack_unpack_callback
+#undef msgpack_unpack_struct
+#undef msgpack_unpack_object
+#undef msgpack_unpack_user
+
+#undef push_simple_value
+#undef push_fixed_value
+#undef push_variable_value
+#undef again_fixed_trail
+#undef again_fixed_trail_if_zero
+#undef start_container
+
+#undef NEXT_CS
+#undef PTR_CAST_8
+#undef PTR_CAST_16
+#undef PTR_CAST_32
+#undef PTR_CAST_64
+
diff --git a/python/setup.py b/python/setup.py
new file mode 100755
index 0000000..c0d121b
--- /dev/null
+++ b/python/setup.py
@@ -0,0 +1,42 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+from distutils.core import setup, Extension
+#from Cython.Distutils import build_ext
+import os
+
+version = '0.1.0'
+
+msgpack_mod = Extension('msgpack._msgpack',
+ #sources=['msgpack/_msgpack.pyx']
+ sources=['msgpack/_msgpack.c']
+ )
+
+desc = 'MessagePack (de)serializer.'
+long_desc = desc + """
+
+MessagePack_ (de)serializer for Python.
+
+.. _MessagePack: http://msgpack.sourceforge.jp/
+
+What's MessagePack? (from http://msgpack.sourceforge.jp/)
+
+ MessagePack is a binary-based efficient data interchange format that is
+ focused on high performance. It is like JSON, but very fast and small.
+"""
+
+setup(name='msgpack',
+ author='Naoki INADA',
+ author_email='songofacandy@gmail.com',
+ version=version,
+ #cmdclass={'build_ext': build_ext},
+ ext_modules=[msgpack_mod],
+ packages=['msgpack'],
+ description=desc,
+ long_description=long_desc,
+ classifiers=[
+ 'Development Status :: 4 - Beta',
+ 'Intended Audience :: Developers',
+ 'License :: OSI Approved :: Apache Software License',
+ ]
+ )
diff --git a/python/setup_dev.py b/python/setup_dev.py
new file mode 100755
index 0000000..255e0db
--- /dev/null
+++ b/python/setup_dev.py
@@ -0,0 +1,41 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+from distutils.core import setup, Extension
+from Cython.Distutils import build_ext
+import os
+
+version = '0.1.0'
+
+msgpack_mod = Extension('msgpack._msgpack',
+ sources=['msgpack/_msgpack.pyx']
+ )
+
+desc = 'MessagePack (de)serializer.'
+long_desc = desc + """
+
+MessagePack_ (de)serializer for Python.
+
+.. _MessagePack: http://msgpack.sourceforge.jp/
+
+What's MessagePack? (from http://msgpack.sourceforge.jp/)
+
+ MessagePack is a binary-based efficient data interchange format that is
+ focused on high performance. It is like JSON, but very fast and small.
+"""
+
+setup(name='msgpack',
+ author='Naoki INADA',
+ author_email='songofacandy@gmail.com',
+ version=version,
+ cmdclass={'build_ext': build_ext},
+ ext_modules=[msgpack_mod],
+ packages=['msgpack'],
+ description=desc,
+ long_description=long_desc,
+ classifiers=[
+ 'Development Status :: 4 - Beta',
+ 'Intended Audience :: Developers',
+ 'License :: OSI Approved :: Apache Software License',
+ ]
+ )
diff --git a/python/test/test_case.py b/python/test/test_case.py
new file mode 100644
index 0000000..d754fb0
--- /dev/null
+++ b/python/test/test_case.py
@@ -0,0 +1,101 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+from nose import main
+from nose.tools import *
+from msgpack import packs, unpacks
+
+def check(length, obj):
+ v = packs(obj)
+ assert_equal(len(v), length, "%r length should be %r but get %r" % (obj, length, len(v)))
+ assert_equal(unpacks(v), obj)
+
+def test_1():
+ for o in [None, True, False, 0, 1, (1 << 6), (1 << 7) - 1, -1,
+ -((1<<5)-1), -(1<<5)]:
+ check(1, o)
+
+def test_2():
+ for o in [1 << 7, (1 << 8) - 1,
+ -((1<<5)+1), -(1<<7)
+ ]:
+ check(2, o)
+
+def test_3():
+ for o in [1 << 8, (1 << 16) - 1,
+ -((1<<7)+1), -(1<<15)]:
+ check(3, o)
+
+def test_5():
+ for o in [1 << 16, (1 << 32) - 1,
+ -((1<<15)+1), -(1<<31)]:
+ check(5, o)
+
+def test_9():
+ for o in [1 << 32, (1 << 64) - 1,
+ -((1<<31)+1), -(1<<63),
+ 1.0, 0.1, -0.1, -1.0]:
+ check(9, o)
+
+
+def check_raw(overhead, num):
+ check(num + overhead, " " * num)
+
+def test_fixraw():
+ check_raw(1, 0)
+ check_raw(1, (1<<5) - 1)
+
+def test_raw16():
+ check_raw(3, 1<<5)
+ check_raw(3, (1<<16) - 1)
+
+def test_raw32():
+ check_raw(5, 1<<16)
+
+
+def check_array(overhead, num):
+ check(num + overhead, [None] * num)
+
+def test_fixarray():
+ check_array(1, 0)
+ check_array(1, (1 << 4) - 1)
+
+def test_array16():
+ check_array(3, 1 << 4)
+ check_array(3, (1<<16)-1)
+
+def test_array32():
+ check_array(5, (1<<16))
+
+
+def match(obj, buf):
+ assert_equal(packs(obj), buf)
+ assert_equal(unpacks(buf), obj)
+
+def test_match():
+ cases = [
+ (None, '\xc0'),
+ (False, '\xc2'),
+ (True, '\xc3'),
+ (0, '\x00'),
+ (127, '\x7f'),
+ (128, '\xcc\x80'),
+ (256, '\xcd\x01\x00'),
+ (-1, '\xff'),
+ (-33, '\xd0\xdf'),
+ (-129, '\xd1\xff\x7f'),
+ ({1:1}, '\x81\x01\x01'),
+ (1.0, "\xcb\x3f\xf0\x00\x00\x00\x00\x00\x00"),
+ ([], '\x90'),
+ (range(15),"\x9f\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e"),
+ (range(16),"\xdc\x00\x10\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"),
+ ({}, '\x80'),
+ (dict([(x,x) for x in range(15)]), '\x8f\x00\x00\x01\x01\x02\x02\x03\x03\x04\x04\x05\x05\x06\x06\x07\x07\x08\x08\t\t\n\n\x0b\x0b\x0c\x0c\r\r\x0e\x0e'),
+ (dict([(x,x) for x in range(16)]), '\xde\x00\x10\x00\x00\x01\x01\x02\x02\x03\x03\x04\x04\x05\x05\x06\x06\x07\x07\x08\x08\t\t\n\n\x0b\x0b\x0c\x0c\r\r\x0e\x0e\x0f\x0f'),
+ ]
+
+ for v, p in cases:
+ match(v, p)
+
+if __name__ == '__main__':
+ main()
diff --git a/python/test/test_format.py b/python/test/test_format.py
new file mode 100644
index 0000000..009a764
--- /dev/null
+++ b/python/test/test_format.py
@@ -0,0 +1,74 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+from nose import main
+from nose.tools import *
+from msgpack import unpacks
+
+def check(src, should):
+ assert_equal(unpacks(src), should)
+
+def testSimpleValue():
+ check("\x93\xc0\xc2\xc3",
+ [None, False, True])
+
+def testFixnum():
+ check("\x92\x93\x00\x40\x7f\x93\xe0\xf0\xff",
+ [[0,64,127], [-32,-16,-1]]
+ )
+
+def testFixArray():
+ check("\x92\x90\x91\x91\xc0",
+ [[],[[None]]],
+ )
+
+def testFixRaw():
+ check("\x94\xa0\xa1a\xa2bc\xa3def",
+ ["", "a", "bc", "def"],
+ )
+
+def testFixMap():
+ check(
+ "\x82\xc2\x81\xc0\xc0\xc3\x81\xc0\x80",
+ {False: {None: None}, True:{None:{}}},
+ )
+
+def testUnsignedInt():
+ check(
+ "\x99\xcc\x00\xcc\x80\xcc\xff\xcd\x00\x00\xcd\x80\x00"
+ "\xcd\xff\xff\xce\x00\x00\x00\x00\xce\x80\x00\x00\x00"
+ "\xce\xff\xff\xff\xff",
+ [0, 128, 255, 0, 32768, 65535, 0, 2147483648, 4294967295],
+ )
+
+def testSignedInt():
+ check("\x99\xd0\x00\xd0\x80\xd0\xff\xd1\x00\x00\xd1\x80\x00"
+ "\xd1\xff\xff\xd2\x00\x00\x00\x00\xd2\x80\x00\x00\x00"
+ "\xd2\xff\xff\xff\xff",
+ [0, -128, -1, 0, -32768, -1, 0, -2147483648, -1])
+
+def testRaw():
+ check("\x96\xda\x00\x00\xda\x00\x01a\xda\x00\x02ab\xdb\x00\x00"
+ "\x00\x00\xdb\x00\x00\x00\x01a\xdb\x00\x00\x00\x02ab",
+ ["", "a", "ab", "", "a", "ab"])
+
+def testArray():
+ check("\x96\xdc\x00\x00\xdc\x00\x01\xc0\xdc\x00\x02\xc2\xc3\xdd\x00"
+ "\x00\x00\x00\xdd\x00\x00\x00\x01\xc0\xdd\x00\x00\x00\x02"
+ "\xc2\xc3",
+ [[], [None], [False,True], [], [None], [False,True]])
+
+def testMap():
+ check(
+ "\x96"
+ "\xde\x00\x00"
+ "\xde\x00\x01\xc0\xc2"
+ "\xde\x00\x02\xc0\xc2\xc3\xc2"
+ "\xdf\x00\x00\x00\x00"
+ "\xdf\x00\x00\x00\x01\xc0\xc2"
+ "\xdf\x00\x00\x00\x02\xc0\xc2\xc3\xc2",
+ [{}, {None: False}, {True: False, None: False}, {},
+ {None: False}, {True: False, None: False}])
+
+if __name__ == '__main__':
+ main()
diff --git a/python/test/test_pack.py b/python/test/test_pack.py
new file mode 100644
index 0000000..86badb5
--- /dev/null
+++ b/python/test/test_pack.py
@@ -0,0 +1,28 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+from nose import main
+from nose.tools import *
+
+from msgpack import packs, unpacks
+
+def check(data):
+ re = unpacks(packs(data))
+ assert_equal(re, data)
+
+def testPack():
+ test_data = [
+ 0, 1, 127, 128, 255, 256, 65535, 65536,
+ -1, -32, -33, -128, -129, -32768, -32769,
+ 1.0,
+ "", "a", "a"*31, "a"*32,
+ None, True, False,
+ [], [[]], [[], None],
+ {None: 0},
+ (1<<23),
+ ]
+ for td in test_data:
+ check(td)
+
+if __name__ == '__main__':
+ main()
diff --git a/python/test/test_sequnpack.py b/python/test/test_sequnpack.py
new file mode 100644
index 0000000..789ccd2
--- /dev/null
+++ b/python/test/test_sequnpack.py
@@ -0,0 +1,36 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+from __future__ import unicode_literals, print_function
+
+from msgpack import Unpacker
+
+def test_foobar():
+ unpacker = Unpacker(read_size=3)
+ unpacker.feed(b'foobar')
+ assert unpacker.unpack() == ord('f')
+ assert unpacker.unpack() == ord('o')
+ assert unpacker.unpack() == ord('o')
+ assert unpacker.unpack() == ord('b')
+ assert unpacker.unpack() == ord('a')
+ assert unpacker.unpack() == ord('r')
+ try:
+ o = unpacker.unpack()
+ print("Oops!", o)
+ assert 0
+ except StopIteration:
+ assert 1
+ else:
+ assert 0
+ unpacker.feed(b'foo')
+ unpacker.feed(b'bar')
+
+ k = 0
+ for o, e in zip(unpacker, b'foobarbaz'):
+ assert o == ord(e)
+ k += 1
+ assert k == len(b'foobar')
+
+if __name__ == '__main__':
+ test_foobar()
+
View Lorry Controller Status