VALUE MessagePack_pack(int argc, VALUE* argv)
{
VALUE v;
if (argc < 0 || argc > 3) {
rb_raise(rb_eArgError, "wrong number of arguments (%d for 1..3)", argc);
}
v = argv[0];
VALUE self = MessagePack_Factory_packer(argc - 1, argv + 1, cMessagePack_DefaultFactory);
PACKER(self, pk);
msgpack_packer_write_value(pk, v);
VALUE retval;
if(msgpack_buffer_has_io(PACKER_BUFFER_(pk))) {
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 */
#ifdef RB_GC_GUARD
/* This prevents compilers from optimizing out the `self` variable
* from stack. Otherwise GC free()s it. */
RB_GC_GUARD(self);
#endif
return retval;
}
mrb_value
MessagePack_pack_v(mrb_state *mrb, int argc, mrb_value* argv)
{
//mrb_value *argv;
//int argc; /* Number of arguments */
/* TODO options */
mrb_value v;
mrb_value io = mrb_nil_value();
//mrb_get_args(mrb, "*", &argv, &argc);
switch (argc) {
case 2:
io = argv[1];
/* Pass-through */
case 1:
v = argv[0];
break;
default:
mrb_raisef(mrb, E_ARGUMENT_ERROR, "wrong number of arguments (%S for 1..2)", mrb_fixnum_value(argc));
}
mrb_value self = Packer_alloc(mrb, cMessagePack_Packer);
PACKER(mrb, self, pk);
//msgpack_packer_reset(s_packer);
//msgpack_buffer_reset_io(PACKER_BUFFER_(s_packer));
if (!mrb_nil_p(io)) {
MessagePack_Buffer_initialize(mrb, PACKER_BUFFER_(pk), io, mrb_nil_value());
}
msgpack_packer_write_value(mrb, pk, v);
mrb_value retval;
if (!mrb_nil_p(io)) {
msgpack_buffer_flush(mrb, PACKER_BUFFER_(pk));
retval = mrb_nil_value();
} else {
retval = msgpack_buffer_all_as_string(mrb, PACKER_BUFFER_(pk));
}
//msgpack_buffer_clear(mrb, PACKER_BUFFER_(pk)); /* to free rmem before GC */
#ifdef RB_GC_GUARD
/* This prevents compilers from optimizing out the `self` variable
* from stack. Otherwise GC free()s it. */
RB_GC_GUARD(self);
#endif
return retval;
}
void _msgpack_buffer_append_long_string(msgpack_buffer_t* b, VALUE string)
{
size_t length = RSTRING_LEN(string);
if(b->io != Qnil) {
msgpack_buffer_flush(b);
rb_funcall(b->io, b->io_write_all_method, 1, string);
} else if(!STR_DUP_LIKELY_DOES_COPY(string)) {
_msgpack_buffer_append_reference(b, string);
} else {
msgpack_buffer_append(b, RSTRING_PTR(string), length);
}
}
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 */
#ifdef RB_GC_GUARD
/* This prevents compilers from optimizing out the `self` variable
* from stack. Otherwise GC free()s it. */
RB_GC_GUARD(self);
#endif
return retval;
}
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 Packer_flush(VALUE self)
{
PACKER(self, pk);
msgpack_buffer_flush(PACKER_BUFFER_(pk));
return self;
}
void _msgpack_buffer_expand(msgpack_buffer_t* b, const char* data, size_t length, bool flush_to_io)
{
if(flush_to_io && b->io != Qnil) {
msgpack_buffer_flush(b);
if(msgpack_buffer_writable_size(b) >= length) {
/* data == NULL means ensure_writable */
if(data != NULL) {
size_t tail_avail = msgpack_buffer_writable_size(b);
memcpy(b->tail.last, data, length);
b->tail.last += tail_avail;
}
return;
}
}
/* data == NULL means ensure_writable */
if(data != NULL) {
size_t tail_avail = msgpack_buffer_writable_size(b);
memcpy(b->tail.last, data, tail_avail);
b->tail.last += tail_avail;
data += tail_avail;
length -= tail_avail;
}
size_t capacity = b->tail.last - b->tail.first;
/* can't realloc mapped chunk or rmem page */
if(b->tail.mapped_string != NO_MAPPED_STRING
#ifndef DISABLE_RMEM
|| capacity <= MSGPACK_RMEM_PAGE_SIZE
#endif
) {
/* allocate new chunk */
_msgpack_buffer_add_new_chunk(b);
char* mem = _msgpack_buffer_chunk_malloc(b, &b->tail, length, &capacity);
char* last = mem;
if(data != NULL) {
memcpy(mem, data, length);
last += length;
}
/* rebuild tail chunk */
b->tail.first = mem;
b->tail.last = last;
b->tail.mapped_string = NO_MAPPED_STRING;
b->tail_buffer_end = mem + capacity;
/* consider read_buffer */
if(b->head == &b->tail) {
b->read_buffer = b->tail.first;
}
} else {
/* realloc malloc()ed chunk or NULL */
size_t tail_filled = b->tail.last - b->tail.first;
char* mem = _msgpack_buffer_chunk_realloc(b, &b->tail,
b->tail.first, tail_filled+length, &capacity);
char* last = mem + tail_filled;
if(data != NULL) {
memcpy(last, data, length);
last += length;
}
/* consider read_buffer */
if(b->head == &b->tail) {
size_t read_offset = b->read_buffer - b->head->first;
b->read_buffer = mem + read_offset;
}
/* rebuild tail chunk */
b->tail.first = mem;
b->tail.last = last;
b->tail_buffer_end = mem + capacity;
}
}
static mrb_value Packer_flush(mrb_state* mrb, mrb_value self)
{
PACKER(mrb, self, pk);
msgpack_buffer_flush(mrb, PACKER_BUFFER_(pk));
return self;
}
static VALUE Buffer_flush(VALUE self)
{
BUFFER(self, b);
msgpack_buffer_flush(b);
return self;
}
