static ptrdiff_t
write_iseq_block(mrb_state *mrb, mrb_irep *irep, uint8_t *buf, uint8_t flags)
{
uint8_t *cur = buf;
uint32_t iseq_no;
cur += uint32_to_bin(irep->ilen, cur); /* number of opcode */
cur += write_padding(cur);
switch (flags & DUMP_ENDIAN_NAT) {
case DUMP_ENDIAN_BIG:
if (bigendian_p()) goto native;
for (iseq_no = 0; iseq_no < irep->ilen; iseq_no++) {
cur += uint32_to_bin(irep->iseq[iseq_no], cur); /* opcode */
}
break;
case DUMP_ENDIAN_LIL:
if (!bigendian_p()) goto native;
for (iseq_no = 0; iseq_no < irep->ilen; iseq_no++) {
cur += uint32l_to_bin(irep->iseq[iseq_no], cur); /* opcode */
}
break;
native:
case DUMP_ENDIAN_NAT:
memcpy(cur, irep->iseq, irep->ilen * sizeof(mrb_code));
cur += irep->ilen * sizeof(mrb_code);
break;
}
return cur - buf;
}
static int
write_lineno_record_1(mrb_state *mrb, mrb_irep *irep, uint8_t* bin)
{
uint8_t *cur = bin;
size_t filename_len = 0, iseq_no;
cur += sizeof(uint32_t); /* record size */
if (irep->filename) {
filename_len = strlen(irep->filename);
}
cur += uint16_to_bin(filename_len, cur); /* filename size */
if (filename_len) {
memcpy(cur, irep->filename, filename_len);
cur += filename_len; /* filename */
}
if (irep->lines) {
cur += uint32_to_bin(irep->ilen, cur); /* niseq */
for (iseq_no = 0; iseq_no < irep->ilen; iseq_no++) {
cur += uint16_to_bin(irep->lines[iseq_no], cur); /* opcode */
}
}
else {
cur += uint32_to_bin(0, cur); /* niseq */
}
uint32_to_bin(cur - bin, bin); /* record size */
return (cur - bin);
}
static size_t
write_debug_record_1(mrb_state *mrb, mrb_irep *irep, uint8_t *bin, mrb_sym const* filenames, uint16_t filenames_len)
{
uint8_t *cur;
uint16_t f_idx;
ptrdiff_t ret;
cur = bin + sizeof(uint32_t); /* skip record size */
cur += uint16_to_bin(irep->debug_info->flen, cur); /* file count */
for (f_idx = 0; f_idx < irep->debug_info->flen; ++f_idx) {
int filename_idx;
const mrb_irep_debug_info_file *file = irep->debug_info->files[f_idx];
/* position */
cur += uint32_to_bin(file->start_pos, cur);
/* filename index */
filename_idx = find_filename_index(filenames, filenames_len,
file->filename_sym);
mrb_assert(filename_idx >= 0);
mrb_assert(filename_idx <= UINT16_MAX);
cur += uint16_to_bin((uint16_t)filename_idx, cur);
/* lines */
cur += uint32_to_bin(file->line_entry_count, cur);
cur += uint8_to_bin(file->line_type, cur);
switch(file->line_type) {
case mrb_debug_line_ary: {
uint32_t l;
for (l = 0; l < file->line_entry_count; ++l) {
cur += uint16_to_bin(file->line_ary[l], cur);
}
} break;
case mrb_debug_line_flat_map: {
uint32_t line;
for (line = 0; line < file->line_entry_count; ++line) {
cur += uint32_to_bin(file->line_flat_map[line].start_pos, cur);
cur += uint16_to_bin(file->line_flat_map[line].line, cur);
}
} break;
default: mrb_assert(0); break;
}
}
ret = cur - bin;
mrb_assert(ret >= 0);
mrb_assert(ret <= UINT32_MAX);
uint32_to_bin(ret, bin);
mrb_assert((size_t)ret <= SIZE_MAX);
return (size_t)ret;
}
static int
write_debug_record(mrb_state *mrb, mrb_irep *irep, uint8_t *bin, mrb_sym const* filenames, size_t filenames_len)
{
uint8_t *cur;
uint32_t f_idx;
size_t ret;
cur = bin + sizeof(uint32_t); // skip record size
cur += uint16_to_bin(irep->debug_info->flen, cur); // file count
for (f_idx = 0; f_idx < irep->debug_info->flen; ++f_idx) {
int filename_idx;
const mrb_irep_debug_info_file *file = irep->debug_info->files[f_idx];
// position
cur += uint32_to_bin(file->start_pos, cur);
// filename index
filename_idx = find_filename_index(filenames, filenames_len,
file->filename_sym);
mrb_assert(filename_idx != -1);
cur += uint16_to_bin(filename_idx, cur);
// lines
cur += uint32_to_bin(file->line_entry_count, cur);
cur += uint8_to_bin(file->line_type, cur);
switch(file->line_type) {
case mrb_debug_line_ary: {
size_t l;
for (l = 0; l < file->line_entry_count; ++l) {
cur += uint16_to_bin(file->line_ary[l], cur);
}
} break;
case mrb_debug_line_flat_map: {
uint32_t line;
for (line = 0; line < file->line_entry_count; ++line) {
cur += uint32_to_bin(file->line_flat_map[line].start_pos, cur);
cur += uint16_to_bin(file->line_flat_map[line].line, cur);
}
} break;
default: mrb_assert(0); break;
}
}
ret = cur - bin;
uint32_to_bin(ret, bin);
mrb_assert((cur - bin) == (int)get_debug_record_size(mrb, irep));
return ret;
}
static int
write_iseq_block(mrb_state *mrb, mrb_irep *irep, uint8_t *buf)
{
uint8_t *cur = buf;
size_t iseq_no;
cur += uint32_to_bin(irep->ilen, cur); /* number of opcode */
for (iseq_no = 0; iseq_no < irep->ilen; iseq_no++) {
cur += uint32_to_bin(irep->iseq[iseq_no], cur); /* opcode */
}
return (cur - buf);
}
static ptrdiff_t
write_syms_block(mrb_state *mrb, mrb_irep *irep, uint8_t *buf)
{
uint32_t sym_no;
uint8_t *cur = buf;
const char *name;
cur += uint32_to_bin(irep->slen, cur); /* number of symbol */
for (sym_no = 0; sym_no < irep->slen; sym_no++) {
if (irep->syms[sym_no] != 0) {
mrb_int len;
name = mrb_sym2name_len(mrb, irep->syms[sym_no], &len);
mrb_assert_int_fit(mrb_int, len, uint16_t, UINT16_MAX);
cur += uint16_to_bin((uint16_t)len, cur); /* length of symbol name */
memcpy(cur, name, len); /* symbol name */
cur += (uint16_t)len;
*cur++ = '\0';
}
else {
cur += uint16_to_bin(MRB_DUMP_NULL_SYM_LEN, cur); /* length of symbol name */
}
}
return cur - buf;
}
static int
write_rite_binary_header(mrb_state *mrb, size_t binary_size, uint8_t *bin, uint8_t flags)
{
struct rite_binary_header *header = (struct rite_binary_header *)bin;
uint16_t crc;
uint32_t offset;
switch (flags & DUMP_ENDIAN_NAT) {
endian_big:
case DUMP_ENDIAN_BIG:
memcpy(header->binary_ident, RITE_BINARY_IDENT, sizeof(header->binary_ident));
break;
endian_little:
case DUMP_ENDIAN_LIL:
memcpy(header->binary_ident, RITE_BINARY_IDENT_LIL, sizeof(header->binary_ident));
break;
case DUMP_ENDIAN_NAT:
if (bigendian_p()) goto endian_big;
goto endian_little;
break;
}
memcpy(header->binary_version, RITE_BINARY_FORMAT_VER, sizeof(header->binary_version));
memcpy(header->compiler_name, RITE_COMPILER_NAME, sizeof(header->compiler_name));
memcpy(header->compiler_version, RITE_COMPILER_VERSION, sizeof(header->compiler_version));
mrb_assert(binary_size <= UINT32_MAX);
uint32_to_bin((uint32_t)binary_size, header->binary_size);
offset = (&(header->binary_crc[0]) - bin) + sizeof(uint16_t);
crc = calc_crc_16_ccitt(bin + offset, binary_size - offset, 0);
uint16_to_bin(crc, header->binary_crc);
return MRB_DUMP_OK;
}
static int
write_section_lv(mrb_state *mrb, mrb_irep *irep, uint8_t *start, mrb_sym const *syms, uint32_t const syms_len)
{
uint8_t *cur = start;
struct rite_section_lv_header *header;
ptrdiff_t diff;
int result = MRB_DUMP_OK;
if (mrb == NULL || cur == NULL) {
return MRB_DUMP_INVALID_ARGUMENT;
}
header = (struct rite_section_lv_header*)cur;
cur += sizeof(struct rite_section_lv_header);
result = write_lv_sym_table(mrb, &cur, syms, syms_len);
if (result != MRB_DUMP_OK) {
goto lv_section_exit;
}
result = write_lv_record(mrb, irep, &cur, syms, syms_len);
if (result != MRB_DUMP_OK) {
goto lv_section_exit;
}
memcpy(header->section_identify, RITE_SECTION_LV_IDENTIFIER, sizeof(header->section_identify));
diff = cur - start;
mrb_assert_int_fit(ptrdiff_t, diff, size_t, SIZE_MAX);
uint32_to_bin(diff, header->section_size);
lv_section_exit:
return result;
}
static int
write_syms_block(mrb_state *mrb, mrb_irep *irep, uint8_t *buf)
{
size_t sym_no;
uint8_t *cur = buf;
const char *name;
cur += uint32_to_bin(irep->slen, cur); /* number of symbol */
for (sym_no = 0; sym_no < irep->slen; sym_no++) {
if (irep->syms[sym_no] != 0) {
size_t len;
name = mrb_sym2name_len(mrb, irep->syms[sym_no], &len);
if (len > UINT16_MAX) {
return MRB_DUMP_GENERAL_FAILURE;
}
cur += uint16_to_bin((uint16_t)len, cur); /* length of symbol name */
memcpy(cur, name, len); /* symbol name */
cur += (uint16_t)len;
*cur++ = '\0';
}
else {
cur += uint16_to_bin(MRB_DUMP_NULL_SYM_LEN, cur); /* length of symbol name */
}
}
return (int)(cur - buf);
}
static size_t
write_lineno_record_1(mrb_state *mrb, mrb_irep *irep, uint8_t* bin)
{
uint8_t *cur = bin;
size_t iseq_no;
size_t filename_len;
ptrdiff_t diff;
cur += sizeof(uint32_t); /* record size */
if (irep->filename) {
filename_len = strlen(irep->filename);
} else {
filename_len = 0;
}
mrb_assert(filename_len <= UINT16_MAX);
cur += uint16_to_bin((uint16_t)filename_len, cur); /* filename size */
if (filename_len) {
memcpy(cur, irep->filename, filename_len);
cur += filename_len; /* filename */
}
if (irep->lines) {
mrb_assert(irep->ilen <= UINT32_MAX);
cur += uint32_to_bin((uint32_t)(irep->ilen), cur); /* niseq */
for (iseq_no = 0; iseq_no < irep->ilen; iseq_no++) {
cur += uint16_to_bin(irep->lines[iseq_no], cur); /* opcode */
}
}
else {
cur += uint32_to_bin(0, cur); /* niseq */
}
diff = cur - bin;
mrb_assert(diff >= 0);
mrb_assert(diff <= UINT32_MAX);
uint32_to_bin((uint32_t)diff, bin); /* record size */
mrb_assert((size_t)diff <= SIZE_MAX);
return (size_t)diff;
}
static int
write_section_lineno_header(mrb_state *mrb, size_t section_size, uint8_t *bin)
{
struct rite_section_lineno_header *header = (struct rite_section_lineno_header*)bin;
memcpy(header->section_identify, RITE_SECTION_LINENO_IDENTIFIER, sizeof(header->section_identify));
uint32_to_bin((uint32_t)section_size, header->section_size);
return MRB_DUMP_OK;
}
static int
write_section_irep_header(mrb_state *mrb, uint32_t section_size, uint8_t *bin)
{
struct rite_section_irep_header *header = (struct rite_section_irep_header*)bin;
memcpy(header->section_identify, RITE_SECTION_IREP_IDENTIFIER, sizeof(header->section_identify));
uint32_to_bin(section_size, header->section_size);
memcpy(header->rite_version, RITE_VM_VER, sizeof(header->rite_version));
return MRB_DUMP_OK;
}
static size_t
write_irep_header(mrb_state *mrb, mrb_irep *irep, uint8_t *buf)
{
uint8_t *cur = buf;
cur += uint32_to_bin(get_irep_record_size(mrb, irep), cur); /* record size */
cur += uint16_to_bin((uint16_t)irep->nlocals, cur); /* number of local variable */
cur += uint16_to_bin((uint16_t)irep->nregs, cur); /* number of register variable */
return (cur - buf);
}
static size_t
write_footer(mrb_state *mrb, uint8_t *bin)
{
struct rite_binary_footer footer;
memcpy(footer.section_identify, RITE_BINARY_EOF, sizeof(footer.section_identify));
uint32_to_bin(sizeof(struct rite_binary_footer), footer.section_size);
memcpy(bin, &footer, sizeof(struct rite_binary_footer));
return sizeof(struct rite_binary_footer);
}
static int
write_syms_block(mrb_state *mrb, mrb_irep *irep, uint8_t *buf)
{
int result;
size_t sym_no;
size_t buf_size;
uint8_t *cur = buf;
uint16_t nlen;
char *char_buf = NULL;
const char *name;
buf_size = MRB_DUMP_DEFAULT_STR_LEN;
char_buf = (char *)mrb_malloc(mrb, buf_size);
if (char_buf == NULL) {
result = MRB_DUMP_GENERAL_FAILURE;
goto error_exit;
}
cur += uint32_to_bin(irep->slen, cur); /* number of symbol */
for (sym_no = 0; sym_no < irep->slen; sym_no++) {
if (irep->syms[sym_no] != 0) {
size_t len;
name = mrb_sym2name_len(mrb, irep->syms[sym_no], &len);
if (len > UINT16_MAX) goto error_exit;
nlen = (uint16_t)len;
if (nlen > buf_size - 1) {
buf_size = nlen + 1;
char_buf = (char *)mrb_realloc(mrb, char_buf, buf_size);
if (char_buf == NULL) {
result = MRB_DUMP_GENERAL_FAILURE;
goto error_exit;
}
}
memset(char_buf, 0, buf_size);
memcpy(char_buf, name, len);
cur += uint16_to_bin(nlen, cur); /* length of symbol name */
memcpy(cur, char_buf, nlen); /* symbol name */
cur += nlen;
}
else {
cur += uint16_to_bin(MRB_DUMP_NULL_SYM_LEN, cur); /* length of symbol name */
}
}
result = (int)(cur - buf);
error_exit:
mrb_free(mrb, char_buf);
return result;
}
static int
write_section_irep_header(mrb_state *mrb, size_t section_size, uint8_t *bin)
{
struct rite_section_irep_header *header = (struct rite_section_irep_header*)bin;
memcpy(header->section_ident, RITE_SECTION_IREP_IDENT, sizeof(header->section_ident));
mrb_assert_int_fit(size_t, section_size, uint32_t, UINT32_MAX);
uint32_to_bin((uint32_t)section_size, header->section_size);
memcpy(header->rite_version, RITE_VM_VER, sizeof(header->rite_version));
return MRB_DUMP_OK;
}
static int
mrb_write_section_lineno_header(mrb_state *mrb, uint32_t section_size, uint16_t nirep, uint16_t sirep, uint8_t *bin)
{
struct rite_section_lineno_header *header = (struct rite_section_lineno_header*)bin;
// TODO
memcpy(header->section_identify, RITE_SECTION_LIENO_IDENTIFIER, sizeof(header->section_identify));
uint32_to_bin(section_size, header->section_size);
uint16_to_bin(nirep, header->nirep);
uint16_to_bin(sirep, header->sirep);
return MRB_DUMP_OK;
}
static ptrdiff_t
write_pool_block(mrb_state *mrb, mrb_irep *irep, uint8_t *buf)
{
size_t pool_no;
uint8_t *cur = buf;
uint16_t len;
mrb_value str;
const char *char_ptr;
cur += uint32_to_bin(irep->plen, cur); /* number of pool */
for (pool_no = 0; pool_no < irep->plen; pool_no++) {
int ai = mrb_gc_arena_save(mrb);
switch (mrb_type(irep->pool[pool_no])) {
case MRB_TT_FIXNUM:
cur += uint8_to_bin(IREP_TT_FIXNUM, cur); /* data type */
str = mrb_fixnum_to_str(mrb, irep->pool[pool_no], 10);
break;
case MRB_TT_FLOAT:
cur += uint8_to_bin(IREP_TT_FLOAT, cur); /* data type */
str = mrb_float_to_str(mrb, irep->pool[pool_no], MRB_FLOAT_FMT);
break;
case MRB_TT_STRING:
cur += uint8_to_bin(IREP_TT_STRING, cur); /* data type */
str = irep->pool[pool_no];
break;
default:
continue;
}
char_ptr = RSTRING_PTR(str);
{
mrb_int tlen = RSTRING_LEN(str);
mrb_assert_int_fit(mrb_int, tlen, uint16_t, UINT16_MAX);
len = (uint16_t)tlen;
}
cur += uint16_to_bin(len, cur); /* data length */
memcpy(cur, char_ptr, (size_t)len);
cur += len;
mrb_gc_arena_restore(mrb, ai);
}
return cur - buf;
}
static int
write_pool_block(mrb_state *mrb, mrb_irep *irep, uint8_t *buf)
{
size_t pool_no;
uint8_t *cur = buf;
size_t len;
mrb_value str;
const char *char_ptr;
char char_buf[30];
cur += uint32_to_bin(irep->plen, cur); /* number of pool */
for (pool_no = 0; pool_no < irep->plen; pool_no++) {
int ai = mrb_gc_arena_save(mrb);
cur += uint8_to_bin(mrb_type(irep->pool[pool_no]), cur); /* data type */
switch (mrb_type(irep->pool[pool_no])) {
case MRB_TT_FIXNUM:
str = mrb_fixnum_to_str(mrb, irep->pool[pool_no], 10);
char_ptr = RSTRING_PTR(str);
len = RSTRING_LEN(str);
break;
case MRB_TT_FLOAT:
len = mrb_float_to_str(char_buf, mrb_float(irep->pool[pool_no]));
char_ptr = &char_buf[0];
break;
case MRB_TT_STRING:
str = irep->pool[pool_no];
char_ptr = RSTRING_PTR(str);
len = RSTRING_LEN(str);
break;
default:
continue;
}
cur += uint16_to_bin(len, cur); /* data length */
memcpy(cur, char_ptr, len);
cur += len;
mrb_gc_arena_restore(mrb, ai);
}
return (int)(cur - buf);
}
static int
write_section_debug(mrb_state *mrb, mrb_irep *irep, uint8_t *cur)
{
uint32_t section_size = 0;
const uint8_t *bin = cur;
struct rite_section_debug_header *header;
mrb_sym *filenames;
size_t filenames_len = 0, i;
uint8_t *filenames_len_out;
uint32_t dlen;
if (mrb == NULL || cur == NULL) {
return MRB_DUMP_INVALID_ARGUMENT;
}
header = (struct rite_section_debug_header *)bin;
cur += sizeof(struct rite_section_debug_header);
section_size += sizeof(struct rite_section_debug_header);
// filename table
filenames = (mrb_sym *)mrb_malloc(mrb, sizeof(mrb_sym *) * 1);
filenames_len_out = cur;
cur += sizeof(uint16_t);
section_size += sizeof(uint16_t);
section_size += write_filename_table(mrb, irep, &cur, &filenames, &filenames_len);
for (i=0; i<irep->rlen; i++) {
section_size += write_filename_table(mrb, irep->reps[i], &cur, &filenames, &filenames_len);
}
uint16_to_bin(filenames_len, filenames_len_out);
// debug records
dlen = write_debug_record(mrb, irep, cur, filenames, filenames_len);
cur += dlen;
section_size += dlen;
for (i=0; i<irep->rlen; i++) {
dlen = write_debug_record(mrb, irep->reps[i], cur, filenames, filenames_len);
cur += dlen;
section_size += dlen;
}
memcpy(header->section_identify, RITE_SECTION_DEBUG_IDENTIFIER, sizeof(header->section_identify));
uint32_to_bin(section_size, header->section_size);
mrb_free(mrb, filenames);
return MRB_DUMP_OK;
}
static inline int
uint32_dump(uint32_t bin, char *hex, int type)
{
if (type == DUMP_TYPE_BIN) {
return (uint32_to_bin(bin, hex));
} else {
*hex++ = bin2hex[(bin >> 28) & 0x0f];
*hex++ = bin2hex[(bin >> 24) & 0x0f];
*hex++ = bin2hex[(bin >> 20) & 0x0f];
*hex++ = bin2hex[(bin >> 16) & 0x0f];
*hex++ = bin2hex[(bin >> 12) & 0x0f];
*hex++ = bin2hex[(bin >> 8) & 0x0f];
*hex++ = bin2hex[(bin >> 4) & 0x0f];
*hex = bin2hex[bin & 0x0f];
return DUMP_SIZE(MRB_DUMP_SIZE_OF_LONG, type);
}
}
static int
write_rite_binary_header(mrb_state *mrb, size_t binary_size, uint8_t *bin)
{
struct rite_binary_header *header = (struct rite_binary_header *)bin;
uint16_t crc;
size_t offset;
memcpy(header->binary_identify, RITE_BINARY_IDENTIFIER, sizeof(header->binary_identify));
memcpy(header->binary_version, RITE_BINARY_FORMAT_VER, sizeof(header->binary_version));
memcpy(header->compiler_name, RITE_COMPILER_NAME, sizeof(header->compiler_name));
memcpy(header->compiler_version, RITE_COMPILER_VERSION, sizeof(header->compiler_version));
uint32_to_bin(binary_size, header->binary_size);
offset = (&(header->binary_crc[0]) - bin) + sizeof(uint16_t);
crc = calc_crc_16_ccitt(bin + offset, binary_size - offset, 0);
uint16_to_bin(crc, header->binary_crc);
return MRB_DUMP_OK;
}
static int
write_lv_sym_table(mrb_state *mrb, uint8_t **start, mrb_sym const *syms, uint32_t syms_len)
{
uint8_t *cur = *start;
uint32_t i;
const char *str;
mrb_int str_len;
cur += uint32_to_bin(syms_len, cur);
for (i = 0; i < syms_len; ++i) {
str = mrb_sym2name_len(mrb, syms[i], &str_len);
cur += uint16_to_bin(str_len, cur);
memcpy(cur, str, str_len);
cur += str_len;
}
*start = cur;
return MRB_DUMP_OK;
}
static int
write_section_debug(mrb_state *mrb, mrb_irep *irep, uint8_t *cur, mrb_sym const *filenames, uint16_t filenames_len)
{
size_t section_size = 0;
const uint8_t *bin = cur;
struct rite_section_debug_header *header;
size_t dlen;
uint16_t i;
char const *sym; mrb_int sym_len;
if (mrb == NULL || cur == NULL) {
return MRB_DUMP_INVALID_ARGUMENT;
}
header = (struct rite_section_debug_header *)bin;
cur += sizeof(struct rite_section_debug_header);
section_size += sizeof(struct rite_section_debug_header);
/* filename table */
cur += uint16_to_bin(filenames_len, cur);
section_size += sizeof(uint16_t);
for (i = 0; i < filenames_len; ++i) {
sym = mrb_sym2name_len(mrb, filenames[i], &sym_len);
mrb_assert(sym);
cur += uint16_to_bin(sym_len, cur);
memcpy(cur, sym, sym_len);
cur += sym_len;
section_size += sizeof(uint16_t) + sym_len;
}
/* debug records */
dlen = write_debug_record(mrb, irep, cur, filenames, filenames_len);
section_size += dlen;
memcpy(header->section_identify, RITE_SECTION_DEBUG_IDENTIFIER, sizeof(header->section_identify));
mrb_assert(section_size <= INT32_MAX);
uint32_to_bin(section_size, header->section_size);
return MRB_DUMP_OK;
}
static int
write_pool_block(mrb_state *mrb, mrb_irep *irep, uint8_t *buf)
{
int result;
size_t pool_no;
uint8_t *cur = buf;
size_t buf_size, len;
mrb_value str;
char *char_buf = NULL;
buf_size = MRB_DUMP_DEFAULT_STR_LEN;
char_buf = (char *)mrb_malloc(mrb, buf_size);
if (char_buf == NULL) {
result = MRB_DUMP_GENERAL_FAILURE;
goto error_exit;
}
cur += uint32_to_bin(irep->plen, cur); /* number of pool */
for (pool_no = 0; pool_no < irep->plen; pool_no++) {
int ai = mrb_gc_arena_save(mrb);
cur += uint8_to_bin(mrb_type(irep->pool[pool_no]), cur); /* data type */
memset(char_buf, 0, buf_size);
switch (mrb_type(irep->pool[pool_no])) {
case MRB_TT_FIXNUM:
str = mrb_fix2str(mrb, irep->pool[pool_no], 10);
memcpy(char_buf, RSTRING_PTR(str), RSTRING_LEN(str));
len = RSTRING_LEN(str);
break;
case MRB_TT_FLOAT:
len = mrb_float_to_str(char_buf, mrb_float(irep->pool[pool_no]));
break;
case MRB_TT_STRING:
str = irep->pool[pool_no];
len = RSTRING_LEN(str);
if (len > buf_size - 1) {
buf_size = len + 1;
char_buf = (char *)mrb_realloc(mrb, char_buf, buf_size);
if (char_buf == NULL) {
mrb_gc_arena_restore(mrb, ai);
result = MRB_DUMP_GENERAL_FAILURE;
goto error_exit;
}
memset(char_buf, 0, buf_size);
}
memcpy(char_buf, RSTRING_PTR(str), RSTRING_LEN(str));
break;
default:
len = 0;
continue;
}
cur += uint16_to_bin(len, cur); /* data length */
memcpy(cur, char_buf, len);
cur += len;
mrb_gc_arena_restore(mrb, ai);
}
result = (int)(cur - buf);
error_exit:
mrb_free(mrb, char_buf);
return result;
}