msgpack 0.6.0-x86-mswin32-60

data/ext/msgpack/buffer_class.h

@@ -0,0 +1,32 @@
+/*
+ * 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_BUFFER_CLASS_H__
+#define MSGPACK_RUBY_BUFFER_CLASS_H__
+
+#include "buffer.h"
+
+extern VALUE cMessagePack_Buffer;
+
+void MessagePack_Buffer_module_init(VALUE mMessagePack);
+
+VALUE MessagePack_Buffer_wrap(msgpack_buffer_t* b, VALUE owner);
+
+void MessagePack_Buffer_initialize(msgpack_buffer_t* b, VALUE io, VALUE options);
+
+#endif
+

data/ext/msgpack/compat.h

@@ -0,0 +1,114 @@
+/*
+ * 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_COMPAT_H__
+#define MSGPACK_RUBY_COMPAT_H__
+
+#include <stdbool.h>
+#include "ruby.h"
+
+#if defined(HAVE_RUBY_ST_H)
+#  include "ruby/st.h"  /* ruby hash on Ruby 1.9 */
+#elif defined(HAVE_ST_H)
+#  include "st.h"       /* ruby hash on Ruby 1.8 */
+#endif
+
+
+/*
+ * COMPAT_HAVE_ENCODING
+ */
+#ifdef HAVE_RUBY_ENCODING_H
+#  include "ruby/encoding.h"
+#  define COMPAT_HAVE_ENCODING
+#endif
+
+#if defined(__MACRUBY__)  /* MacRuby */
+#  undef COMPAT_HAVE_ENCODING
+#endif
+
+
+/*
+ * define STR_DUP_LIKELY_DOES_COPY
+ * check rb_str_dup actually copies the string or not
+ */
+#if defined(RUBY_VM) && defined(FL_ALL) && defined(FL_USER1) && defined(FL_USER3)  /* MRI 1.9 */
+#  define STR_DUP_LIKELY_DOES_COPY(str) FL_ALL(str, FL_USER1|FL_USER3)  /* same as STR_ASSOC_P(str) */
+
+#elif defined(FL_TEST) && defined(ELTS_SHARED)  /* MRI 1.8 */
+#  define STR_DUP_LIKELY_DOES_COPY(str) (!FL_TEST(str, ELTS_SHARED))
+
+//#elif defined(RUBINIUS) || defined(JRUBY)  /* Rubinius and JRuby */
+#else
+#  define STR_DUP_LIKELY_DOES_COPY(str) (1)
+
+#endif
+
+
+/*
+ * SIZET2NUM
+ */
+#ifndef SIZET2NUM   /* MRI 1.8 */
+#  define SIZET2NUM(v) ULL2NUM(v)
+#endif
+
+
+/*
+ * rb_errinfo()
+ */
+#if defined(RUBY_VM)  /* MRI 1.9 */
+#  define COMPAT_RERAISE rb_exc_raise(rb_errinfo())
+
+#elif defined(JRUBY)  /* JRuby */
+#  define COMPAT_RERAISE rb_exc_raise(rb_gv_get("$!"))
+
+#else  /* MRI 1.8 and Rubinius */
+#  define COMPAT_RERAISE rb_exc_raise(ruby_errinfo)
+#endif
+
+
+/*
+ * RBIGNUM_POSITIVE_P
+ */
+#ifndef RBIGNUM_POSITIVE_P
+#  if defined(RUBINIUS)  /* Rubinius <= v1.2.3 */
+#    define RBIGNUM_POSITIVE_P(b) (rb_funcall(b, rb_intern(">="), 1, INT2FIX(0)) == Qtrue)
+
+#  elif defined(JRUBY)  /* JRuby */
+#    define RBIGNUM_POSITIVE_P(b) (rb_funcall(b, rb_intern(">="), 1, INT2FIX(0)) == Qtrue)
+#    define rb_big2ull(b) rb_num2ull(b)
+     /*#define rb_big2ll(b) rb_num2ll(b)*/
+
+#  else  /* MRI 1.8 */
+#    define RBIGNUM_POSITIVE_P(b) (RBIGNUM(b)->sign)
+#  endif
+#endif
+
+
+/*
+ * RSTRING_PTR, RSTRING_LEN
+ */
+#ifndef RSTRING_PTR  /* MRI 1.8.5 */
+#  define RSTRING_PTR(s) (RSTRING(s)->ptr)
+#endif
+
+#ifndef RSTRING_LEN  /* MRI 1.8.5 */
+#  define RSTRING_LEN(s) (RSTRING(s)->len)
+#endif
+
+
+#endif
+

