msgpack 0.6.0pre1-x64-mingw32

data/ext/msgpack/packer_class.c

@@ -0,0 +1,302 @@
+/*
+ * MessagePack for Ruby
+ *
+ * Copyright (C) 2008-2013 Sadayuki Furuhashi
+ *
+ *    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 "compat.h"
+#include "ruby.h"
+#include "packer.h"
+#include "packer_class.h"
+#include "buffer_class.h"
+
+VALUE cMessagePack_Packer;
+
+static ID s_to_msgpack;
+static ID s_write;
+
+//static VALUE s_packer_value;
+//static msgpack_packer_t* s_packer;
+
+#define PACKER(from, name) \
+    msgpack_packer_t* name; \
+    Data_Get_Struct(from, msgpack_packer_t, name); \
+    if(name == NULL) { \
+        rb_raise(rb_eArgError, "NULL found for " # name " when shouldn't be."); \
+    }
+
+static void Packer_free(msgpack_packer_t* pk)
+{
+    if(pk == NULL) {
+        return;
+    }
+    msgpack_packer_destroy(pk);
+    free(pk);
+}
+
+static VALUE Packer_alloc(VALUE klass)
+{
+    msgpack_packer_t* pk = ALLOC_N(msgpack_packer_t, 1);
+    msgpack_packer_init(pk);
+
+    VALUE self = Data_Wrap_Struct(klass, msgpack_packer_mark, Packer_free, pk);
+
+    msgpack_packer_set_to_msgpack_method(pk, s_to_msgpack, self);
+    pk->buffer_ref = MessagePack_Buffer_wrap(PACKER_BUFFER_(pk), self);
+
+    return self;
+}
+
+static VALUE Packer_initialize(int argc, VALUE* argv, VALUE self)
+{
+    VALUE io = Qnil;
+    VALUE options = Qnil;
+
+    if(argc == 0 || (argc == 1 && argv[0] == Qnil)) {
+        /* Qnil */
+
+    } else if(argc == 1) {
+        VALUE v = argv[0];
+        if(rb_type(v) == T_HASH) {
+            options = v;
+        } else {
+            io = v;
+        }
+
+    } else if(argc == 2) {
+        io = argv[0];
+        options = argv[1];
+        if(rb_type(options) != T_HASH) {
+            rb_raise(rb_eArgError, "expected Hash but found %s.", rb_obj_classname(options));
+        }
+
+    } else {
+        rb_raise(rb_eArgError, "wrong number of arguments (%d for 0..2)", argc);
+    }
+
+    PACKER(self, pk);
+    MessagePack_Buffer_initialize(PACKER_BUFFER_(pk), io, options);
+
+    // TODO MessagePack_Unpacker_initialize and options
+
+    return self;
+}
+
+static VALUE Packer_buffer(VALUE self)
+{
+    PACKER(self, pk);
+    return pk->buffer_ref;
+}
+
+static VALUE Packer_write(VALUE self, VALUE v)
+{
+    PACKER(self, pk);
+    msgpack_packer_write_value(pk, v);
+    return self;
+}
+
+static VALUE Packer_write_nil(VALUE self)
+{
+    PACKER(self, pk);
+    msgpack_packer_write_nil(pk);
+    return self;
+}
+
+static VALUE Packer_write_array_header(VALUE self, VALUE n)
+{
+    PACKER(self, pk);
+    msgpack_packer_write_array_header(pk, NUM2UINT(n));
+    return self;
+}
+
+static VALUE Packer_write_map_header(VALUE self, VALUE n)
+{
+    PACKER(self, pk);
+    msgpack_packer_write_map_header(pk, NUM2UINT(n));
+    return self;
+}
+
+static VALUE Packer_flush(VALUE self)
+{
+    PACKER(self, pk);
+    msgpack_buffer_flush(PACKER_BUFFER_(pk));
+    return self;
+}
+
+static VALUE Packer_clear(VALUE self)
+{
+    PACKER(self, pk);
+    msgpack_buffer_clear(PACKER_BUFFER_(pk));
+    return Qnil;
+}
+
+static VALUE Packer_size(VALUE self)
+{
+    PACKER(self, pk);
+    size_t size = msgpack_buffer_all_readable_size(PACKER_BUFFER_(pk));
+    return SIZET2NUM(size);
+}
+
+static VALUE Packer_empty_p(VALUE self)
+{
+    PACKER(self, pk);
+    if(msgpack_buffer_top_readable_size(PACKER_BUFFER_(pk)) == 0) {
+        return Qtrue;
+    } else {
+        return Qfalse;
+    }
+}
+
+static VALUE Packer_to_str(VALUE self)
+{
+    PACKER(self, pk);
+    return msgpack_buffer_all_as_string(PACKER_BUFFER_(pk));
+}
+
+static VALUE Packer_to_a(VALUE self)
+{
+    PACKER(self, pk);
+    return msgpack_buffer_all_as_string_array(PACKER_BUFFER_(pk));
+}
+
+static VALUE Packer_write_to(VALUE self, VALUE io)
+{
+    PACKER(self, pk);
+    size_t sz = msgpack_buffer_flush_to_io(PACKER_BUFFER_(pk), io, s_write, true);
+    return ULONG2NUM(sz);
+}
+
+//static VALUE Packer_append(VALUE self, VALUE string_or_buffer)
+//{
+//    PACKER(self, pk);
+//
+//    // TODO if string_or_buffer is a Buffer
+//    VALUE string = string_or_buffer;
+//
+//    msgpack_buffer_append_string(PACKER_BUFFER_(pk), string);
+//
+//    return self;
+//}
+
+VALUE MessagePack_pack(int argc, VALUE* argv)
+{
+    VALUE v;
+    VALUE io = Qnil;
+    VALUE options = Qnil;
+
+    if(argc == 1) {
+        v = argv[0];
+
+    } else if(argc == 2) {
+        v = argv[0];
+        if(rb_type(argv[1]) == T_HASH) {
+            options = argv[1];
+        } else {
+            io = argv[1];
+        }
+
+    } else if(argc == 3) {
+        v = argv[0];
+        io = argv[1];
+        options = argv[2];
+        if(rb_type(options) != T_HASH) {
+            rb_raise(rb_eArgError, "expected Hash but found %s.", rb_obj_classname(options));
+        }
+
+    } else {
+        rb_raise(rb_eArgError, "wrong number of arguments (%d for 1..3)", argc);
+    }
+
+    VALUE self = Packer_alloc(cMessagePack_Packer);
+    PACKER(self, pk);
+    //msgpack_packer_reset(s_packer);
+    //msgpack_buffer_reset_io(PACKER_BUFFER_(s_packer));
+
+    MessagePack_Buffer_initialize(PACKER_BUFFER_(pk), io, options);
+    // TODO MessagePack_Unpacker_initialize and options
+
+    msgpack_packer_write_value(pk, v);
+
+    VALUE retval;
+    if(io != Qnil) {
+        msgpack_buffer_flush(PACKER_BUFFER_(pk));
+        retval = Qnil;
+    } else {
+        retval = msgpack_buffer_all_as_string(PACKER_BUFFER_(pk));
+    }
+
+    msgpack_buffer_clear(PACKER_BUFFER_(pk)); /* to free rmem before GC */
+
+#ifdef RB_GC_GUARD
+    /* This prevents compilers from optimizing out the `self` variable
+     * from stack. Otherwise GC free()s it. */
+    RB_GC_GUARD(self);
+#endif
+
+    return retval;
+}
+
+static VALUE MessagePack_dump_module_method(int argc, VALUE* argv, VALUE mod)
+{
+    UNUSED(mod);
+    return MessagePack_pack(argc, argv);
+}
+
+static VALUE MessagePack_pack_module_method(int argc, VALUE* argv, VALUE mod)
+{
+    UNUSED(mod);
+    return MessagePack_pack(argc, argv);
+}
+
+void MessagePack_Packer_module_init(VALUE mMessagePack)
+{
+    s_to_msgpack = rb_intern("to_msgpack");
+    s_write = rb_intern("write");
+
+    msgpack_packer_static_init();
+
+    cMessagePack_Packer = rb_define_class_under(mMessagePack, "Packer", rb_cObject);
+
+    rb_define_alloc_func(cMessagePack_Packer, Packer_alloc);
+
+    rb_define_method(cMessagePack_Packer, "initialize", Packer_initialize, -1);
+    rb_define_method(cMessagePack_Packer, "buffer", Packer_buffer, 0);
+    rb_define_method(cMessagePack_Packer, "write", Packer_write, 1);
+    rb_define_alias(cMessagePack_Packer, "pack", "write");
+    rb_define_method(cMessagePack_Packer, "write_nil", Packer_write_nil, 0);
+    rb_define_method(cMessagePack_Packer, "write_array_header", Packer_write_array_header, 1);
+    rb_define_method(cMessagePack_Packer, "write_map_header", Packer_write_map_header, 1);
+    rb_define_method(cMessagePack_Packer, "flush", Packer_flush, 0);
+
+    /* delegation methods */
+    rb_define_method(cMessagePack_Packer, "clear", Packer_clear, 0);
+    rb_define_method(cMessagePack_Packer, "size", Packer_size, 0);
+    rb_define_method(cMessagePack_Packer, "empty?", Packer_empty_p, 0);
+    rb_define_method(cMessagePack_Packer, "write_to", Packer_write_to, 1);
+    rb_define_method(cMessagePack_Packer, "to_str", Packer_to_str, 0);
+    rb_define_alias(cMessagePack_Packer, "to_s", "to_str");
+    rb_define_method(cMessagePack_Packer, "to_a", Packer_to_a, 0);
+    //rb_define_method(cMessagePack_Packer, "append", Packer_append, 1);
+    //rb_define_alias(cMessagePack_Packer, "<<", "append");
+
+    //s_packer_value = Packer_alloc(cMessagePack_Packer);
+    //rb_gc_register_address(&s_packer_value);
+    //Data_Get_Struct(s_packer_value, msgpack_packer_t, s_packer);
+
+    /* MessagePack.pack(x) */
+    rb_define_module_function(mMessagePack, "pack", MessagePack_pack_module_method, -1);
+    rb_define_module_function(mMessagePack, "dump", MessagePack_dump_module_method, -1);
+}
+

