自学教程：C++ uint32_to_bin函数代码示例

static ptrdiff_twrite_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 intwrite_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_twrite_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 intwrite_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 intwrite_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_twrite_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 intwrite_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 intwrite_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 intwrite_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_twrite_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 intwrite_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 intwrite_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_twrite_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_twrite_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 intwrite_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 intwrite_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 intmrb_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_twrite_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 intwrite_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 intwrite_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 intuint32_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 intwrite_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 intwrite_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 intwrite_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 intwrite_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;}