gitlab-cbor 1.0.0

data/ext/cbor/packer_class.h

@@ -0,0 +1,40 @@
+/*
+ * CBOR for Ruby
+ *
+ * Copyright (C) 2013 Carsten Bormann
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License").
+ *
+ * Based on:
+ ***********/
+/*
+ * 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;
+
+msgpack_packer_t* MessagePack_Packer_get(VALUE self);
+
+void MessagePack_Packer_module_init(VALUE mMessagePack);
+
+VALUE MessagePack_pack(int argc, VALUE* argv);
+
+#endif

data/ext/cbor/rbinit.c

@@ -0,0 +1,57 @@
+/*
+ * CBOR for Ruby
+ *
+ * Copyright (C) 2013 Carsten Bormann
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License").
+ *
+ * Based on:
+ ***********/
+/*
+ * 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"
+
+
+VALUE rb_cCBOR_Tagged;
+VALUE rb_cCBOR_Simple;
+
+void Init_cbor(void)
+{
+    VALUE mMessagePack = rb_define_module("CBOR");
+
+    rb_cCBOR_Tagged = rb_struct_define(NULL, "tag", "value", NULL);
+    rb_define_const(mMessagePack, "Tagged", rb_cCBOR_Tagged);
+    rb_cCBOR_Simple = rb_struct_define(NULL, "value", NULL);
+    rb_define_const(mMessagePack, "Simple", rb_cCBOR_Simple);
+
+    /* CBOR tag numbers accepted by the decode option reconstruct_from_tags:,
+       so callers can write reconstruct_from_tags: [CBOR::TAG_REGEXP] instead of
+       a bare integer. */
+    rb_define_const(mMessagePack, "TAG_URI", INT2FIX(TAG_URI));
+    rb_define_const(mMessagePack, "TAG_REGEXP", INT2FIX(TAG_RE));
+
+    MessagePack_Buffer_module_init(mMessagePack);
+    MessagePack_Packer_module_init(mMessagePack);
+    MessagePack_Unpacker_module_init(mMessagePack);
+    MessagePack_core_ext_module_init();
+}
+

data/ext/cbor/renamer.h

@@ -0,0 +1,56 @@
+#define MessagePack_Buffer_initialize CBOR_Buffer_initialize
+#define MessagePack_Buffer_module_init CBOR_Buffer_module_init
+#define MessagePack_Buffer_wrap CBOR_Buffer_wrap
+#define MessagePack_Packer_module_init CBOR_Packer_module_init
+#define MessagePack_Unpacker_module_init CBOR_Unpacker_module_init
+#define MessagePack_core_ext_module_init CBOR_core_ext_module_init
+#define MessagePack_pack CBOR_pack
+#define MessagePack_unpack CBOR_unpack
+#define _msgpack_buffer_append_long_string _CBOR_buffer_append_long_string
+#define _msgpack_buffer_expand _CBOR_buffer_expand
+#define _msgpack_buffer_feed_from_io _CBOR_buffer_feed_from_io
+#define _msgpack_buffer_read_all2 _CBOR_buffer_read_all2
+#define _msgpack_buffer_read_from_io_to_string _CBOR_buffer_read_from_io_to_string
+#define _msgpack_buffer_shift_chunk _CBOR_buffer_shift_chunk
+#define _msgpack_buffer_skip_from_io _CBOR_buffer_skip_from_io
+#define _msgpack_rmem_alloc2 _CBOR_rmem_alloc2
+#define _msgpack_rmem_chunk_free _CBOR_rmem_chunk_free
+#define cMessagePack_Buffer cCBOR_Buffer
+#define cMessagePack_Packer cCBOR_Packer
+#define cMessagePack_Unpacker cCBOR_Unpacker
+#define msgpack_buffer_all_as_string CBOR_buffer_all_as_string
+#define msgpack_buffer_all_as_string_array CBOR_buffer_all_as_string_array
+#define msgpack_buffer_all_readable_size CBOR_buffer_all_readable_size
+#define msgpack_buffer_clear CBOR_buffer_clear
+#define msgpack_buffer_destroy CBOR_buffer_destroy
+#define msgpack_buffer_flush_to_io CBOR_buffer_flush_to_io
+#define msgpack_buffer_init CBOR_buffer_init
+#define msgpack_buffer_mark CBOR_buffer_mark
+#define msgpack_buffer_read_nonblock CBOR_buffer_read_nonblock
+#define msgpack_buffer_read_to_string_nonblock CBOR_buffer_read_to_string_nonblock
+#define msgpack_buffer_static_destroy CBOR_buffer_static_destroy
+#define msgpack_buffer_static_init CBOR_buffer_static_init
+#define msgpack_packer_destroy CBOR_packer_destroy
+#define msgpack_packer_init CBOR_packer_init
+#define msgpack_packer_mark CBOR_packer_mark
+#define msgpack_packer_reset CBOR_packer_reset
+#define msgpack_packer_static_destroy CBOR_packer_static_destroy
+#define msgpack_packer_static_init CBOR_packer_static_init
+#define msgpack_packer_write_array_value CBOR_packer_write_array_value
+#define msgpack_packer_write_hash_value CBOR_packer_write_hash_value
+#define msgpack_packer_write_value CBOR_packer_write_value
+#define msgpack_rmem_destroy CBOR_rmem_destroy
+#define msgpack_rmem_init CBOR_rmem_init
+#define msgpack_unpacker_destroy CBOR_unpacker_destroy
+#define msgpack_unpacker_init CBOR_unpacker_init
+#define msgpack_unpacker_mark CBOR_unpacker_mark
+#define msgpack_unpacker_peek_next_object_type CBOR_unpacker_peek_next_object_type
+#define msgpack_unpacker_read CBOR_unpacker_read
+#define msgpack_unpacker_read_array_header CBOR_unpacker_read_array_header
+#define msgpack_unpacker_read_container_header CBOR_unpacker_read_container_header
+#define msgpack_unpacker_read_map_header CBOR_unpacker_read_map_header
+#define msgpack_unpacker_reset CBOR_unpacker_reset
+#define msgpack_unpacker_skip CBOR_unpacker_skip
+#define msgpack_unpacker_skip_nil CBOR_unpacker_skip_nil
+#define msgpack_unpacker_static_destroy CBOR_unpacker_static_destroy
+#define msgpack_unpacker_static_init CBOR_unpacker_static_init