data/ext/msgpack/packer_class.h

@@ -0,0 +1,30 @@
+/*
+ * MessagePack for Ruby
+ *
+ * Copyright (C) 2008-2013 Sadayuki Furuhashi
+ *
+ *    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_RUBY_PACKER_CLASS_H__
+#define MSGPACK_RUBY_PACKER_CLASS_H__
+
+#include "packer.h"
+
+extern VALUE cMessagePack_Packer;
+
+void MessagePack_Packer_module_init(VALUE mMessagePack);
+
+VALUE MessagePack_pack(int argc, VALUE* argv);
+
+#endif
+

data/ext/msgpack/rbinit.c

@@ -0,0 +1,33 @@
+/*
+ * MessagePack for Ruby
+ *
+ * Copyright (C) 2008-2013 Sadayuki Furuhashi
+ *
+ *    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 "buffer_class.h"
+#include "packer_class.h"
+#include "unpacker_class.h"
+#include "core_ext.h"
+
+void Init_msgpack(void)
+{
+    VALUE mMessagePack = rb_define_module("MessagePack");
+
+    MessagePack_Buffer_module_init(mMessagePack);
+    MessagePack_Packer_module_init(mMessagePack);
+    MessagePack_Unpacker_module_init(mMessagePack);
+    MessagePack_core_ext_module_init();
+}
+

data/ext/msgpack/rmem.c

@@ -0,0 +1,94 @@
+/*
+ * MessagePack for Ruby
+ *
+ * Copyright (C) 2008-2013 Sadayuki Furuhashi
+ *
+ *    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 "rmem.h"
+
+void msgpack_rmem_init(msgpack_rmem_t* pm)
+{
+    memset(pm, 0, sizeof(msgpack_rmem_t));
+    pm->head.pages = malloc(MSGPACK_RMEM_PAGE_SIZE * 32);
+    pm->head.mask = 0xffffffff;  /* all bit is 1 = available */
+}
+
+void msgpack_rmem_destroy(msgpack_rmem_t* pm)
+{
+    msgpack_rmem_chunk_t* c = pm->array_first;
+    msgpack_rmem_chunk_t* cend = pm->array_last;
+    for(; c != cend; c++) {
+        free(c->pages);
+    }
+    free(pm->head.pages);
+    free(pm->array_first);
+}
+
+void* _msgpack_rmem_alloc2(msgpack_rmem_t* pm)
+{
+    msgpack_rmem_chunk_t* c = pm->array_first;
+    msgpack_rmem_chunk_t* last = pm->array_last;
+    for(; c != last; c++) {
+        if(_msgpack_rmem_chunk_available(c)) {
+            void* mem = _msgpack_rmem_chunk_alloc(c);
+
+            /* move to head */
+            msgpack_rmem_chunk_t tmp = pm->head;
+            pm->head = *c;
+            *c = tmp;
+            return mem;
+        }
+    }
+
+    if(c == pm->array_end) {
+        size_t capacity = c - pm->array_first;
+        size_t length = last - pm->array_first;
+        capacity = (capacity == 0) ? 8 : capacity * 2;
+        msgpack_rmem_chunk_t* array = realloc(pm->array_first, capacity * sizeof(msgpack_rmem_chunk_t));
+        pm->array_first = array;
+        pm->array_last = array + length;
+        pm->array_end = array + capacity;
+    }
+
+    /* allocate new chunk */
+    c = pm->array_last++;
+
+    /* move to head */
+    msgpack_rmem_chunk_t tmp = pm->head;
+    pm->head = *c;
+    *c = tmp;
+
+    pm->head.mask = 0xffffffff & (~1);  /* "& (~1)" means first chunk is already allocated */
+    pm->head.pages = malloc(MSGPACK_RMEM_PAGE_SIZE * 32);
+
+    return pm->head.pages;
+}
+
+void _msgpack_rmem_chunk_free(msgpack_rmem_t* pm, msgpack_rmem_chunk_t* c)
+{
+    if(pm->array_first->mask == 0xffffffff) {
+        /* free and move to last */
+        pm->array_last--;
+        free(c->pages);
+        *c = *pm->array_last;
+        return;
+    }
+
+    /* move to first */
+    msgpack_rmem_chunk_t tmp = *pm->array_first;
+    *pm->array_first = *c;
+    *c = tmp;
+}
+

