コード例 #1
0
ファイル: load.c プロジェクト: Ancurio/mruby
static mrb_irep*
read_irep_record_file(mrb_state *mrb, FILE *fp)
{
  uint8_t header[1 + 4];
  const size_t record_header_size = sizeof(header);
  size_t buf_size, i;
  size_t len;
  mrb_irep *irep = NULL;
  void *ptr;
  uint8_t *buf;

  if (fread(header, record_header_size, 1, fp) == 0) {
    return NULL;
  }
  buf_size = (size_t)bin_to_uint32(&header[0]);
  if (SIZE_ERROR(buf_size)) {
    return NULL;
  }
  ptr = mrb_malloc(mrb, buf_size);
  buf = (uint8_t *)ptr;
  memcpy(buf, header, record_header_size);
  if (fread(&buf[record_header_size], buf_size - record_header_size, 1, fp) == 0) {
    return NULL;
  }
  irep = read_irep_record_1(mrb, buf, &len, TRUE);
  mrb_free(mrb, ptr);
  if (!irep) return NULL;
  for (i=0; i<irep->rlen; i++) {
    irep->reps[i] = read_irep_record_file(mrb, fp);
    if (!irep->reps[i]) return NULL;
  }
  return irep;
}
コード例 #2
0
ファイル: load.c プロジェクト: Ancurio/mruby
static int
read_lineno_record_file(mrb_state *mrb, FILE *fp, mrb_irep *irep)
{
  uint8_t header[4];
  const size_t record_header_size = sizeof(header);
  int result;
  size_t i, buf_size;
  size_t len;
  void *ptr;
  uint8_t *buf;

  if (fread(header, record_header_size, 1, fp) == 0) {
    return MRB_DUMP_READ_FAULT;
  }
  buf_size = (size_t)bin_to_uint32(&header[0]);
  if (SIZE_ERROR(buf_size)) {
    return MRB_DUMP_GENERAL_FAILURE;
  }
  ptr = mrb_malloc(mrb, buf_size);
  buf = (uint8_t *)ptr;

  if (fread(&buf[record_header_size], buf_size - record_header_size, 1, fp) == 0) {
    return MRB_DUMP_READ_FAULT;
  }
  result = read_lineno_record_1(mrb, buf, irep, &len);
  mrb_free(mrb, ptr);
  if (result != MRB_DUMP_OK) return result;
  for (i = 0; i < irep->rlen; i++) {
    result = read_lineno_record_file(mrb, fp, irep->reps[i]);
    if (result != MRB_DUMP_OK) break;
  }
  return result;
}
コード例 #3
0
ファイル: load.c プロジェクト: plounze/mruby
static int
read_rite_lineno_record(mrb_state *mrb, const uint8_t *bin, size_t irepno, uint32_t *len)
{
  int ret;
  size_t i, fname_len, niseq;
  char *fname;
  uint16_t *lines;

  ret = MRB_DUMP_OK;
  *len = 0;
  bin += sizeof(uint32_t); // record size
  *len += sizeof(uint32_t);
  fname_len = bin_to_uint16(bin);
  bin += sizeof(uint16_t);
  *len += sizeof(uint16_t);
  if (SIZE_ERROR(fname_len + 1)) {
    ret = MRB_DUMP_GENERAL_FAILURE;
    goto error_exit;
  }
  fname = (char *)mrb_malloc(mrb, fname_len + 1);
  if (fname == NULL) {
    ret = MRB_DUMP_GENERAL_FAILURE;
    goto error_exit;
  }
  memcpy(fname, bin, fname_len);
  fname[fname_len] = '\0';
  bin += fname_len;
  *len += fname_len;

  niseq = bin_to_uint32(bin);
  bin += sizeof(uint32_t); // niseq
  *len += sizeof(uint32_t);

  if (SIZE_ERROR_MUL(niseq, sizeof(uint16_t))) {
    ret = MRB_DUMP_GENERAL_FAILURE;
    goto error_exit;
  }
  lines = (uint16_t *)mrb_malloc(mrb, niseq * sizeof(uint16_t));
  if (lines == NULL) {
    ret = MRB_DUMP_GENERAL_FAILURE;
    goto error_exit;
  }
  for (i = 0; i < niseq; i++) {
    lines[i] = bin_to_uint16(bin);
    bin += sizeof(uint16_t); // niseq
    *len += sizeof(uint16_t);
 }

  mrb->irep[irepno]->filename = fname;
  mrb->irep[irepno]->lines = lines;

error_exit:

  return ret;
}
コード例 #4
0
ファイル: load.c プロジェクト: nin2/mruby
static int
read_lineno_record_1(mrb_state *mrb, const uint8_t *bin, mrb_irep *irep, uint32_t *len)
{
  int ret;
  size_t i, fname_len, niseq;
  char *fname;
  uint16_t *lines;

  ret = MRB_DUMP_OK;
  *len = 0;
  bin += sizeof(uint32_t); /* record size */
  *len += sizeof(uint32_t);
  fname_len = bin_to_uint16(bin);
  bin += sizeof(uint16_t);
  *len += sizeof(uint16_t);
  if (SIZE_ERROR(fname_len + 1)) {
    return MRB_DUMP_GENERAL_FAILURE;
  }
  fname = (char *)mrb_malloc(mrb, fname_len + 1);
  if (fname == NULL) {
    return MRB_DUMP_GENERAL_FAILURE;
  }
  memcpy(fname, bin, fname_len);
  fname[fname_len] = '\0';
  bin += fname_len;
  *len += fname_len;

  niseq = bin_to_uint32(bin);
  bin += sizeof(uint32_t); /* niseq */
  *len += sizeof(uint32_t);

  if (SIZE_ERROR_MUL(niseq, sizeof(uint16_t))) {
    return MRB_DUMP_GENERAL_FAILURE;
  }
  lines = (uint16_t *)mrb_malloc(mrb, niseq * sizeof(uint16_t));
  if (lines == NULL) {
    return MRB_DUMP_GENERAL_FAILURE;
  }
  for (i = 0; i < niseq; i++) {
    lines[i] = bin_to_uint16(bin);
    bin += sizeof(uint16_t); /* niseq */
    *len += sizeof(uint16_t);
  }

  irep->filename = fname;
  irep->lines = lines;
  return ret;
}
コード例 #5
0
ファイル: load.c プロジェクト: plounze/mruby
static int32_t
read_rite_section_irep_file(mrb_state *mrb, FILE *fp)
{
  int32_t result;
  size_t sirep;
  uint16_t nirep;
  uint16_t n;
  uint32_t len, buf_size;
  uint8_t *buf = NULL;
  const size_t record_header_size = 1 + 4;
  struct rite_section_irep_header header;

  if (fread(&header, sizeof(struct rite_section_irep_header), 1, fp) == 0) {
    return MRB_DUMP_READ_FAULT;
  }

  sirep = mrb->irep_len;
  nirep = bin_to_uint16(header.nirep);

  buf_size = record_header_size;
  /* You don't need use SIZE_ERROR as buf_size is enough small. */
  buf = (uint8_t *)mrb_malloc(mrb, buf_size);
  if (!buf) {
    result = MRB_DUMP_GENERAL_FAILURE;
    goto error_exit;
  }

  //Read Binary Data Section
  for (n = 0; n < nirep; n++) {
    void *ptr;

    if (fread(buf, record_header_size, 1, fp) == 0) {
      result = MRB_DUMP_READ_FAULT;
      goto error_exit;
    }
    buf_size = bin_to_uint32(&buf[0]);
    if (SIZE_ERROR(buf_size)) {
      result = MRB_DUMP_GENERAL_FAILURE;
      goto error_exit;
    }
    ptr = mrb_realloc(mrb, buf, buf_size);
    if (!ptr) {
      result = MRB_DUMP_GENERAL_FAILURE;
      goto error_exit;
    }
    buf = (uint8_t *)ptr;

    if (fread(&buf[record_header_size], buf_size - record_header_size, 1, fp) == 0) {
      result = MRB_DUMP_READ_FAULT;
      goto error_exit;
    }
    result = read_rite_irep_record(mrb, buf, &len);
    if (result != MRB_DUMP_OK)
      goto error_exit;
  }

  result = nirep;
error_exit:
  if (buf) {
    mrb_free(mrb, buf);
  }
  if (result < MRB_DUMP_OK) {
    irep_free(sirep, mrb);
  }
  return result;
}