cbor 0.5.6.2

data/ext/cbor/extconf.rb

@@ -0,0 +1,25 @@
+require 'mkmf'
+
+have_header("ruby/st.h")
+have_header("st.h")
+have_func("rb_str_replace", ["ruby.h"])
+have_func("rb_big_new", ["ruby.h"])
+
+$CFLAGS << %[ -I.. -Wall -O3 -g -std=c99]
+#$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('cbor/cbor')

data/ext/cbor/packer.c

@@ -0,0 +1,169 @@
+/*
+ * 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 "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);
+    msgpack_packer_write_array_header(pk, len);
+
+    unsigned long i;
+    for(i=0; i < len; ++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);
+    msgpack_packer_write_map_header(pk, len);
+
+#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);
+    }
+}
+

data/ext/cbor/packer.h

@@ -0,0 +1,337 @@
+/*
+ * 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_H__
+#define MSGPACK_RUBY_PACKER_H__
+
+#include "buffer.h"
+
+#ifndef MSGPACK_PACKER_IO_FLUSH_THRESHOLD_TO_WRITE_STRING_BODY
+#define MSGPACK_PACKER_IO_FLUSH_THRESHOLD_TO_WRITE_STRING_BODY (1024)
+#endif
+
+struct msgpack_packer_t;
+typedef struct msgpack_packer_t msgpack_packer_t;
+
+struct msgpack_packer_t {
+    msgpack_buffer_t buffer;
+
+    VALUE io;
+    ID io_write_all_method;
+
+    ID to_msgpack_method;
+    VALUE to_msgpack_arg;
+
+    VALUE buffer_ref;
+};
+
+#define PACKER_BUFFER_(pk) (&(pk)->buffer)
+
+void msgpack_packer_static_init();
+
+void msgpack_packer_static_destroy();
+
+void msgpack_packer_init(msgpack_packer_t* pk);
+
+void msgpack_packer_destroy(msgpack_packer_t* pk);
+
+void msgpack_packer_mark(msgpack_packer_t* pk);
+
+static inline void msgpack_packer_set_to_msgpack_method(msgpack_packer_t* pk,
+        ID to_msgpack_method, VALUE to_msgpack_arg)
+{
+    pk->to_msgpack_method = to_msgpack_method;
+    pk->to_msgpack_arg = to_msgpack_arg;
+}
+
+static inline void msgpack_packer_set_io(msgpack_packer_t* pk, VALUE io, ID io_write_all_method)
+{
+    pk->io = io;
+    pk->io_write_all_method = io_write_all_method;
+}
+
+void msgpack_packer_reset(msgpack_packer_t* pk);
+
+
+static inline void cbor_encoder_write_head(msgpack_packer_t* pk, unsigned int ib, uint64_t n)
+{
+    if (n < 24) {
+        msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 1);
+        msgpack_buffer_write_1(PACKER_BUFFER_(pk), ib + n);
+    } else if (n < 256) {
+        msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 3);
+        msgpack_buffer_write_2(PACKER_BUFFER_(pk), ib + 24, n);
+    } else if (n < 65536) {
+        msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 3);
+        uint16_t be = _msgpack_be16(n);
+        msgpack_buffer_write_byte_and_data(PACKER_BUFFER_(pk), ib + 25, (const void*)&be, 2);
+    } else if (n < 0x100000000LU) {
+        msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 5);
+        uint32_t be = _msgpack_be32(n);
+        msgpack_buffer_write_byte_and_data(PACKER_BUFFER_(pk), ib + 26, (const void*)&be, 4);
+    } else {
+        msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 9);
+        uint64_t be = _msgpack_be64(n);
+        msgpack_buffer_write_byte_and_data(PACKER_BUFFER_(pk), ib + 27, (const void*)&be, 8);
+    }
+}
+
+static inline void msgpack_packer_write_nil(msgpack_packer_t* pk)
+{
+    msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 1);
+    msgpack_buffer_write_1(PACKER_BUFFER_(pk), IB_NIL);
+}
+
+static inline void msgpack_packer_write_true(msgpack_packer_t* pk)
+{
+    msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 1);
+    msgpack_buffer_write_1(PACKER_BUFFER_(pk), IB_TRUE);
+}
+
+static inline void msgpack_packer_write_false(msgpack_packer_t* pk)
+{
+    msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 1);
+    msgpack_buffer_write_1(PACKER_BUFFER_(pk), IB_FALSE);
+}
+
+static inline void _msgpack_packer_write_long_long64(msgpack_packer_t* pk, long long v)
+{
+  uint64_t ui = v >> 63;    // extend sign to whole length
+  int mt = ui & IB_NEGFLAG;          // extract major type
+  ui ^= v;                 // complement negatives
+  cbor_encoder_write_head(pk, mt, ui);
+}
+
+static inline void msgpack_packer_write_long(msgpack_packer_t* pk, long v)
+{
+  _msgpack_packer_write_long_long64(pk, v);
+}
+
+static inline void msgpack_packer_write_u64(msgpack_packer_t* pk, uint64_t v)
+{
+  cbor_encoder_write_head(pk, IB_UNSIGNED, v);
+}
+
+static inline void msgpack_packer_write_double(msgpack_packer_t* pk, double v)
+{
+  float fv = v;
+  if (fv == v) {                /* 32 bits is enough and we aren't NaN */
+    union {
+        float f;
+        uint32_t u32;
+        char mem[4];
+    } castbuf = { fv };
+    int b32 = castbuf.u32;
+    if ((b32 & 0x1FFF) == 0) { /* worth trying half */
+      int s16 = (b32 >> 16) & 0x8000;
+      int exp = (b32 >> 23) & 0xff;
+      int mant = b32 & 0x7fffff;
+      if (exp == 0 && mant == 0)
+        ;              /* 0.0, -0.0 */
+      else if (exp >= 113 && exp <= 142) /* normalized */
+        s16 += ((exp - 112) << 10) + (mant >> 13);
+      else if (exp >= 103 && exp < 113) { /* denorm, exp16 = 0 */
+        if (mant & ((1 << (126 - exp)) - 1))
+          goto float32;         /* loss of precision */
+        s16 += ((mant + 0x800000) >> (126 - exp));
+      } else if (exp == 255 && mant == 0) { /* Inf */
+        s16 += 0x7c00;
+      } else
+        goto float32;           /* loss of range */
+      msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 3);
+      uint16_t be = _msgpack_be16(s16);
+      msgpack_buffer_write_byte_and_data(PACKER_BUFFER_(pk), IB_FLOAT2, (const void*)&be, 2);
+      return;
+    }
+  float32:
+    msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 5);
+    castbuf.u32 = _msgpack_be_float(castbuf.u32);
+    msgpack_buffer_write_byte_and_data(PACKER_BUFFER_(pk), IB_FLOAT4, castbuf.mem, 4);
+  } else if (v != v) {          /* NaN */
+    cbor_encoder_write_head(pk, 0xe0, 0xfe00);
+  } else {
+    msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 9);
+    union {
+        double d;
+        uint64_t u64;
+        char mem[8];
+    } castbuf = { v };
+    castbuf.u64 = _msgpack_be_double(castbuf.u64);
+    msgpack_buffer_write_byte_and_data(PACKER_BUFFER_(pk), IB_FLOAT8, castbuf.mem, 8);
+  }
+}
+
+static inline void msgpack_packer_write_array_header(msgpack_packer_t* pk, uint64_t n)
+{
+  cbor_encoder_write_head(pk, IB_ARRAY, n);
+}
+
+static inline void msgpack_packer_write_map_header(msgpack_packer_t* pk, uint64_t n)
+{
+  cbor_encoder_write_head(pk, IB_MAP, n);
+}
+
+
+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)
+{
+  int mt = IB_TEXT;                /* text string */
+#ifdef COMPAT_HAVE_ENCODING
+  int enc = ENCODING_GET(v);
+  if (enc == s_enc_ascii8bit) {
+    mt = IB_BYTES;
+  } else if (enc != s_enc_utf8 && enc != s_enc_usascii) {
+    if(!ENC_CODERANGE_ASCIIONLY(v)) {
+      v = rb_str_encode(v, s_enc_utf8_value, 0, Qnil);
+    }
+  }
+#endif
+  cbor_encoder_write_head(pk, mt, RSTRING_LEN(v));
+  msgpack_buffer_append_string(PACKER_BUFFER_(pk), v);
+}
+
+static inline void msgpack_packer_write_symbol_value(msgpack_packer_t* pk, VALUE v)
+{
+    const char* name = rb_id2name(SYM2ID(v));
+    /* 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);
+    }
+    cbor_encoder_write_head(pk, IB_TEXT, len);
+    msgpack_buffer_append(PACKER_BUFFER_(pk), name, len);
+}
+
+static inline void msgpack_packer_write_fixnum_value(msgpack_packer_t* pk, VALUE v)
+{
+#ifdef JRUBY
+    msgpack_packer_write_long(pk, FIXNUM_P(v) ? FIX2LONG(v) : rb_num2ll(v));
+#else
+    msgpack_packer_write_long(pk, FIX2LONG(v));
+#endif
+}
+
+static inline void msgpack_packer_write_bignum_value(msgpack_packer_t* pk, VALUE v)
+{
+  long len;
+  int ib = IB_UNSIGNED;
+  if (!RBIGNUM_POSITIVE_P(v)) {
+    v = rb_funcall(v, rb_intern("~"), 0);  /* should be rb_big_neg(), but that is static. */
+    ib = IB_NEGATIVE;
+  }
+  len = RBIGNUM_LEN(v);         /* This API is broken in Rubinius 2.1.1, #2742 */
+  if (len > SIZEOF_LONG_LONG/SIZEOF_BDIGITS) {
+    msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 1);
+    msgpack_buffer_write_1(PACKER_BUFFER_(pk), IB_BIGNUM + IB_NEGFLAG_AS_BIT(ib));
+    {
+#ifndef CANT_DO_BIGNUMS_FAST_ON_THIS_PLATFORM
+    BDIGIT *dp = RBIGNUM_DIGITS(v);
+    BDIGIT *de = dp + len;
+    int nbyte = (len - 1) * SIZEOF_BDIGITS;
+    int nbmsdig = 0;
+    BDIGIT msdig;
+    int i;
+    if ((msdig = de[-1]) == 0)  /* todo: check whether that occurs */
+      rb_raise(rb_eRangeError, "cbor writing unnormalized bignum");
+    while (msdig) {     /* get number of significant bytes in msdig */
+      nbmsdig++;
+      msdig >>= 8;
+    }
+    nbyte += nbmsdig;
+    cbor_encoder_write_head(pk, IB_BYTES, nbyte);
+    msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), nbyte);
+    /* first digit: */
+    msdig = de[-1];
+    while (nbmsdig) {
+      --nbmsdig;
+      msgpack_buffer_write_1(PACKER_BUFFER_(pk), msdig >> (nbmsdig << 3));
+    }
+    /* rest of the digits: */
+    for (i = 1; i < len; ++i) {
+      BDIGIT be = NTOHBDIGIT(de[-1-i]);
+      msgpack_buffer_append(PACKER_BUFFER_(pk), (const void*)&be, SIZEOF_BDIGITS);
+    }
+#else
+    /* This is a slow workaround only... But a working one.*/
+    size_t nbyte;
+    VALUE hexval = rb_funcall(v, rb_intern("to_s"), 1, INT2FIX(16));
+    char *hp;
+    int i;
+    if (RSTRING_LEN(hexval) & 1)
+      rb_funcall(hexval, rb_intern("[]="), 3, INT2FIX(0), INT2FIX(0), rb_str_new("0", 1));
+    nbyte = RSTRING_LEN(hexval) >> 1;
+    hp = RSTRING_PTR(hexval);
+    cbor_encoder_write_head(pk, IB_BYTES, nbyte);
+    msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), nbyte);
+    for (i = 0; i < nbyte; i++) {
+      int c;
+      sscanf(hp, "%2x", &c);
+      hp += 2;
+      msgpack_buffer_write_1(PACKER_BUFFER_(pk), c);
+    }
+#endif
+    }
+  } else {
+    cbor_encoder_write_head(pk, ib, rb_big2ull(v));
+  }
+
+#ifdef RB_GC_GUARD
+    RB_GC_GUARD(v);
+#endif
+}
+
+static inline void msgpack_packer_write_float_value(msgpack_packer_t* pk, VALUE v)
+{
+    msgpack_packer_write_double(pk, rb_num2dbl(v));
+}
+
+static inline void msgpack_packer_write_simple_value(msgpack_packer_t* pk, VALUE v)
+{
+  cbor_encoder_write_head(pk, IB_PRIM, FIX2LONG(rb_struct_aref(v, INT2FIX(0))));
+}
+
+void msgpack_packer_write_array_value(msgpack_packer_t* pk, VALUE v);
+
+void msgpack_packer_write_hash_value(msgpack_packer_t* pk, VALUE v);
+
+void msgpack_packer_write_value(msgpack_packer_t* pk, VALUE v);
+
+static inline void msgpack_packer_write_tagged_value(msgpack_packer_t* pk, VALUE v)
+{
+  cbor_encoder_write_head(pk, IB_TAG, FIX2LONG(rb_struct_aref(v, INT2FIX(0))));
+  msgpack_packer_write_value(pk, rb_struct_aref(v, INT2FIX(1)));
+}
+
+static inline void msgpack_packer_write_processed_value(msgpack_packer_t* pk, VALUE v, ID method, int tag)
+{
+  cbor_encoder_write_head(pk, IB_TAG, tag);
+  msgpack_packer_write_value(pk, rb_funcall(v, method, 0));
+}
+
+#endif
+