data/ext/msgpack/rmem.h

@@ -0,0 +1,109 @@
+/*
+ * MessagePack for Ruby
+ *
+ * Copyright (C) 2008-2013 Sadayuki Furuhashi
+ *
+ *    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_RUBY_RMEM_H__
+#define MSGPACK_RUBY_RMEM_H__
+
+#include "compat.h"
+#include "sysdep.h"
+
+#ifndef MSGPACK_RMEM_PAGE_SIZE
+#define MSGPACK_RMEM_PAGE_SIZE (4*1024)
+#endif
+
+struct msgpack_rmem_t;
+typedef struct msgpack_rmem_t msgpack_rmem_t;
+
+struct msgpack_rmem_chunk_t;
+typedef struct msgpack_rmem_chunk_t msgpack_rmem_chunk_t;
+
+/*
+ * a chunk contains 32 pages.
+ * size of each buffer is MSGPACK_RMEM_PAGE_SIZE bytes.
+ */
+struct msgpack_rmem_chunk_t {
+    unsigned int mask;
+    char* pages;
+};
+
+struct msgpack_rmem_t {
+    msgpack_rmem_chunk_t head;
+    msgpack_rmem_chunk_t* array_first;
+    msgpack_rmem_chunk_t* array_last;
+    msgpack_rmem_chunk_t* array_end;
+};
+
+/* assert MSGPACK_RMEM_PAGE_SIZE % sysconf(_SC_PAGE_SIZE) == 0 */
+void msgpack_rmem_init(msgpack_rmem_t* pm);
+
+void msgpack_rmem_destroy(msgpack_rmem_t* pm);
+
+void* _msgpack_rmem_alloc2(msgpack_rmem_t* pm);
+
+#define _msgpack_rmem_chunk_available(c) ((c)->mask != 0)
+
+static inline void* _msgpack_rmem_chunk_alloc(msgpack_rmem_chunk_t* c)
+{
+    _msgpack_bsp32(pos, c->mask);
+    (c)->mask &= ~(1 << pos);
+    return ((char*)(c)->pages) + (pos * (MSGPACK_RMEM_PAGE_SIZE));
+}
+
+static inline bool _msgpack_rmem_chunk_try_free(msgpack_rmem_chunk_t* c, void* mem)
+{
+    ptrdiff_t pdiff = ((char*)(mem)) - ((char*)(c)->pages);
+    if(0 <= pdiff && pdiff < MSGPACK_RMEM_PAGE_SIZE * 32) {
+        size_t pos = pdiff / MSGPACK_RMEM_PAGE_SIZE;
+        (c)->mask |= (1 << pos);
+        return true;
+    }
+    return false;
+}
+
+static inline void* msgpack_rmem_alloc(msgpack_rmem_t* pm)
+{
+    if(_msgpack_rmem_chunk_available(&pm->head)) {
+        return _msgpack_rmem_chunk_alloc(&pm->head);
+    }
+    return _msgpack_rmem_alloc2(pm);
+}
+
+void _msgpack_rmem_chunk_free(msgpack_rmem_t* pm, msgpack_rmem_chunk_t* c);
+
+static inline bool msgpack_rmem_free(msgpack_rmem_t* pm, void* mem)
+{
+    if(_msgpack_rmem_chunk_try_free(&pm->head, mem)) {
+        return true;
+    }
+
+    /* search from last */
+    msgpack_rmem_chunk_t* c = pm->array_last - 1;
+    msgpack_rmem_chunk_t* before_first = pm->array_first - 1;
+    for(; c != before_first; c--) {
+        if(_msgpack_rmem_chunk_try_free(c, mem)) {
+            if(c != pm->array_first && c->mask == 0xffffffff) {
+                _msgpack_rmem_chunk_free(pm, c);
+            }
+            return true;
+        }
+    }
+    return false;
+}
+
+
+#endif
+