data/ext/msgpack/core_ext.c

@@ -0,0 +1,129 @@
+/*
+ * 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 "core_ext.h"
+#include "packer.h"
+#include "packer_class.h"
+
+static inline VALUE delegete_to_pack(int argc, VALUE* argv, VALUE self)
+{
+    if(argc == 0) {
+        return MessagePack_pack(1, &self);
+    } else if(argc == 1) {
+        /* write to io */
+        VALUE argv2[2];
+        argv2[0] = self;
+        argv2[1] = argv[0];
+        return MessagePack_pack(2, argv2);
+    } else {
+        rb_raise(rb_eArgError, "wrong number of arguments (%d for 0..1)", argc);
+    }
+}
+
+#define ENSURE_PACKER(argc, argv, packer, pk) \
+    if(argc != 1 || rb_class_of(argv[0]) != cMessagePack_Packer) { \
+        return delegete_to_pack(argc, argv, self); \
+    } \
+    VALUE packer = argv[0]; \
+    msgpack_packer_t *pk; \
+    Data_Get_Struct(packer, msgpack_packer_t, pk);
+
+static VALUE NilClass_to_msgpack(int argc, VALUE* argv, VALUE self)
+{
+    ENSURE_PACKER(argc, argv, packer, pk);
+    msgpack_packer_write_nil(pk);
+    return packer;
+}
+
+static VALUE TrueClass_to_msgpack(int argc, VALUE* argv, VALUE self)
+{
+    ENSURE_PACKER(argc, argv, packer, pk);
+    msgpack_packer_write_true(pk);
+    return packer;
+}
+
+static VALUE FalseClass_to_msgpack(int argc, VALUE* argv, VALUE self)
+{
+    ENSURE_PACKER(argc, argv, packer, pk);
+    msgpack_packer_write_false(pk);
+    return packer;
+}
+
+static VALUE Fixnum_to_msgpack(int argc, VALUE* argv, VALUE self)
+{
+    ENSURE_PACKER(argc, argv, packer, pk);
+    msgpack_packer_write_fixnum_value(pk, self);
+    return packer;
+}
+
+static VALUE Bignum_to_msgpack(int argc, VALUE* argv, VALUE self)
+{
+    ENSURE_PACKER(argc, argv, packer, pk);
+    msgpack_packer_write_bignum_value(pk, self);
+    return packer;
+}
+
+static VALUE Float_to_msgpack(int argc, VALUE* argv, VALUE self)
+{
+    ENSURE_PACKER(argc, argv, packer, pk);
+    msgpack_packer_write_float_value(pk, self);
+    return packer;
+}
+
+static VALUE String_to_msgpack(int argc, VALUE* argv, VALUE self)
+{
+    ENSURE_PACKER(argc, argv, packer, pk);
+    msgpack_packer_write_string_value(pk, self);
+    return packer;
+}
+
+static VALUE Array_to_msgpack(int argc, VALUE* argv, VALUE self)
+{
+    ENSURE_PACKER(argc, argv, packer, pk);
+    msgpack_packer_write_array_value(pk, self);
+    return packer;
+}
+
+static VALUE Hash_to_msgpack(int argc, VALUE* argv, VALUE self)
+{
+    ENSURE_PACKER(argc, argv, packer, pk);
+    msgpack_packer_write_hash_value(pk, self);
+    return packer;
+}
+
+static VALUE Symbol_to_msgpack(int argc, VALUE* argv, VALUE self)
+{
+    ENSURE_PACKER(argc, argv, packer, pk);
+    msgpack_packer_write_symbol_value(pk, self);
+    return packer;
+}
+
+void MessagePack_core_ext_module_init()
+{
+    rb_define_method(rb_cNilClass,   "to_msgpack", NilClass_to_msgpack, -1);
+    rb_define_method(rb_cTrueClass,  "to_msgpack", TrueClass_to_msgpack, -1);
+    rb_define_method(rb_cFalseClass, "to_msgpack", FalseClass_to_msgpack, -1);
+    rb_define_method(rb_cFixnum, "to_msgpack", Fixnum_to_msgpack, -1);
+    rb_define_method(rb_cBignum, "to_msgpack", Bignum_to_msgpack, -1);
+    rb_define_method(rb_cFloat,  "to_msgpack", Float_to_msgpack, -1);
+    rb_define_method(rb_cString, "to_msgpack", String_to_msgpack, -1);
+    rb_define_method(rb_cArray,  "to_msgpack", Array_to_msgpack, -1);
+    rb_define_method(rb_cHash,   "to_msgpack", Hash_to_msgpack, -1);
+    rb_define_method(rb_cSymbol, "to_msgpack", Symbol_to_msgpack, -1);
+}
+

