packsnap 0.0.1

data/ext/packsnap/packer_class.cc

@@ -0,0 +1,288 @@
+/*
+ * MessagePack for Ruby
+ *
+ * Copyright (C) 2008-2012 FURUHASHI Sadayuki
+ *
+ *    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 "packsnap.h"
+#include "compat.h"
+#include "ruby.h"
+#include "packer.h"
+#include "packer_class.hh"
+#include "buffer_class.hh"
+
+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(io));
+        }
+
+    } else {
+        rb_raise(rb_eArgError, "wrong number of arguments (%d for 0..1)", argc);
+    }
+
+    PACKER(self, pk);
+    if(io != Qnil || options != Qnil) {
+        MessagePack_Buffer_initialize(PACKER_BUFFER_(pk), io, options);
+    }
+
+    // TODO 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;
+//}
+
+extern "C"
+VALUE MessagePack_pack(int argc, VALUE* argv)
+{
+    // TODO options
+
+    VALUE v;
+    VALUE io = Qnil;
+
+    switch(argc) {
+    case 2:
+        io = argv[1];
+        /* pass-through */
+    case 1:
+        v = argv[0];
+        break;
+    default:
+        rb_raise(rb_eArgError, "wrong number of arguments (%d for 1..2)", argc);
+    }
+
+    VALUE self = Packer_alloc(cMessagePack_Packer);
+    PACKER(self, pk);
+    //msgpack_packer_reset(s_packer);
+    //msgpack_buffer_reset_io(PACKER_BUFFER_(s_packer));
+
+    if(io != Qnil) {
+        MessagePack_Buffer_initialize(PACKER_BUFFER_(pk), io, Qnil);
+    }
+
+    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 */
+    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);
+}
+
+extern "C"
+void MessagePack_Packer_module_init(VALUE mMessagePack)
+{
+    s_to_msgpack = rb_intern("to_msgpack");
+    s_write = rb_intern("write");
+
+    cMessagePack_Packer = rb_define_class_under(mMessagePack, "Packer", rb_cObject);
+
+    rb_define_alloc_func(cMessagePack_Packer, (VALUE (*)(VALUE))Packer_alloc);
+
+    rb_define_method(cMessagePack_Packer, "initialize", (VALUE (*)(...))Packer_initialize, -1);
+    rb_define_method(cMessagePack_Packer, "buffer", (VALUE (*)(...))Packer_buffer, 0);
+    rb_define_method(cMessagePack_Packer, "write", (VALUE (*)(...))Packer_write, 1);
+    rb_define_alias(cMessagePack_Packer, "pack", "write");
+    rb_define_method(cMessagePack_Packer, "write_nil", (VALUE (*)(...))Packer_write_nil, 0);
+    rb_define_method(cMessagePack_Packer, "write_array_header", (VALUE (*)(...))Packer_write_array_header, 1);
+    rb_define_method(cMessagePack_Packer, "write_map_header", (VALUE (*)(...))Packer_write_map_header, 1);
+    rb_define_method(cMessagePack_Packer, "flush", (VALUE (*)(...))Packer_flush, 0);
+
+    /* delegation methods */
+    rb_define_method(cMessagePack_Packer, "clear", (VALUE (*)(...))Packer_clear, 0);
+    rb_define_method(cMessagePack_Packer, "size", (VALUE (*)(...))Packer_size, 0);
+    rb_define_method(cMessagePack_Packer, "empty?", (VALUE (*)(...))Packer_empty_p, 0);
+    rb_define_method(cMessagePack_Packer, "write_to", (VALUE (*)(...))Packer_write_to, 1);
+    rb_define_method(cMessagePack_Packer, "to_str", (VALUE (*)(...))Packer_to_str, 0);
+    rb_define_alias(cMessagePack_Packer, "to_s", "to_str");
+    rb_define_method(cMessagePack_Packer, "to_a", (VALUE (*)(...))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", (VALUE (*)(...))MessagePack_pack_module_method, -1);
+    rb_define_module_function(mMessagePack, "dump", (VALUE (*)(...))MessagePack_dump_module_method, -1);
+}
+

data/ext/packsnap/packer_class.hh

@@ -0,0 +1,32 @@
+/*
+ * MessagePack for Ruby
+ *
+ * Copyright (C) 2008-2012 FURUHASHI Sadayuki
+ *
+ *    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;
+
+extern "C"
+void MessagePack_Packer_module_init(VALUE mMessagePack);
+
+extern "C"
+VALUE MessagePack_pack(int argc, VALUE* argv);
+
+#endif
+

data/ext/packsnap/packsnap.h

@@ -0,0 +1,4 @@
+#include "ruby.h"
+static VALUE rb_mPacksnap;
+static VALUE rb_ePacksnap;
+

data/ext/packsnap/rbinit.cc

@@ -0,0 +1,52 @@
+/*
+ * MessagePack for Ruby
+ *
+ * Copyright (C) 2008-2012 FURUHASHI Sadayuki
+ *
+ *    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 "packsnap.h"
+
+#include "buffer_class.hh"
+#include "packer_class.hh"
+#include "unpacker_class.hh"
+
+#ifdef COMPAT_HAVE_ENCODING
+/* see compat.h*/
+int s_enc_utf8;
+int s_enc_ascii8bit;
+int s_enc_usascii;
+VALUE s_enc_utf8_value;
+#endif
+
+extern "C"
+void Init_packsnap(void)
+{
+#ifdef COMPAT_HAVE_ENCODING
+    s_enc_ascii8bit = rb_ascii8bit_encindex();
+    s_enc_utf8 = rb_utf8_encindex();
+    s_enc_usascii = rb_usascii_encindex();
+    s_enc_utf8_value = rb_enc_from_encoding(rb_utf8_encoding());
+#endif
+
+    VALUE mMessagePack = rb_define_module("Packsnap");
+    rb_mPacksnap = mMessagePack;
+
+    rb_ePacksnap = rb_define_class_under(rb_mPacksnap, "Error", rb_eStandardError);
+
+    MessagePack_Buffer_module_init(mMessagePack);
+    MessagePack_Packer_module_init(mMessagePack);
+    MessagePack_Unpacker_module_init(mMessagePack);
+}
+

data/ext/packsnap/rmem.cc

@@ -0,0 +1,110 @@
+/*
+ * MessagePack for Ruby
+ *
+ * Copyright (C) 2008-2012 FURUHASHI Sadayuki
+ *
+ *    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 = (char*)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 = (msgpack_rmem_chunk_t*)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);  /* first chunk is already allocated */
+    pm->head.pages = (char*)malloc(MSGPACK_RMEM_PAGE_SIZE * 32);
+
+    return pm->head.pages;
+}
+
+static inline void handle_empty_chunk(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;
+}
+
+bool _msgpack_rmem_free2(msgpack_rmem_t* pm, void* mem)
+{
+    /* 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) {
+                handle_empty_chunk(pm, c);
+            }
+            return true;
+        }
+    }
+    return false;
+}
+