data/ext/msgpack/sysdep.h

@@ -0,0 +1,115 @@
+/*
+ * MessagePack for Ruby
+ *
+ * Copyright (C) 2008-2013 Sadayuki Furuhashi
+ *
+ *    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_RUBY_SYSDEP_H__
+#define MSGPACK_RUBY_SYSDEP_H__
+
+#include "sysdep_types.h"
+#include "sysdep_endian.h"
+
+
+#define UNUSED(var) ((void)var)
+
+
+#ifdef __LITTLE_ENDIAN__
+
+/* _msgpack_be16 */
+#ifdef _WIN32
+#  if defined(ntohs)
+#    define _msgpack_be16(x) ntohs(x)
+#  elif defined(_byteswap_ushort) || (defined(_MSC_VER) && _MSC_VER >= 1400)
+#    define _msgpack_be16(x) ((uint16_t)_byteswap_ushort((unsigned short)x))
+#  else
+#    define _msgpack_be16(x) ( \
+        ((((uint16_t)x) <<  8) ) | \
+        ((((uint16_t)x) >>  8) ) )
+#  endif
+#else
+#  define _msgpack_be16(x) ntohs(x)
+#endif
+
+/* _msgpack_be32 */
+#ifdef _WIN32
+#  if defined(ntohl)
+#    define _msgpack_be32(x) ntohl(x)
+#  elif defined(_byteswap_ulong) || (defined(_MSC_VER) && _MSC_VER >= 1400)
+#    define _msgpack_be32(x) ((uint32_t)_byteswap_ulong((unsigned long)x))
+#  else
+#    define _msgpack_be32(x) \
+        ( ((((uint32_t)x) << 24)               ) | \
+          ((((uint32_t)x) <<  8) & 0x00ff0000U ) | \
+          ((((uint32_t)x) >>  8) & 0x0000ff00U ) | \
+          ((((uint32_t)x) >> 24)               ) )
+#  endif
+#else
+#  define _msgpack_be32(x) ntohl(x)
+#endif
+
+/* _msgpack_be64 */
+#if defined(_byteswap_uint64) || (defined(_MSC_VER) && _MSC_VER >= 1400)
+#  define _msgpack_be64(x) (_byteswap_uint64(x))
+#elif defined(bswap_64)
+#  define _msgpack_be64(x) bswap_64(x)
+#elif defined(__DARWIN_OSSwapInt64)
+#  define _msgpack_be64(x) __DARWIN_OSSwapInt64(x)
+#else
+#define _msgpack_be64(x) \
+    ( ((((uint64_t)x) << 56)                         ) | \
+      ((((uint64_t)x) << 40) & 0x00ff000000000000ULL ) | \
+      ((((uint64_t)x) << 24) & 0x0000ff0000000000ULL ) | \
+      ((((uint64_t)x) <<  8) & 0x000000ff00000000ULL ) | \
+      ((((uint64_t)x) >>  8) & 0x00000000ff000000ULL ) | \
+      ((((uint64_t)x) >> 24) & 0x0000000000ff0000ULL ) | \
+      ((((uint64_t)x) >> 40) & 0x000000000000ff00ULL ) | \
+      ((((uint64_t)x) >> 56)                         ) )
+#endif
+
+#else  /* big endian */
+#define _msgpack_be16(x) (x)
+#define _msgpack_be32(x) (x)
+#define _msgpack_be64(x) (x)
+
+#endif
+
+
+/* _msgpack_be_float */
+#define _msgpack_be_float(x) _msgpack_be32(x)
+
+/* _msgpack_be_double */
+#if defined(__arm__) && !(__ARM_EABI__)
+/* ARM OABI */
+#define _msgpack_be_double(x) \
+    ( (((x) & 0xFFFFFFFFUL) << 32UL) | ((x) >> 32UL) )
+#else
+/* the other ABI */
+#define _msgpack_be_double(x) _msgpack_be64(x)
+#endif
+
+/* _msgpack_bsp32 */
+#if defined(_MSC_VER)
+#define _msgpack_bsp32(name, val) \
+    long name; \
+    _BitScanForward(&name, val)
+#else
+#define _msgpack_bsp32(name, val) \
+    int name = __builtin_ctz(val)
+/* TODO default impl for _msgpack_bsp32 */
+#endif
+
+
+#endif
+