data/ext/msgpack/core_ext.h

@@ -0,0 +1,26 @@
+/*
+ * 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_CORE_EXT_H__
+#define MSGPACK_RUBY_CORE_EXT_H__
+
+#include "compat.h"
+
+void MessagePack_core_ext_module_init();
+
+#endif
+

data/ext/msgpack/extconf.rb

@@ -0,0 +1,30 @@
+require 'mkmf'
+
+have_header("ruby/st.h")
+have_header("st.h")
+have_func("rb_str_replace", ["ruby.h"])
+have_func("rb_intern_str", ["ruby.h"])
+have_func("rb_sym2str", ["ruby.h"])
+have_func("rb_str_intern", ["ruby.h"])
+
+unless RUBY_PLATFORM.include? 'mswin'
+  $CFLAGS << %[ -I.. -Wall -O3 -g -std=c99]
+end
+#$CFLAGS << %[ -DDISABLE_RMEM]
+#$CFLAGS << %[ -DDISABLE_RMEM_REUSE_INTERNAL_FRAGMENT]
+#$CFLAGS << %[ -DDISABLE_BUFFER_READ_REFERENCE_OPTIMIZE]
+#$CFLAGS << %[ -DDISABLE_BUFFER_READ_TO_S_OPTIMIZE]
+
+if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
+  # msgpack-ruby doesn't modify data came from RSTRING_PTR(str)
+  $CFLAGS << %[ -DRSTRING_NOT_MODIFIED]
+  # Rubinius C extensions don't grab GVL while rmem is not thread safe
+  $CFLAGS << %[ -DDISABLE_RMEM]
+end
+
+if warnflags = CONFIG['warnflags']
+  warnflags.slice!(/ -Wdeclaration-after-statement/)
+end
+
+create_makefile('msgpack/msgpack')
+

data/ext/msgpack/packer.c

@@ -0,0 +1,168 @@
+/*
+ * 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 "packer.h"
+
+#ifdef RUBINIUS
+static ID s_to_iter;
+static ID s_next;
+static ID s_key;
+static ID s_value;
+#endif
+
+void msgpack_packer_static_init()
+{
+#ifdef RUBINIUS
+    s_to_iter = rb_intern("to_iter");
+    s_next = rb_intern("next");
+    s_key = rb_intern("key");
+    s_value = rb_intern("value");
+#endif
+}
+
+void msgpack_packer_static_destroy()
+{ }
+
+void msgpack_packer_init(msgpack_packer_t* pk)
+{
+    memset(pk, 0, sizeof(msgpack_packer_t));
+
+    msgpack_buffer_init(PACKER_BUFFER_(pk));
+
+    pk->io = Qnil;
+}
+
+void msgpack_packer_destroy(msgpack_packer_t* pk)
+{
+    msgpack_buffer_destroy(PACKER_BUFFER_(pk));
+}
+
+void msgpack_packer_mark(msgpack_packer_t* pk)
+{
+    rb_gc_mark(pk->io);
+
+    /* See MessagePack_Buffer_wrap */
+    /* msgpack_buffer_mark(PACKER_BUFFER_(pk)); */
+    rb_gc_mark(pk->buffer_ref);
+}
+
+void msgpack_packer_reset(msgpack_packer_t* pk)
+{
+    msgpack_buffer_clear(PACKER_BUFFER_(pk));
+
+    pk->io = Qnil;
+    pk->io_write_all_method = 0;
+    pk->buffer_ref = Qnil;
+}
+
+
+void msgpack_packer_write_array_value(msgpack_packer_t* pk, VALUE v)
+{
+    /* actual return type of RARRAY_LEN is long */
+    unsigned long len = RARRAY_LEN(v);
+    if(len > 0xffffffffUL) {
+        rb_raise(rb_eArgError, "size of array is too long to pack: %lu bytes should be <= %lu", len, 0xffffffffUL);
+    }
+    unsigned int len32 = (unsigned int)len;
+    msgpack_packer_write_array_header(pk, len32);
+
+    unsigned int i;
+    for(i=0; i < len32; ++i) {
+        VALUE e = rb_ary_entry(v, i);
+        msgpack_packer_write_value(pk, e);
+    }
+}
+
+static int write_hash_foreach(VALUE key, VALUE value, VALUE pk_value)
+{
+    if (key == Qundef) {
+        return ST_CONTINUE;
+    }
+    msgpack_packer_t* pk = (msgpack_packer_t*) pk_value;
+    msgpack_packer_write_value(pk, key);
+    msgpack_packer_write_value(pk, value);
+    return ST_CONTINUE;
+}
+
+void msgpack_packer_write_hash_value(msgpack_packer_t* pk, VALUE v)
+{
+    /* actual return type of RHASH_SIZE is long (if SIZEOF_LONG == SIZEOF_VOIDP
+     * or long long (if SIZEOF_LONG_LONG == SIZEOF_VOIDP. See st.h. */
+    unsigned long len = RHASH_SIZE(v);
+    if(len > 0xffffffffUL) {
+        rb_raise(rb_eArgError, "size of array is too long to pack: %ld bytes should be <= %lu", len, 0xffffffffUL);
+    }
+    unsigned int len32 = (unsigned int)len;
+    msgpack_packer_write_map_header(pk, len32);
+
+#ifdef RUBINIUS
+    VALUE iter = rb_funcall(v, s_to_iter, 0);
+    VALUE entry = Qnil;
+    while(RTEST(entry = rb_funcall(iter, s_next, 1, entry))) {
+        VALUE key = rb_funcall(entry, s_key, 0);
+        VALUE val = rb_funcall(entry, s_value, 0);
+        write_hash_foreach(key, val, (VALUE) pk);
+    }
+#else
+    rb_hash_foreach(v, write_hash_foreach, (VALUE) pk);
+#endif
+}
+
+static void _msgpack_packer_write_other_value(msgpack_packer_t* pk, VALUE v)
+{
+    rb_funcall(v, pk->to_msgpack_method, 1, pk->to_msgpack_arg);
+}
+
+void msgpack_packer_write_value(msgpack_packer_t* pk, VALUE v)
+{
+    switch(rb_type(v)) {
+    case T_NIL:
+        msgpack_packer_write_nil(pk);
+        break;
+    case T_TRUE:
+        msgpack_packer_write_true(pk);
+        break;
+    case T_FALSE:
+        msgpack_packer_write_false(pk);
+        break;
+    case T_FIXNUM:
+        msgpack_packer_write_fixnum_value(pk, v);
+        break;
+    case T_SYMBOL:
+        msgpack_packer_write_symbol_value(pk, v);
+        break;
+    case T_STRING:
+        msgpack_packer_write_string_value(pk, v);
+        break;
+    case T_ARRAY:
+        msgpack_packer_write_array_value(pk, v);
+        break;
+    case T_HASH:
+        msgpack_packer_write_hash_value(pk, v);
+        break;
+    case T_BIGNUM:
+        msgpack_packer_write_bignum_value(pk, v);
+        break;
+    case T_FLOAT:
+        msgpack_packer_write_float_value(pk, v);
+        break;
+    default:
+        _msgpack_packer_write_other_value(pk, v);
+    }
+}
+