msgpack 0.5.1-x86-mingw32 → 0.5.2-x86-mingw32

data/ChangeLog

@@ -1,4 +1,10 @@
 
+2012-02-07 version 0.5.2:
+
+* Fixed invalid pack/unpack on 32bit architecture such as Win32
+* Disable rmem on Rubinius because rmem is not thread safe
+
+
 2012-12-23 version 0.5.1:
 
 * Fixed compile error with Rubinius 2.0.0-dev

data/ext/msgpack/buffer.c

@@ -611,13 +611,13 @@ size_t msgpack_buffer_flush_to_io(msgpack_buffer_t* b, VALUE io, ID write_method
 size_t _msgpack_buffer_feed_from_io(msgpack_buffer_t* b)
 {
     if(b->io_buffer == Qnil) {
-        b->io_buffer = rb_funcall(b->io, b->io_partial_read_method, 1, LONG2FIX(b->io_buffer_size));
+        b->io_buffer = rb_funcall(b->io, b->io_partial_read_method, 1, LONG2NUM(b->io_buffer_size));
         if(b->io_buffer == Qnil) {
             rb_raise(rb_eEOFError, "IO reached end of file");
         }
         StringValue(b->io_buffer);
     } else {
-        VALUE ret = rb_funcall(b->io, b->io_partial_read_method, 2, LONG2FIX(b->io_buffer_size), b->io_buffer);
+        VALUE ret = rb_funcall(b->io, b->io_partial_read_method, 2, LONG2NUM(b->io_buffer_size), b->io_buffer);
         if(ret == Qnil) {
             rb_raise(rb_eEOFError, "IO reached end of file");
         }
@@ -638,7 +638,7 @@ size_t _msgpack_buffer_read_from_io_to_string(msgpack_buffer_t* b, VALUE string,
 {
     if(RSTRING_LEN(string) == 0) {
         /* direct read */
-        VALUE ret = rb_funcall(b->io, b->io_partial_read_method, 2, LONG2FIX(length), string);
+        VALUE ret = rb_funcall(b->io, b->io_partial_read_method, 2, LONG2NUM(length), string);
         if(ret == Qnil) {
             return 0;
         }
@@ -650,7 +650,7 @@ size_t _msgpack_buffer_read_from_io_to_string(msgpack_buffer_t* b, VALUE string,
         b->io_buffer = rb_str_buf_new(0);
     }
 
-    VALUE ret = rb_funcall(b->io, b->io_partial_read_method, 2, LONG2FIX(length), b->io_buffer);
+    VALUE ret = rb_funcall(b->io, b->io_partial_read_method, 2, LONG2NUM(length), b->io_buffer);
     if(ret == Qnil) {
         return 0;
     }
@@ -666,7 +666,7 @@ size_t _msgpack_buffer_skip_from_io(msgpack_buffer_t* b, size_t length)
         b->io_buffer = rb_str_buf_new(0);
     }
 
-    VALUE ret = rb_funcall(b->io, b->io_partial_read_method, 2, LONG2FIX(length), b->io_buffer);
+    VALUE ret = rb_funcall(b->io, b->io_partial_read_method, 2, LONG2NUM(length), b->io_buffer);
     if(ret == Qnil) {
         return 0;
     }

data/ext/msgpack/buffer.h

@@ -92,9 +92,11 @@ struct msgpack_buffer_t {
     msgpack_buffer_chunk_t* head;
     msgpack_buffer_chunk_t* free_list;
 
+#ifndef DISABLE_RMEM
     char* rmem_last;
     char* rmem_end;
     void** rmem_owner;
+#endif
 
     union msgpack_buffer_cast_block_t cast_block;
 

data/ext/msgpack/extconf.rb

@@ -10,6 +10,13 @@ $CFLAGS << %[ -I.. -Wall -O3 -g -std=c99]
 #$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

data/ext/msgpack/packer.c

@@ -73,9 +73,9 @@ void msgpack_packer_reset(msgpack_packer_t* pk)
 
 void msgpack_packer_write_array_value(msgpack_packer_t* pk, VALUE v)
 {
-    size_t len = RARRAY_LEN(v);
+    /* actual return type of RARRAY_LEN is long */
+    unsigned long len = RARRAY_LEN(v);
     if(len > 0xffffffffUL) {
-        // TODO rb_eArgError?
         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;
@@ -101,10 +101,11 @@ static int write_hash_foreach(VALUE key, VALUE value, VALUE pk_value)
 
 void msgpack_packer_write_hash_value(msgpack_packer_t* pk, VALUE v)
 {
-    size_t len = RHASH_SIZE(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) {
-        // TODO rb_eArgError?
-        rb_raise(rb_eArgError, "size of array is too long to pack: %lu bytes should be <= %lu", 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);

data/ext/msgpack/packer.h

@@ -145,33 +145,56 @@ static inline void _msgpack_packer_write_int64(msgpack_packer_t* pk, int64_t v)
     msgpack_buffer_write_byte_and_data(PACKER_BUFFER_(pk), 0xd3, (const void*)&be, 8);
 }
 
-static inline void msgpack_packer_write_long(msgpack_packer_t* pk, long v)
+static inline void _msgpack_packer_write_long32(msgpack_packer_t* pk, long v)
 {
     if(v < -0x20L) {
         if(v < -0x8000L) {
-            if(v < -0x80000000L) {
+            _msgpack_packer_write_int32(pk, (int32_t) v);
+        } else if(v < -0x80L) {
+            _msgpack_packer_write_int16(pk, (int16_t) v);
+        } else {
+            _msgpack_packer_write_int8(pk, (int8_t) v);
+        }
+    } else if(v <= 0x7fL) {
+        _msgpack_packer_write_fixint(pk, (int8_t) v);
+    } else {
+        if(v <= 0xffL) {
+            _msgpack_packer_write_uint8(pk, (uint8_t) v);
+        } else if(v <= 0xffffL) {
+            _msgpack_packer_write_uint16(pk, (uint16_t) v);
+        } else {
+            _msgpack_packer_write_uint32(pk, (uint32_t) v);
+        }
+    }
+}
+
+static inline void _msgpack_packer_write_long_long64(msgpack_packer_t* pk, long long v)
+{
+    if(v < -0x20LL) {
+        if(v < -0x8000LL) {
+            if(v < -0x80000000LL) {
                 _msgpack_packer_write_int64(pk, (int64_t) v);
             } else {
                 _msgpack_packer_write_int32(pk, (int32_t) v);
             }
         } else {
-            if(v < -0x80L) {
+            if(v < -0x80LL) {
                 _msgpack_packer_write_int16(pk, (int16_t) v);
             } else {
                 _msgpack_packer_write_int8(pk, (int8_t) v);
             }
         }
-    } else if(v <= 0x7fL) {
+    } else if(v <= 0x7fLL) {
         _msgpack_packer_write_fixint(pk, (int8_t) v);
     } else {
-        if(v <= 0xffffL) {
-            if(v <= 0xffL) {
+        if(v <= 0xffffLL) {
+            if(v <= 0xffLL) {
                 _msgpack_packer_write_uint8(pk, (uint8_t) v);
             } else {
                 _msgpack_packer_write_uint16(pk, (uint16_t) v);
             }
         } else {
-            if(v <= 0xffffffffL) {
+            if(v <= 0xffffffffLL) {
                 _msgpack_packer_write_uint32(pk, (uint32_t) v);
             } else {
                 _msgpack_packer_write_uint64(pk, (uint64_t) v);
@@ -180,6 +203,37 @@ static inline void msgpack_packer_write_long(msgpack_packer_t* pk, long v)
     }
 }
 
+static inline void msgpack_packer_write_long(msgpack_packer_t* pk, long v)
+{
+#if defined(SIZEOF_LONG)
+#  if SIZEOF_LONG <= 4
+    _msgpack_packer_write_long32(pk, v);
+#  else
+    _msgpack_packer_write_long_long64(pk, v);
+#  endif
+
+#elif defined(LONG_MAX)
+#  if LONG_MAX <= 0x7fffffffL
+    _msgpack_packer_write_long32(pk, v);
+#  else
+    _msgpack_packer_write_long_long64(pk, v);
+#  endif
+
+#else
+    if(sizeof(long) <= 4) {
+        _msgpack_packer_write_long32(pk, v);
+    } else {
+        _msgpack_packer_write_long_long64(pk, v);
+    }
+#endif
+}
+
+static inline void msgpack_packer_write_long_long(msgpack_packer_t* pk, long long v)
+{
+    /* assuming sizeof(long long) == 8 */
+    _msgpack_packer_write_long_long64(pk, v);
+}
+
 static inline void msgpack_packer_write_u64(msgpack_packer_t* pk, uint64_t v)
 {
     if(v <= 0xffULL) {
@@ -268,7 +322,8 @@ void _msgpack_packer_write_string_to_io(msgpack_packer_t* pk, VALUE string);
 static inline void msgpack_packer_write_string_value(msgpack_packer_t* pk, VALUE v)
 {
     /* TODO encoding conversion? */
-    size_t len = RSTRING_LEN(v);
+    /* actual return type of RSTRING_LEN is long */
+    unsigned long len = RSTRING_LEN(v);
     if(len > 0xffffffffUL) {
         // TODO rb_eArgError?
         rb_raise(rb_eArgError, "size of string is too long to pack: %lu bytes should be <= %lu", len, 0xffffffffUL);
@@ -280,7 +335,8 @@ static inline void msgpack_packer_write_string_value(msgpack_packer_t* pk, VALUE
 static inline void msgpack_packer_write_symbol_value(msgpack_packer_t* pk, VALUE v)
 {
     const char* name = rb_id2name(SYM2ID(v));
-    size_t len = strlen(name);
+    /* actual return type of strlen is size_t */
+    unsigned long len = strlen(name);
     if(len > 0xffffffffUL) {
         // TODO rb_eArgError?
         rb_raise(rb_eArgError, "size of symbol is too long to pack: %lu bytes should be <= %lu", len, 0xffffffffUL);
@@ -303,7 +359,7 @@ static inline void msgpack_packer_write_bignum_value(msgpack_packer_t* pk, VALUE
     if(RBIGNUM_POSITIVE_P(v)) {
         msgpack_packer_write_u64(pk, rb_big2ull(v));
     } else {
-        msgpack_packer_write_long(pk, rb_big2ll(v));  /* TODO long long? */
+        msgpack_packer_write_long_long(pk, rb_big2ll(v));
     }
 }
 

data/ext/msgpack/unpacker.c

@@ -251,10 +251,10 @@ static int read_primitive(msgpack_unpacker_t* uk)
 
     SWITCH_RANGE_BEGIN(b)
     SWITCH_RANGE(b, 0x00, 0x7f)  // Positive Fixnum
-        return object_complete(uk, INT2FIX(b));
+        return object_complete(uk, INT2NUM(b));
 
     SWITCH_RANGE(b, 0xe0, 0xff)  // Negative Fixnum
-        return object_complete(uk, INT2FIX((int8_t)b));
+        return object_complete(uk, INT2NUM((int8_t)b));
 
     SWITCH_RANGE(b, 0xa0, 0xbf)  // FixRaw
         int count = b & 0x1f;
@@ -317,14 +317,14 @@ static int read_primitive(msgpack_unpacker_t* uk)
             {
                 READ_CAST_BLOCK_OR_RETURN_EOF(cb, uk, 1);
                 uint8_t u8 = cb->u8;
-                return object_complete(uk, INT2FIX((int)u8));
+                return object_complete(uk, INT2NUM((int)u8));
             }
 
         case 0xcd:  // unsigned int 16
             {
                 READ_CAST_BLOCK_OR_RETURN_EOF(cb, uk, 2);
                 uint16_t u16 = _msgpack_be16(cb->u16);
-                return object_complete(uk, INT2FIX((int)u16));
+                return object_complete(uk, INT2NUM((int)u16));
             }
 
         case 0xce:  // unsigned int 32
@@ -345,21 +345,21 @@ static int read_primitive(msgpack_unpacker_t* uk)
             {
                 READ_CAST_BLOCK_OR_RETURN_EOF(cb, uk, 1);
                 int8_t i8 = cb->i8;
-                return object_complete(uk, INT2FIX((int)i8));
+                return object_complete(uk, INT2NUM((int)i8));
             }
 
         case 0xd1:  // signed int 16
             {
                 READ_CAST_BLOCK_OR_RETURN_EOF(cb, uk, 2);
                 int16_t i16 = _msgpack_be16(cb->i16);
-                return object_complete(uk, INT2FIX((int)i16));
+                return object_complete(uk, INT2NUM((int)i16));
             }
 
         case 0xd2:  // signed int 32
             {
                 READ_CAST_BLOCK_OR_RETURN_EOF(cb, uk, 4);
                 int32_t i32 = _msgpack_be32(cb->i32);
-                return object_complete(uk, LONG2FIX((long)i32));
+                return object_complete(uk, LONG2NUM((long)i32));
             }
 
         case 0xd3:  // signed int 64

data/lib/msgpack/version.rb

@@ -1,3 +1,3 @@
 module MessagePack
-	VERSION = "0.5.1"
+	VERSION = "0.5.2"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: msgpack
 version: !ruby/object:Gem::Version 
-  hash: 9
+  hash: 15
   prerelease: 
   segments: 
   - 0
   - 5
-  - 1
-  version: 0.5.1
+  - 2
+  version: 0.5.2
 platform: x86-mingw32
 authors: 
 - FURUHASHI Sadayuki
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-12-24 00:00:00 +09:00
+date: 2013-02-07 00:00:00 +09:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency