Ignore:
Timestamp:
Jul 9, 2020, 8:51:43 AM (4 years ago)
Author:
coas-nagasima
Message:

mrubyを2.1.1に更新

Location:
EcnlProtoTool/trunk/mruby-2.1.1
Files:
1 edited
1 moved

Legend:

Unmodified
Added
Removed

  • EcnlProtoTool/trunk/mruby-2.1.1/src/load.c

    r331 r439  
    88#include <stdlib.h>
    99#include <string.h>
     10#include <math.h>
    1011#include <mruby/dump.h>
    1112#include <mruby/irep.h>
    … …  
    2526#define FLAG_SRC_STATIC 0
    2627
    27 #define SIZE_ERROR_MUL(nmemb, size) ((nmemb) > SIZE_MAX / (size))
     28#define SIZE_ERROR_MUL(nmemb, size) ((size_t)(nmemb) > SIZE_MAX / (size))
    2829
    2930static size_t
    … …  
    4142}
    4243
     44#ifndef MRB_WITHOUT_FLOAT
     45double mrb_str_len_to_dbl(mrb_state *mrb, const char *s, size_t len, mrb_bool badcheck);
     46
     47static double
     48str_to_double(mrb_state *mrb, const char *p, size_t len)
     49{
     50  /* `i`, `inf`, `infinity` */
     51  if (len > 0 && p[0] == 'i') return INFINITY;
     52
     53  /* `I`, `-inf`, `-infinity` */
     54  if (p[0] == 'I' || (len > 1 && p[0] == '-' && p[1] == 'i')) return -INFINITY;
     55  return mrb_str_len_to_dbl(mrb, p, len, TRUE);
     56}
     57#endif
     58
     59mrb_value mrb_str_len_to_inum(mrb_state *mrb, const char *str, mrb_int len, mrb_int base, int badcheck);
     60
    4361static mrb_irep*
    4462read_irep_record_1(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flags)
    4563{
    46   size_t i;
     64  int i;
    4765  const uint8_t *src = bin;
    4866  ptrdiff_t diff;
    4967  uint16_t tt, pool_data_len, snl;
    50   size_t plen;
     68  int plen;
    5169  int ai = mrb_gc_arena_save(mrb);
    5270  mrb_irep *irep = mrb_add_irep(mrb);
    … …  
    6987  /* Binary Data Section */
    7088  /* ISEQ BLOCK */
    71   irep->ilen = (size_t)bin_to_uint32(src);
     89  irep->ilen = (uint16_t)bin_to_uint32(src);
    7290  src += sizeof(uint32_t);
    7391  src += skip_padding(src);
    … …  
    8098        (flags & FLAG_BYTEORDER_NATIVE)) {
    8199      irep->iseq = (mrb_code*)src;
    82       src += sizeof(uint32_t) * irep->ilen;
     100      src += sizeof(mrb_code) * irep->ilen;
    83101      irep->flags |= MRB_ISEQ_NO_FREE;
    84102    }
    85103    else {
    86       irep->iseq = (mrb_code *)mrb_malloc(mrb, sizeof(mrb_code) * irep->ilen);
    87       if (flags & FLAG_BYTEORDER_NATIVE) {
    88         memcpy(irep->iseq, src, sizeof(uint32_t) * irep->ilen);
    89         src += sizeof(uint32_t) * irep->ilen;
    90       }
    91       else if (flags & FLAG_BYTEORDER_BIG) {
    92         for (i = 0; i < irep->ilen; i++) {
    93           irep->iseq[i] = (mrb_code)bin_to_uint32(src);     /* iseq */
    94           src += sizeof(uint32_t);
    95         }
    96       }
    97       else {
    98         for (i = 0; i < irep->ilen; i++) {
    99           irep->iseq[i] = (mrb_code)bin_to_uint32l(src);     /* iseq */
    100           src += sizeof(uint32_t);
    101         }
    102       }
     104      size_t data_len = sizeof(mrb_code) * irep->ilen;
     105      void *buf = mrb_malloc(mrb, data_len);
     106      irep->iseq = (mrb_code *)buf;
     107      memcpy(buf, src, data_len);
     108      src += data_len;
    103109    }
    104110  }
    105111
    106112  /* POOL BLOCK */
    107   plen = (size_t)bin_to_uint32(src); /* number of pool */
     113  plen = bin_to_uint32(src); /* number of pool */
    108114  src += sizeof(uint32_t);
    109115  if (plen > 0) {
    … …  
    114120
    115121    for (i = 0; i < plen; i++) {
    116       mrb_value s;
     122      const char *s;
     123      mrb_bool st = (flags & FLAG_SRC_MALLOC)==0;
    117124
    118125      tt = *src++; /* pool TT */
    119126      pool_data_len = bin_to_uint16(src); /* pool data length */
    120127      src += sizeof(uint16_t);
    121       if (flags & FLAG_SRC_MALLOC) {
    122         s = mrb_str_new(mrb, (char *)src, pool_data_len);
    123       }
    124       else {
    125         s = mrb_str_new_static(mrb, (char *)src, pool_data_len);
    126       }
     128      s = (const char*)src;
    127129      src += pool_data_len;
    128130      switch (tt) { /* pool data */
    129       case IREP_TT_FIXNUM:
    130         irep->pool[i] = mrb_str_to_inum(mrb, s, 10, FALSE);
     131      case IREP_TT_FIXNUM: {
     132        mrb_value num = mrb_str_len_to_inum(mrb, s, pool_data_len, 10, FALSE);
     133#ifdef MRB_WITHOUT_FLOAT
     134        irep->pool[i] = num;
     135#else
     136        irep->pool[i] = mrb_float_p(num)? mrb_float_pool(mrb, mrb_float(num)) : num;
     137#endif
     138        }
    131139        break;
    132140
     141#ifndef MRB_WITHOUT_FLOAT
    133142      case IREP_TT_FLOAT:
    134         irep->pool[i] = mrb_float_pool(mrb, mrb_str_to_dbl(mrb, s, FALSE));
     143        irep->pool[i] = mrb_float_pool(mrb, str_to_double(mrb, s, pool_data_len));
    135144        break;
     145#endif
    136146
    137147      case IREP_TT_STRING:
    138         irep->pool[i] = mrb_str_pool(mrb, s);
     148        irep->pool[i] = mrb_str_pool(mrb, s, pool_data_len, st);
    139149        break;
    140150
    … …  
    150160
    151161  /* SYMS BLOCK */
    152   irep->slen = (size_t)bin_to_uint32(src);  /* syms length */
     162  irep->slen = (uint16_t)bin_to_uint32(src);  /* syms length */
    153163  src += sizeof(uint32_t);
    154164  if (irep->slen > 0) {
    … …  
    192202{
    193203  mrb_irep *irep = read_irep_record_1(mrb, bin, len, flags);
    194   size_t i;
     204  int i;
    195205
    196206  if (irep == NULL) {
    … …  
    222232
    223233static int
    224 read_lineno_record_1(mrb_state *mrb, const uint8_t *bin, mrb_irep *irep, size_t *len)
    225 {
    226   size_t i, fname_len, niseq;
    227   char *fname;
    228   uint16_t *lines;
    229 
    230   *len = 0;
    231   bin += sizeof(uint32_t); /* record size */
    232   *len += sizeof(uint32_t);
    233   fname_len = bin_to_uint16(bin);
    234   bin += sizeof(uint16_t);
    235   *len += sizeof(uint16_t);
    236   fname = (char *)mrb_malloc(mrb, fname_len + 1);
    237   memcpy(fname, bin, fname_len);
    238   fname[fname_len] = '\0';
    239   bin += fname_len;
    240   *len += fname_len;
    241 
    242   niseq = (size_t)bin_to_uint32(bin);
    243   bin += sizeof(uint32_t); /* niseq */
    244   *len += sizeof(uint32_t);
    245 
    246   if (SIZE_ERROR_MUL(niseq, sizeof(uint16_t))) {
    247     return MRB_DUMP_GENERAL_FAILURE;
    248   }
    249   lines = (uint16_t *)mrb_malloc(mrb, niseq * sizeof(uint16_t));
    250   for (i = 0; i < niseq; i++) {
    251     lines[i] = bin_to_uint16(bin);
    252     bin += sizeof(uint16_t); /* niseq */
    253     *len += sizeof(uint16_t);
    254   }
    255 
    256   irep->filename = fname;
    257   irep->lines = lines;
    258   return MRB_DUMP_OK;
    259 }
    260 
    261 static int
    262 read_lineno_record(mrb_state *mrb, const uint8_t *bin, mrb_irep *irep, size_t *lenp)
    263 {
    264   int result = read_lineno_record_1(mrb, bin, irep, lenp);
    265   size_t i;
    266 
    267   if (result != MRB_DUMP_OK) return result;
    268   for (i = 0; i < irep->rlen; i++) {
    269     size_t len;
    270 
    271     result = read_lineno_record(mrb, bin, irep->reps[i], &len);
    272     if (result != MRB_DUMP_OK) break;
    273     bin += len;
    274     *lenp += len;
    275   }
    276   return result;
    277 }
    278 
    279 static int
    280 read_section_lineno(mrb_state *mrb, const uint8_t *bin, mrb_irep *irep)
    281 {
    282   size_t len;
    283 
    284   len = 0;
    285   bin += sizeof(struct rite_section_lineno_header);
    286 
    287   /* Read Binary Data Section */
    288   return read_lineno_record(mrb, bin, irep, &len);
    289 }
    290 
    291 static int
    292234read_debug_record(mrb_state *mrb, const uint8_t *start, mrb_irep* irep, size_t *record_len, const mrb_sym *filenames, size_t filenames_len)
    293235{
    294236  const uint8_t *bin = start;
    295237  ptrdiff_t diff;
    296   size_t record_size, i;
     238  size_t record_size;
    297239  uint16_t f_idx;
     240  int i;
    298241
    299242  if (irep->debug_info) { return MRB_DUMP_INVALID_IREP; }
    300243
    301244  irep->debug_info = (mrb_irep_debug_info*)mrb_malloc(mrb, sizeof(mrb_irep_debug_info));
    302   irep->debug_info->pc_count = irep->ilen;
     245  irep->debug_info->pc_count = (uint32_t)irep->ilen;
    303246
    304247  record_size = (size_t)bin_to_uint32(bin);
    … …  
    312255    mrb_irep_debug_info_file *file;
    313256    uint16_t filename_idx;
    314     mrb_int len;
    315257
    316258    file = (mrb_irep_debug_info_file *)mrb_malloc(mrb, sizeof(*file));
    … …  
    325267    mrb_assert(filename_idx < filenames_len);
    326268    file->filename_sym = filenames[filename_idx];
    327     len = 0;
    328     file->filename = mrb_sym2name_len(mrb, file->filename_sym, &len);
    329269
    330270    file->line_entry_count = bin_to_uint32(bin);
    … …  
    433373{
    434374  const uint8_t *bin = start;
    435   size_t i;
    436375  ptrdiff_t diff;
     376  int i;
    437377
    438378  irep->lv = (struct mrb_locals*)mrb_malloc(mrb, sizeof(struct mrb_locals) * (irep->nlocals - 1));
    … …  
    517457
    518458static int
    519 read_binary_header(const uint8_t *bin, size_t *bin_size, uint16_t *crc, uint8_t *flags)
     459read_binary_header(const uint8_t *bin, size_t bufsize, size_t *bin_size, uint16_t *crc, uint8_t *flags)
    520460{
    521461  const struct rite_binary_header *header = (const struct rite_binary_header *)bin;
     462
     463  if (bufsize < sizeof(struct rite_binary_header)) {
     464    return MRB_DUMP_READ_FAULT;
     465  }
    522466
    523467  if (memcmp(header->binary_ident, RITE_BINARY_IDENT, sizeof(header->binary_ident)) == 0) {
    … …  
    537481  }
    538482
     483  if (memcmp(header->binary_version, RITE_BINARY_FORMAT_VER, sizeof(header->binary_version)) != 0) {
     484    return MRB_DUMP_INVALID_FILE_HEADER;
     485  }
     486
    539487  if (crc) {
    540488    *crc = bin_to_uint16(header->binary_crc);
    … …  
    542490  *bin_size = (size_t)bin_to_uint32(header->binary_size);
    543491
     492  if (bufsize < *bin_size) {
     493    return MRB_DUMP_READ_FAULT;
     494  }
     495
    544496  return MRB_DUMP_OK;
    545497}
    546498
    547499static mrb_irep*
    548 read_irep(mrb_state *mrb, const uint8_t *bin, uint8_t flags)
     500read_irep(mrb_state *mrb, const uint8_t *bin, size_t bufsize, uint8_t flags)
    549501{
    550502  int result;
    … …  
    559511  }
    560512
    561   result = read_binary_header(bin, &bin_size, &crc, &flags);
     513  result = read_binary_header(bin, bufsize, &bin_size, &crc, &flags);
    562514  if (result != MRB_DUMP_OK) {
    563515    return NULL;
    … …  
    576528      if (!irep) return NULL;
    577529    }
    578     else if (memcmp(section_header->section_ident, RITE_SECTION_LINENO_IDENT, sizeof(section_header->section_ident)) == 0) {
    579       if (!irep) return NULL;   /* corrupted data */
    580       result = read_section_lineno(mrb, bin, irep);
    581       if (result < MRB_DUMP_OK) {
    582         return NULL;
    583       }
    584     }
    585530    else if (memcmp(section_header->section_ident, RITE_SECTION_DEBUG_IDENT, sizeof(section_header->section_ident)) == 0) {
    586531      if (!irep) return NULL;   /* corrupted data */
    … …  
    606551mrb_read_irep(mrb_state *mrb, const uint8_t *bin)
    607552{
    608 #ifdef MRB_USE_ETEXT_EDATA
     553#if defined(MRB_USE_LINK_TIME_RO_DATA_P) || defined(MRB_USE_CUSTOM_RO_DATA_P)
    609554  uint8_t flags = mrb_ro_data_p((char*)bin) ? FLAG_SRC_STATIC : FLAG_SRC_MALLOC;
    610555#else
    … …  
    612557#endif
    613558
    614   return read_irep(mrb, bin, flags);
     559  return read_irep(mrb, bin, (size_t)-1, flags);
     560}
     561
     562MRB_API mrb_irep*
     563mrb_read_irep_buf(mrb_state *mrb, const void *buf, size_t bufsize)
     564{
     565  return read_irep(mrb, (const uint8_t *)buf, bufsize, FLAG_SRC_MALLOC);
    615566}
    616567
    … …  
    623574}
    624575
    625 MRB_API mrb_value
    626 mrb_load_irep_cxt(mrb_state *mrb, const uint8_t *bin, mrbc_context *c)
    627 {
    628   mrb_irep *irep = mrb_read_irep(mrb, bin);
     576void mrb_codedump_all(mrb_state*, struct RProc*);
     577
     578static mrb_value
     579load_irep(mrb_state *mrb, mrb_irep *irep, mrbc_context *c)
     580{
    629581  struct RProc *proc;
    630582
    … …  
    634586  }
    635587  proc = mrb_proc_new(mrb, irep);
     588  proc->c = NULL;
    636589  mrb_irep_decref(mrb, irep);
     590  if (c && c->dump_result) mrb_codedump_all(mrb, proc);
    637591  if (c && c->no_exec) return mrb_obj_value(proc);
    638592  return mrb_top_run(mrb, proc, mrb_top_self(mrb), 0);
    … …  
    640594
    641595MRB_API mrb_value
     596mrb_load_irep_cxt(mrb_state *mrb, const uint8_t *bin, mrbc_context *c)
     597{
     598  return load_irep(mrb, mrb_read_irep(mrb, bin), c);
     599}
     600
     601MRB_API mrb_value
     602mrb_load_irep_buf_cxt(mrb_state *mrb, const void *buf, size_t bufsize, mrbc_context *c)
     603{
     604  return load_irep(mrb, mrb_read_irep_buf(mrb, buf, bufsize), c);
     605}
     606
     607MRB_API mrb_value
    642608mrb_load_irep(mrb_state *mrb, const uint8_t *bin)
    643609{
    644610  return mrb_load_irep_cxt(mrb, bin, NULL);
     611}
     612
     613MRB_API mrb_value
     614mrb_load_irep_buf(mrb_state *mrb, const void *buf, size_t bufsize)
     615{
     616  return mrb_load_irep_buf_cxt(mrb, buf, bufsize, NULL);
    645617}
    646618
    … …  
    665637    goto irep_exit;
    666638  }
    667   result = read_binary_header(buf, &buf_size, NULL, &flags);
     639  result = read_binary_header(buf, (size_t)-1, &buf_size, NULL, &flags);
    668640  if (result != MRB_DUMP_OK || buf_size <= header_size) {
    669641    goto irep_exit;
    … …  
    674646    goto irep_exit;
    675647  }
    676   irep = read_irep(mrb, buf, FLAG_SRC_MALLOC);
     648  irep = read_irep(mrb, buf, (size_t)-1, FLAG_SRC_MALLOC);
    677649
    678650irep_exit:
    … …  
    681653}
    682654
    683 void mrb_codedump_all(mrb_state*, struct RProc*);
    684 
    685655MRB_API mrb_value
    686656mrb_load_irep_file_cxt(mrb_state *mrb, FILE* fp, mrbc_context *c)
    687657{
    688   mrb_irep *irep = mrb_read_irep_file(mrb, fp);
    689   mrb_value val;
    690   struct RProc *proc;
    691 
    692   if (!irep) {
    693     irep_error(mrb);
    694     return mrb_nil_value();
    695   }
    696   proc = mrb_proc_new(mrb, irep);
    697   mrb_irep_decref(mrb, irep);
    698   if (c && c->dump_result) mrb_codedump_all(mrb, proc);
    699   if (c && c->no_exec) return mrb_obj_value(proc);
    700   val = mrb_top_run(mrb, proc, mrb_top_self(mrb), 0);
    701   return val;
     658  return load_irep(mrb, mrb_read_irep_file(mrb, fp), c);
    702659}
    703660
Note: See TracChangeset for help on using the changeset viewer.