VALUE msgpack_buffer_all_as_string_array(msgpack_buffer_t* b) { if(b->head == &b->tail) { VALUE s = msgpack_buffer_all_as_string(b); VALUE ary = rb_ary_new3(1, s); return ary; } /* TODO optimize ary construction */ VALUE ary = rb_ary_new(); VALUE s = _msgpack_buffer_head_chunk_as_string(b); rb_ary_push(ary, s); msgpack_buffer_chunk_t* c = b->head->next; while(true) { s = _msgpack_buffer_chunk_as_string(c); rb_ary_push(ary, s); if(c == &b->tail) { return ary; } c = c->next; } return ary; }
static VALUE Buffer_read(int argc, VALUE* argv, VALUE self) { VALUE out = Qnil; unsigned long n = -1; bool all = false; switch(argc) { case 2: out = argv[1]; /* pass through */ case 1: n = FIX2ULONG(argv[0]); break; case 0: all = true; break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0..2)", argc); } BUFFER(self, b); if(out != Qnil) { CHECK_STRING_TYPE(out); } if(all) { return read_all(b, out); } if(n == 0) { /* do nothing */ MAKE_EMPTY_STRING(out); return out; } #ifndef DISABLE_BUFFER_READ_TO_S_OPTIMIZE if(!msgpack_buffer_has_io(b) && out == Qnil && msgpack_buffer_all_readable_size(b) <= n) { /* same as to_s && clear; optimize */ VALUE str = msgpack_buffer_all_as_string(b); msgpack_buffer_clear(b); if(RSTRING_LEN(str) == 0) { return Qnil; } else { return str; } } #endif MAKE_EMPTY_STRING(out); read_until_eof(b, out, n); if(RSTRING_LEN(out) == 0) { return Qnil; } else { return out; } }
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; }
static inline VALUE read_all(msgpack_buffer_t* b, VALUE out) { #ifndef DISABLE_BUFFER_READ_TO_S_OPTIMIZE if(out == Qnil && !msgpack_buffer_has_io(b)) { /* same as to_s && clear; optimize */ VALUE str = msgpack_buffer_all_as_string(b); msgpack_buffer_clear(b); return str; } #endif MAKE_EMPTY_STRING(out); read_until_eof(b, out, 0); return out; }
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_to_str(VALUE self) { PACKER(self, pk); return msgpack_buffer_all_as_string(PACKER_BUFFER_(pk)); }
static mrb_value Packer_to_str(mrb_state *mrb, mrb_value self) { PACKER(mrb, self, pk); return msgpack_buffer_all_as_string(mrb, PACKER_BUFFER_(pk)); }
static VALUE Buffer_to_str(VALUE self) { BUFFER(self, b); return msgpack_buffer_all_as_string(b); }