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

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 intwrite_lv_record(mrb_state *mrb, const mrb_irep *irep, uint8_t **start, mrb_sym const *syms, uint32_t syms_len){  uint8_t *cur = *start;  size_t i;  for (i = 0; i + 1 < irep->nlocals; ++i) {    if (irep->lv[i].name == 0) {      cur += uint16_to_bin(RITE_LV_NULL_MARK, cur);      cur += uint16_to_bin(0, cur);    }    else {      int const sym_idx = find_filename_index(syms, syms_len, irep->lv[i].name);      mrb_assert(sym_idx != -1); /* local variable name must be in syms */      cur += uint16_to_bin(sym_idx, cur);      cur += uint16_to_bin(irep->lv[i].r, cur);    }  }  for (i = 0; i < irep->rlen; ++i) {    write_lv_record(mrb, irep->reps[i], &cur, syms, syms_len);  }  *start = cur;  return MRB_DUMP_OK;}

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 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 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 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 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_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 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 intmrb_write_section_irep_header(mrb_state *mrb, uint32_t section_size, uint16_t nirep, uint16_t sirep, 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));  uint16_to_bin(nirep, header->nirep);  uint16_to_bin(sirep, header->sirep);  return MRB_DUMP_OK;}

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_filename_table(mrb_state *mrb, mrb_irep *irep, uint8_t **cp, mrb_sym **fp, size_t *lp){  uint8_t *cur = *cp;  mrb_sym *filenames = *fp;  size_t file_i;  uint16_t fn_len;  size_t size = 0;  mrb_irep_debug_info *debug_info = irep->debug_info;  for (file_i = 0; file_i < debug_info->flen; ++file_i) {    mrb_irep_debug_info_file *file = debug_info->files[file_i];    if (find_filename_index(filenames, *lp, file->filename_sym) != -1) continue;    // register filename    *lp += 1;    *fp = filenames = (mrb_sym*)mrb_realloc(mrb, filenames, sizeof(mrb_sym) * (*lp));    filenames[*lp - 1] = file->filename_sym;    // filename    fn_len = (uint16_t)strlen(file->filename);    cur += uint16_to_bin(fn_len, cur);    memcpy(cur, file->filename, fn_len);    cur += fn_len;    size += sizeof(uint16_t) + fn_len;  }  *cp = cur;  return size;}

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_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 inline intuint16_dump(uint16_t bin, char *hex, int type){  if (type == DUMP_TYPE_BIN) {    return (uint16_to_bin(bin, hex));  } else {    *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_SHORT, type);  }}

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 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 intload_rite_irep_record(mrb_state *mrb, RiteFILE* rfp, unsigned char* dst, uint32_t* len){  int i;  uint32_t blocklen;  uint16_t offset, pdl, snl, clen;  unsigned char hex2[2], hex4[4], hex8[8], hcrc[4];  unsigned char *pStart;  char *char_buf;  uint16_t buf_size =0;  buf_size = MRB_DUMP_DEFAULT_STR_LEN;  if ((char_buf = (char *)mrb_malloc(mrb, buf_size)) == NULL)    goto error_exit;  pStart = dst;  //IREP HEADER BLOCK  *dst = rite_fgetc(rfp, TRUE);                         //record identifier  if (*dst != RITE_IREP_IDENFIFIER)    return MRB_DUMP_INVALID_IREP;  dst += sizeof(unsigned char);  *dst = rite_fgetc(rfp, TRUE);                         //class or module  dst += sizeof(unsigned char);  rite_fgets(rfp, hex4, sizeof(hex4), TRUE);            //number of local variable  dst += hex_to_bin16(dst, hex4);  rite_fgets(rfp, hex4, sizeof(hex4), TRUE);            //number of register variable  dst += hex_to_bin16(dst, hex4);  rite_fgets(rfp, hex4, sizeof(hex4), TRUE);            //offset of isec block  offset = hex_to_uint16(hex4);  rite_fgets(rfp, hcrc, sizeof(hcrc), TRUE);            //header CRC  memset( char_buf, '/0', buf_size);  rite_fgets(rfp, (unsigned char*)char_buf, (offset - (MRB_DUMP_SIZE_OF_SHORT * RITE_FILE_HEX_SIZE)), TRUE); //class or module name  hex_to_str(char_buf, (char*)(dst + MRB_DUMP_SIZE_OF_SHORT + MRB_DUMP_SIZE_OF_SHORT), &clen); //class or module name  dst += uint16_to_bin((MRB_DUMP_SIZE_OF_SHORT/*crc*/ + clen), (char*)dst); //offset of isec block  dst += hex_to_bin16(dst, hcrc);                 //header CRC  dst += clen;  //ISEQ BLOCK  rite_fgets(rfp, hex8, sizeof(hex8), TRUE);            //iseq length  dst += hex_to_bin32(dst, hex8);  blocklen = hex_to_uint32(hex8);  for (i=0; i<blocklen; i++) {    rite_fgets(rfp, hex8, sizeof(hex8), TRUE);          //iseq    dst += hex_to_bin32(dst, hex8);  }  rite_fgets(rfp, hcrc, sizeof(hcrc), TRUE);            //iseq CRC  dst += hex_to_bin16(dst, hcrc);  //POOL BLOCK  rite_fgets(rfp, hex8, sizeof(hex8), TRUE);            //pool length  dst += hex_to_bin32(dst, hex8);  blocklen = hex_to_uint32(hex8);  for (i=0; i<blocklen; i++) {    rite_fgets(rfp, hex2, sizeof(hex2), TRUE);          //TT    dst += hex_to_bin8(dst, hex2);    rite_fgets(rfp, hex4, sizeof(hex4), TRUE);          //pool data length    pdl = hex_to_uint16(hex4);    if ( pdl > buf_size - 1) {      buf_size = pdl + 1;      if ((char_buf = (char *)mrb_realloc(mrb, char_buf, buf_size)) == NULL)        goto error_exit;    }    memset(char_buf, '/0', buf_size);    rite_fgets(rfp, (unsigned char*)char_buf, pdl, FALSE); //pool    hex_to_str(char_buf, (char*)(dst + MRB_DUMP_SIZE_OF_SHORT), &clen);    dst += uint16_to_bin(clen, (char*)dst);    dst += clen;  }  rite_fgets(rfp, hcrc, sizeof(hcrc), TRUE);            //pool CRC  dst += hex_to_bin16(dst, hcrc);  //SYMS BLOCK  rite_fgets(rfp, hex8, sizeof(hex8), TRUE);            //syms length  dst += hex_to_bin32(dst, hex8);  blocklen = hex_to_uint32(hex8);  for (i=0; i<blocklen; i++) {    rite_fgets(rfp, hex4, sizeof(hex4), TRUE);          //symbol name length    snl = hex_to_uint16(hex4);    if (snl == MRB_DUMP_NULL_SYM_LEN) {      dst += uint16_to_bin(snl, (char*)dst);      continue;    }    if ( snl > buf_size - 1) {      buf_size = snl + 1;      if ((char_buf = (char *)mrb_realloc(mrb, char_buf, buf_size)) == NULL)        goto error_exit;    }    memset(char_buf, '/0', buf_size);    rite_fgets(rfp, (unsigned char*)char_buf, snl, FALSE); //symbol name    hex_to_str(char_buf, (char*)(dst + MRB_DUMP_SIZE_OF_SHORT), &clen);    dst += uint16_to_bin(clen, (char*)dst);    dst += clen;  }  rite_fgets(rfp, hcrc, sizeof(hcrc), TRUE);            //syms CRC  dst += hex_to_bin16(dst, hcrc);//.........这里部分代码省略.........

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;}