data/ext/cbor/rmem.c

@@ -0,0 +1,103 @@
+/*
+ * CBOR for Ruby
+ *
+ * Copyright (C) 2013 Carsten Bormann
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License").
+ *
+ * Based on:
+ ***********/
+/*
+ * 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/cbor/rmem.h

@@ -0,0 +1,118 @@
+/*
+ * CBOR for Ruby
+ *
+ * Copyright (C) 2013 Carsten Bormann
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License").
+ *
+ * Based on:
+ ***********/
+/*
+ * 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/cbor/sysdep.h

@@ -0,0 +1,139 @@
+/*
+ * CBOR for Ruby
+ *
+ * Copyright (C) 2013 Carsten Bormann
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License").
+ *
+ * Based on:
+ ***********/
+/*
+ * 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 "renamer.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) & 0x0000ff00U ) | \
+        ((((uint16_t)x) >>  8) & 0x000000ffU ) )
+#  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
+
+#ifndef HAVE_RB_INTEGER_UNPACK
+
+#if SIZEOF_BDIGITS == 2
+#define NTOHBDIGIT _msgpack_be16
+#elif SIZEOF_BDIGITS == 4
+#define NTOHBDIGIT _msgpack_be32
+#elif SIZEOF_BDIGITS == 8
+#define NTOHBDIGIT _msgpack_be64
+#else
+#error this size of bignum digits SIZEOF_BDIGITS not implemented
+#endif
+
+#endif
+
+#endif
+

data/ext/cbor/sysdep_endian.h

@@ -0,0 +1,59 @@
+/*
+ * CBOR for Ruby
+ *
+ * Copyright (C) 2013 Carsten Bormann
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License").
+ *
+ * Based on:
+ ***********/
+/*
+ * 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_ENDIAN_H__
+#define MSGPACK_RUBY_SYSDEP_ENDIAN_H__
+
+/* including arpa/inet.h requires an extra dll on win32 */
+#ifndef _WIN32
+#include <arpa/inet.h>  /* __BYTE_ORDER */
+#endif
+
+/*
+ * Use following command to add consitions here:
+ *   cpp -dM `echo "#include <arpa/inet.h>" > test.c; echo test.c` | grep ENDIAN
+ */
+#if !defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__)  /* Mac OS X */
+#  if defined(_LITTLE_ENDIAN) \
+        || ( defined(__BYTE_ORDER) && defined(__LITTLE_ENDIAN) \
+                && __BYTE_ORDER == __LITTLE_ENDIAN ) /* Linux */ \
+        || ( defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) \
+                && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ ) /* Solaris */
+#    define __LITTLE_ENDIAN__
+#  elif defined(_BIG_ENDIAN) \
+        || (defined(__BYTE_ORDER) && defined(__BIG_ENDIAN) \
+                && __BYTE_ORDER == __BIG_ENDIAN) /* Linux */ \
+        || (defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) \
+                && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) /* Solaris */
+#    define __BIG_ENDIAN__
+#  elif defined(_WIN32)  /* Win32 */
+#    define __LITTLE_ENDIAN__
+#  endif
+#endif
+
+
+#endif
+

data/ext/cbor/sysdep_types.h

@@ -0,0 +1,55 @@
+/*
+ * CBOR for Ruby
+ *
+ * Copyright (C) 2013 Carsten Bormann
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License").
+ *
+ * Based on:
+ ***********/
+/*
+ * 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_TYPES_H__
+#define MSGPACK_RUBY_SYSDEP_TYPES_H__
+
+#include <string.h>
+#include <stdlib.h>
+
+#include <stddef.h>
+
+#if defined(_MSC_VER) && _MSC_VER < 1600
+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;
+
+#elif defined(_MSC_VER)  // && _MSC_VER >= 1600
+#include <stdint.h>
+
+#else
+#include <stdint.h>
+#include <stdbool.h>
+#endif
+
+
+#endif
+