summaryrefslogtreecommitdiffhomepage
path: root/src/load.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/load.c')
-rw-r--r--src/load.c720
1 files changed, 407 insertions, 313 deletions
diff --git a/src/load.c b/src/load.c
index 092ddbde8..d97776a16 100644
--- a/src/load.c
+++ b/src/load.c
@@ -4,18 +4,15 @@
** See Copyright Notice in mruby.h
*/
-#ifndef SIZE_MAX
- /* Some versions of VC++
- * has SIZE_MAX in stdint.h
- */
-# include <limits.h>
-#endif
+#include <limits.h>
#include <stdlib.h>
#include <string.h>
#include "mruby/dump.h"
#include "mruby/irep.h"
#include "mruby/proc.h"
#include "mruby/string.h"
+#include "mruby/debug.h"
+#include "mruby/error.h"
#if !defined(_WIN32) && SIZE_MAX < UINT32_MAX
# define SIZE_ERROR_MUL(x, y) ((x) > SIZE_MAX / (y))
@@ -29,30 +26,9 @@
# error This code assumes CHAR_BIT == 8
#endif
-static void
-irep_free(size_t sirep, mrb_state *mrb)
-{
- size_t i;
- void *p;
-
- for (i = sirep; i < mrb->irep_len; i++) {
- if (mrb->irep[i]) {
- p = mrb->irep[i]->iseq;
- if (p)
- mrb_free(mrb, p);
-
- p = mrb->irep[i]->pool;
- if (p)
- mrb_free(mrb, p);
-
- p = mrb->irep[i]->syms;
- if (p)
- mrb_free(mrb, p);
-
- mrb_free(mrb, mrb->irep[i]);
- }
- }
-}
+#if UINT32_MAX > SIZE_MAX
+# error This code cannot be built on your environment.
+#endif
static size_t
offset_crc_body(void)
@@ -61,83 +37,84 @@ offset_crc_body(void)
return ((uint8_t *)header.binary_crc - (uint8_t *)&header) + sizeof(header.binary_crc);
}
-static int
-read_rite_irep_record(mrb_state *mrb, const uint8_t *bin, uint32_t *len)
+static mrb_irep*
+read_irep_record_1(mrb_state *mrb, const uint8_t *bin, size_t *len, mrb_bool alloc)
{
- int ret;
size_t i;
const uint8_t *src = bin;
+ ptrdiff_t diff;
uint16_t tt, pool_data_len, snl;
size_t plen;
int ai = mrb_gc_arena_save(mrb);
mrb_irep *irep = mrb_add_irep(mrb);
- // skip record size
+ /* skip record size */
src += sizeof(uint32_t);
- // number of local variable
+ /* number of local variable */
irep->nlocals = bin_to_uint16(src);
src += sizeof(uint16_t);
- // number of register variable
+ /* number of register variable */
irep->nregs = bin_to_uint16(src);
src += sizeof(uint16_t);
- // Binary Data Section
- // ISEQ BLOCK
- irep->ilen = bin_to_uint32(src);
+ /* number of child irep */
+ irep->rlen = (size_t)bin_to_uint16(src);
+ src += sizeof(uint16_t);
+
+ /* Binary Data Section */
+ /* ISEQ BLOCK */
+ irep->ilen = (size_t)bin_to_uint32(src);
src += sizeof(uint32_t);
if (irep->ilen > 0) {
if (SIZE_ERROR_MUL(sizeof(mrb_code), irep->ilen)) {
- ret = MRB_DUMP_GENERAL_FAILURE;
- goto error_exit;
+ return NULL;
}
irep->iseq = (mrb_code *)mrb_malloc(mrb, sizeof(mrb_code) * irep->ilen);
- if (irep->iseq == NULL) {
- ret = MRB_DUMP_GENERAL_FAILURE;
- goto error_exit;
- }
for (i = 0; i < irep->ilen; i++) {
- irep->iseq[i] = bin_to_uint32(src); //iseq
+ irep->iseq[i] = (size_t)bin_to_uint32(src); /* iseq */
src += sizeof(uint32_t);
}
}
- //POOL BLOCK
- plen = bin_to_uint32(src); /* number of pool */
+ /* POOL BLOCK */
+ plen = (size_t)bin_to_uint32(src); /* number of pool */
src += sizeof(uint32_t);
if (plen > 0) {
if (SIZE_ERROR_MUL(sizeof(mrb_value), plen)) {
- ret = MRB_DUMP_GENERAL_FAILURE;
- goto error_exit;
- }
- irep->pool = (mrb_value *)mrb_malloc(mrb, sizeof(mrb_value) * plen);
- if (irep->pool == NULL) {
- ret = MRB_DUMP_GENERAL_FAILURE;
- goto error_exit;
+ return NULL;
}
+ irep->pool = (mrb_value*)mrb_malloc(mrb, sizeof(mrb_value) * plen);
for (i = 0; i < plen; i++) {
mrb_value s;
- tt = *src++; //pool TT
- pool_data_len = bin_to_uint16(src); //pool data length
+
+ tt = *src++; /* pool TT */
+ pool_data_len = bin_to_uint16(src); /* pool data length */
src += sizeof(uint16_t);
- s = mrb_str_new(mrb, (char *)src, pool_data_len);
+ if (alloc) {
+ s = mrb_str_new(mrb, (char *)src, pool_data_len);
+ }
+ else {
+ s = mrb_str_new_static(mrb, (char *)src, pool_data_len);
+ }
src += pool_data_len;
- switch (tt) { //pool data
- case MRB_TT_FIXNUM:
+ switch (tt) { /* pool data */
+ case IREP_TT_FIXNUM:
irep->pool[i] = mrb_str_to_inum(mrb, s, 10, FALSE);
break;
- case MRB_TT_FLOAT:
- irep->pool[i] = mrb_float_value(mrb, mrb_str_to_dbl(mrb, s, FALSE));
+ case IREP_TT_FLOAT:
+ irep->pool[i] = mrb_float_pool(mrb, mrb_str_to_dbl(mrb, s, FALSE));
break;
- case MRB_TT_STRING:
- irep->pool[i] = s;
+ case IREP_TT_STRING:
+ irep->pool[i] = mrb_str_pool(mrb, s);
break;
default:
+ /* should not happen */
irep->pool[i] = mrb_nil_value();
break;
}
@@ -146,22 +123,17 @@ read_rite_irep_record(mrb_state *mrb, const uint8_t *bin, uint32_t *len)
}
}
- //SYMS BLOCK
- irep->slen = bin_to_uint32(src); //syms length
+ /* SYMS BLOCK */
+ irep->slen = (size_t)bin_to_uint32(src); /* syms length */
src += sizeof(uint32_t);
if (irep->slen > 0) {
if (SIZE_ERROR_MUL(sizeof(mrb_sym), irep->slen)) {
- ret = MRB_DUMP_GENERAL_FAILURE;
- goto error_exit;
+ return NULL;
}
irep->syms = (mrb_sym *)mrb_malloc(mrb, sizeof(mrb_sym) * irep->slen);
- if (irep->syms == NULL) {
- ret = MRB_DUMP_GENERAL_FAILURE;
- goto error_exit;
- }
for (i = 0; i < irep->slen; i++) {
- snl = bin_to_uint16(src); //symbol name length
+ snl = bin_to_uint16(src); /* symbol name length */
src += sizeof(uint16_t);
if (snl == MRB_DUMP_NULL_SYM_LEN) {
@@ -169,53 +141,56 @@ read_rite_irep_record(mrb_state *mrb, const uint8_t *bin, uint32_t *len)
continue;
}
- irep->syms[i] = mrb_intern2(mrb, (char *)src, snl);
+ if (alloc) {
+ irep->syms[i] = mrb_intern(mrb, (char *)src, snl);
+ }
+ else {
+ irep->syms[i] = mrb_intern_static(mrb, (char *)src, snl);
+ }
src += snl + 1;
mrb_gc_arena_restore(mrb, ai);
}
}
- *len = src - bin;
- ret = MRB_DUMP_OK;
-error_exit:
- return ret;
+ irep->reps = (mrb_irep**)mrb_malloc(mrb, sizeof(mrb_irep*)*irep->rlen);
+
+ diff = src - bin;
+ mrb_assert(diff >= 0);
+ mrb_assert(diff <= SIZE_MAX);
+ *len = (size_t)diff;
+
+ return irep;
}
-static int
-read_rite_section_irep(mrb_state *mrb, const uint8_t *bin)
+static mrb_irep*
+read_irep_record(mrb_state *mrb, const uint8_t *bin, size_t *len, mrb_bool alloc)
{
- int result;
- size_t sirep;
- uint32_t len;
- uint16_t nirep;
- uint16_t n;
- const struct rite_section_irep_header *header;
-
- header = (const struct rite_section_irep_header*)bin;
- bin += sizeof(struct rite_section_irep_header);
+ mrb_irep *irep = read_irep_record_1(mrb, bin, len, alloc);
+ size_t i;
- sirep = mrb->irep_len;
- nirep = bin_to_uint16(header->nirep);
+ bin += *len;
+ for (i=0; i<irep->rlen; i++) {
+ size_t rlen;
- //Read Binary Data Section
- for (n = 0; n < nirep; n++) {
- result = read_rite_irep_record(mrb, bin, &len);
- if (result != MRB_DUMP_OK)
- goto error_exit;
- bin += len;
+ irep->reps[i] = read_irep_record(mrb, bin, &rlen, alloc);
+ bin += rlen;
+ *len += rlen;
}
+ return irep;
+}
- result = nirep;
-error_exit:
- if (result < MRB_DUMP_OK) {
- irep_free(sirep, mrb);
- }
- return result;
+static mrb_irep*
+read_section_irep(mrb_state *mrb, const uint8_t *bin, mrb_bool alloc)
+{
+ size_t len;
+
+ bin += sizeof(struct rite_section_irep_header);
+ return read_irep_record(mrb, bin, &len, alloc);
}
static int
-read_rite_lineno_record(mrb_state *mrb, const uint8_t *bin, size_t irepno, uint32_t *len)
+read_lineno_record_1(mrb_state *mrb, const uint8_t *bin, mrb_irep *irep, size_t *len)
{
int ret;
size_t i, fname_len, niseq;
@@ -224,84 +199,214 @@ read_rite_lineno_record(mrb_state *mrb, const uint8_t *bin, size_t irepno, uint3
ret = MRB_DUMP_OK;
*len = 0;
- bin += sizeof(uint32_t); // record size
+ 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;
+ return MRB_DUMP_GENERAL_FAILURE;
}
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
+ niseq = (size_t)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;
+ return MRB_DUMP_GENERAL_FAILURE;
}
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
+ bin += sizeof(uint16_t); /* niseq */
*len += sizeof(uint16_t);
- }
-
- mrb->irep[irepno]->filename = fname;
- mrb->irep[irepno]->lines = lines;
-
-error_exit:
+ }
+ irep->filename = fname;
+ irep->lines = lines;
return ret;
}
static int
-read_rite_section_lineno(mrb_state *mrb, const uint8_t *bin, size_t sirep)
+read_lineno_record(mrb_state *mrb, const uint8_t *bin, mrb_irep *irep, size_t *lenp)
{
- int result;
+ int result = read_lineno_record_1(mrb, bin, irep, lenp);
size_t i;
- uint32_t len;
- uint16_t nirep;
- uint16_t n;
- const struct rite_section_lineno_header *header;
+
+ if (result != MRB_DUMP_OK) return result;
+ for (i = 0; i < irep->rlen; i++) {
+ size_t len;
+
+ result = read_lineno_record(mrb, bin, irep->reps[i], &len);
+ if (result != MRB_DUMP_OK) break;
+ bin += len;
+ *lenp += len;
+ }
+ return result;
+}
+
+static int
+read_section_lineno(mrb_state *mrb, const uint8_t *bin, mrb_irep *irep)
+{
+ size_t len;
len = 0;
- header = (const struct rite_section_lineno_header*)bin;
bin += sizeof(struct rite_section_lineno_header);
- nirep = bin_to_uint16(header->nirep);
+ /* Read Binary Data Section */
+ return read_lineno_record(mrb, bin, irep, &len);
+}
- //Read Binary Data Section
- for (n = 0, i = sirep; n < nirep; n++, i++) {
- result = read_rite_lineno_record(mrb, bin, i, &len);
- if (result != MRB_DUMP_OK)
- goto error_exit;
+static int
+read_debug_record(mrb_state *mrb, const uint8_t *start, mrb_irep* irep, size_t *record_len, const mrb_sym *filenames, size_t filenames_len)
+{
+ const uint8_t *bin = start;
+ ptrdiff_t diff;
+ size_t record_size, i;
+ uint16_t f_idx;
+
+ if (irep->debug_info) { return MRB_DUMP_INVALID_IREP; }
+
+ irep->debug_info = (mrb_irep_debug_info*)mrb_malloc(mrb, sizeof(mrb_irep_debug_info));
+ irep->debug_info->pc_count = irep->ilen;
+
+ record_size = (size_t)bin_to_uint32(bin);
+ bin += sizeof(uint32_t);
+
+ irep->debug_info->flen = bin_to_uint16(bin);
+ irep->debug_info->files = (mrb_irep_debug_info_file**)mrb_malloc(mrb, sizeof(mrb_irep_debug_info*) * irep->debug_info->flen);
+ bin += sizeof(uint16_t);
+
+ for (f_idx = 0; f_idx < irep->debug_info->flen; ++f_idx) {
+ mrb_irep_debug_info_file *file;
+ uint16_t filename_idx;
+ mrb_int len;
+
+ file = (mrb_irep_debug_info_file *)mrb_malloc(mrb, sizeof(*file));
+ irep->debug_info->files[f_idx] = file;
+
+ file->start_pos = bin_to_uint32(bin);
+ bin += sizeof(uint32_t);
+
+ /* filename */
+ filename_idx = bin_to_uint16(bin);
+ bin += sizeof(uint16_t);
+ mrb_assert(filename_idx < filenames_len);
+ file->filename_sym = filenames[filename_idx];
+ len = 0;
+ file->filename = mrb_sym2name_len(mrb, file->filename_sym, &len);
+
+ file->line_entry_count = bin_to_uint32(bin);
+ bin += sizeof(uint32_t);
+ file->line_type = (mrb_debug_line_type)bin_to_uint8(bin);
+ bin += sizeof(uint8_t);
+ switch (file->line_type) {
+ case mrb_debug_line_ary: {
+ uint32_t l;
+
+ file->lines.ary = (uint16_t *)mrb_malloc(mrb, sizeof(uint16_t) * (size_t)(file->line_entry_count));
+ for (l = 0; l < file->line_entry_count; ++l) {
+ file->lines.ary[l] = bin_to_uint16(bin);
+ bin += sizeof(uint16_t);
+ }
+ } break;
+
+ case mrb_debug_line_flat_map: {
+ uint32_t l;
+
+ file->lines.flat_map = (mrb_irep_debug_info_line*)mrb_malloc(
+ mrb, sizeof(mrb_irep_debug_info_line) * (size_t)(file->line_entry_count));
+ for (l = 0; l < file->line_entry_count; ++l) {
+ file->lines.flat_map[l].start_pos = bin_to_uint32(bin);
+ bin += sizeof(uint32_t);
+ file->lines.flat_map[l].line = bin_to_uint16(bin);
+ bin += sizeof(uint16_t);
+ }
+ } break;
+
+ default: return MRB_DUMP_GENERAL_FAILURE;
+ }
+ }
+
+ diff = bin - start;
+ mrb_assert(diff >= 0);
+ mrb_assert(diff <= SIZE_MAX);
+
+ if (record_size != (size_t)diff) {
+ return MRB_DUMP_GENERAL_FAILURE;
+ }
+
+ for (i = 0; i < irep->rlen; i++) {
+ size_t len;
+ int ret;
+
+ ret =read_debug_record(mrb, bin, irep->reps[i], &len, filenames, filenames_len);
+ if (ret != MRB_DUMP_OK) return ret;
bin += len;
}
- result = sirep + bin_to_uint16(header->sirep);
-error_exit:
- return result;
+ diff = bin - start;
+ mrb_assert(diff >= 0);
+ mrb_assert(diff <= SIZE_MAX);
+ *record_len = (size_t)diff;
+
+ return MRB_DUMP_OK;
}
+static int
+read_section_debug(mrb_state *mrb, const uint8_t *start, mrb_irep *irep, mrb_bool alloc)
+{
+ const uint8_t *bin;
+ ptrdiff_t diff;
+ struct rite_section_debug_header *header;
+ uint16_t i;
+ size_t len = 0;
+ int result;
+ uint16_t filenames_len;
+ mrb_sym *filenames;
+
+ bin = start;
+ header = (struct rite_section_debug_header *)bin;
+ bin += sizeof(struct rite_section_debug_header);
+
+ filenames_len = bin_to_uint16(bin);
+ bin += sizeof(uint16_t);
+ filenames = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym) * (size_t)filenames_len);
+ for (i = 0; i < filenames_len; ++i) {
+ uint16_t f_len = bin_to_uint16(bin);
+ bin += sizeof(uint16_t);
+ if (alloc) {
+ filenames[i] = mrb_intern(mrb, (const char *)bin, (size_t)f_len);
+ }
+ else {
+ filenames[i] = mrb_intern_static(mrb, (const char *)bin, (size_t)f_len);
+ }
+ bin += f_len;
+ }
+
+ result = read_debug_record(mrb, bin, irep, &len, filenames, filenames_len);
+ if (result != MRB_DUMP_OK) goto debug_exit;
+
+ bin += len;
+ diff = bin - start;
+ mrb_assert(diff >= 0);
+ mrb_assert(diff <= UINT32_MAX);
+ if ((uint32_t)diff != bin_to_uint32(header->section_size)) {
+ result = MRB_DUMP_GENERAL_FAILURE;
+ }
+
+debug_exit:
+ mrb_free(mrb, filenames);
+ return result;
+}
static int
-read_rite_binary_header(const uint8_t *bin, size_t *bin_size, uint16_t *crc)
+read_binary_header(const uint8_t *bin, size_t *bin_size, uint16_t *crc)
{
const struct rite_binary_header *header = (const struct rite_binary_header *)bin;
@@ -315,226 +420,196 @@ read_rite_binary_header(const uint8_t *bin, size_t *bin_size, uint16_t *crc)
*crc = bin_to_uint16(header->binary_crc);
if (bin_size) {
- *bin_size = bin_to_uint32(header->binary_size);
+ *bin_size = (size_t)bin_to_uint32(header->binary_size);
}
return MRB_DUMP_OK;
}
-int32_t
+mrb_irep*
mrb_read_irep(mrb_state *mrb, const uint8_t *bin)
{
int result;
- int32_t total_nirep = 0;
+ mrb_irep *irep = NULL;
const struct rite_section_header *section_header;
uint16_t crc;
size_t bin_size = 0;
size_t n;
- size_t sirep;
if ((mrb == NULL) || (bin == NULL)) {
- return MRB_DUMP_INVALID_ARGUMENT;
+ return NULL;
}
- result = read_rite_binary_header(bin, &bin_size, &crc);
+ result = read_binary_header(bin, &bin_size, &crc);
if (result != MRB_DUMP_OK) {
- return result;
+ return NULL;
}
n = offset_crc_body();
if (crc != calc_crc_16_ccitt(bin + n, bin_size - n, 0)) {
- return MRB_DUMP_INVALID_FILE_HEADER;
+ return NULL;
}
bin += sizeof(struct rite_binary_header);
- sirep = mrb->irep_len;
-
do {
section_header = (const struct rite_section_header *)bin;
if (memcmp(section_header->section_identify, RITE_SECTION_IREP_IDENTIFIER, sizeof(section_header->section_identify)) == 0) {
- result = read_rite_section_irep(mrb, bin);
+ irep = read_section_irep(mrb, bin, FALSE);
+ if (!irep) return NULL;
+ }
+ else if (memcmp(section_header->section_identify, RITE_SECTION_LINENO_IDENTIFIER, sizeof(section_header->section_identify)) == 0) {
+ if (!irep) return NULL; /* corrupted data */
+ result = read_section_lineno(mrb, bin, irep);
if (result < MRB_DUMP_OK) {
- return result;
+ return NULL;
}
- total_nirep += result;
}
- else if (memcmp(section_header->section_identify, RITE_SECTION_LINENO_IDENTIFIER, sizeof(section_header->section_identify)) == 0) {
- result = read_rite_section_lineno(mrb, bin, sirep);
+ else if (memcmp(section_header->section_identify, RITE_SECTION_DEBUG_IDENTIFIER, sizeof(section_header->section_identify)) == 0) {
+ if (!irep) return NULL; /* corrupted data */
+ result = read_section_debug(mrb, bin, irep, FALSE);
if (result < MRB_DUMP_OK) {
- return result;
+ return NULL;
}
}
bin += bin_to_uint32(section_header->section_size);
} while (memcmp(section_header->section_identify, RITE_BINARY_EOF, sizeof(section_header->section_identify)) != 0);
- return sirep;
+ return irep;
}
static void
-irep_error(mrb_state *mrb, int n)
+irep_error(mrb_state *mrb)
{
- static const char msg[] = "irep load error";
- mrb->exc = mrb_obj_ptr(mrb_exc_new(mrb, E_SCRIPT_ERROR, msg, sizeof(msg) - 1));
+ mrb->exc = mrb_obj_ptr(mrb_exc_new_str_lit(mrb, E_SCRIPT_ERROR, "irep load error"));
}
mrb_value
-mrb_load_irep(mrb_state *mrb, const uint8_t *bin)
+mrb_load_irep_cxt(mrb_state *mrb, const uint8_t *bin, mrbc_context *c)
{
- int32_t n;
+ mrb_irep *irep = mrb_read_irep(mrb, bin);
+ mrb_value val;
+ struct RProc *proc;
- n = mrb_read_irep(mrb, bin);
- if (n < 0) {
- irep_error(mrb, n);
+ if (!irep) {
+ irep_error(mrb);
return mrb_nil_value();
}
- return mrb_run(mrb, mrb_proc_new(mrb, mrb->irep[n]), mrb_top_self(mrb));
+ proc = mrb_proc_new(mrb, irep);
+ mrb_irep_decref(mrb, irep);
+ if (c && c->no_exec) return mrb_obj_value(proc);
+ val = mrb_toplevel_run(mrb, proc);
+ return val;
+}
+
+mrb_value
+mrb_load_irep(mrb_state *mrb, const uint8_t *bin)
+{
+ return mrb_load_irep_cxt(mrb, bin, NULL);
}
#ifdef ENABLE_STDIO
-static int32_t
-read_rite_section_lineno_file(mrb_state *mrb, FILE *fp, size_t sirep)
+static int
+read_lineno_record_file(mrb_state *mrb, FILE *fp, mrb_irep *irep)
{
- int32_t result;
- size_t i;
- uint16_t nirep;
- uint16_t n;
- uint32_t len, buf_size;
- uint8_t *buf = NULL;
- const size_t record_header_size = 4;
+ 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;
- struct rite_section_lineno_header header;
- if (fread(&header, sizeof(struct rite_section_lineno_header), 1, fp) == 0) {
+ if (fread(header, record_header_size, 1, fp) == 0) {
return MRB_DUMP_READ_FAULT;
}
-
- nirep = bin_to_uint16(header.nirep);
-
- buf_size = record_header_size;
- /* We don't need to check buf_size. As it 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, i = sirep; n < nirep; n++, i++) {
- 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_lineno_record(mrb, buf, i, &len);
- if (result != MRB_DUMP_OK)
- goto error_exit;
+ 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;
- result = sirep + bin_to_uint16(header.sirep);
-error_exit:
- if (buf) {
- mrb_free(mrb, buf);
+ if (fread(&buf[record_header_size], buf_size - record_header_size, 1, fp) == 0) {
+ return MRB_DUMP_READ_FAULT;
}
- if (result < MRB_DUMP_OK) {
- irep_free(sirep, mrb);
+ 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;
}
static int32_t
-read_rite_section_irep_file(mrb_state *mrb, FILE *fp)
+read_section_lineno_file(mrb_state *mrb, FILE *fp, mrb_irep *irep)
{
- 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;
+ struct rite_section_lineno_header header;
- if (fread(&header, sizeof(struct rite_section_irep_header), 1, fp) == 0) {
+ if (fread(&header, sizeof(struct rite_section_lineno_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;
+ /* Read Binary Data Section */
+ return read_lineno_record_file(mrb, fp, irep);
+}
- 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;
+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(&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;
+ if (fread(header, record_header_size, 1, fp) == 0) {
+ return NULL;
}
-
- result = nirep;
-error_exit:
- if (buf) {
- mrb_free(mrb, buf);
+ buf_size = (size_t)bin_to_uint32(&header[0]);
+ if (SIZE_ERROR(buf_size)) {
+ return NULL;
}
- if (result < MRB_DUMP_OK) {
- irep_free(sirep, mrb);
+ 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;
}
- return result;
+ 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;
+}
+
+static mrb_irep*
+read_section_irep_file(mrb_state *mrb, FILE *fp)
+{
+ struct rite_section_irep_header header;
+
+ if (fread(&header, sizeof(struct rite_section_irep_header), 1, fp) == 0) {
+ return NULL;
+ }
+ return read_irep_record_file(mrb, fp);
}
-int32_t
+mrb_irep*
mrb_read_irep_file(mrb_state *mrb, FILE* fp)
{
+ mrb_irep *irep = NULL;
int result;
- int32_t total_nirep = 0;
uint8_t *buf;
uint16_t crc, crcwk = 0;
- uint32_t section_size = 0;
+ size_t section_size = 0;
size_t nbytes;
- size_t sirep;
struct rite_section_header section_header;
long fpos;
size_t block_size = 1 << 14;
@@ -543,33 +618,30 @@ mrb_read_irep_file(mrb_state *mrb, FILE* fp)
const size_t buf_size = sizeof(struct rite_binary_header);
if ((mrb == NULL) || (fp == NULL)) {
- return MRB_DUMP_INVALID_ARGUMENT;
+ return NULL;
}
/* You don't need use SIZE_ERROR as buf_size is enough small. */
- buf = mrb_malloc(mrb, buf_size);
- if (!buf) {
- return MRB_DUMP_GENERAL_FAILURE;
- }
+ buf = (uint8_t*)mrb_malloc(mrb, buf_size);
if (fread(buf, buf_size, 1, fp) == 0) {
mrb_free(mrb, buf);
- return MRB_DUMP_READ_FAULT;
+ return NULL;
}
- result = read_rite_binary_header(buf, NULL, &crc);
+ result = read_binary_header(buf, NULL, &crc);
mrb_free(mrb, buf);
if (result != MRB_DUMP_OK) {
- return result;
+ return NULL;
}
/* verify CRC */
fpos = ftell(fp);
/* You don't need use SIZE_ERROR as block_size is enough small. */
for (i = 0; i < block_fallback_count; i++,block_size >>= 1){
- buf = mrb_malloc_simple(mrb, block_size);
- if (buf) break;
+ buf = (uint8_t*)mrb_malloc_simple(mrb, block_size);
+ if (buf) break;
}
if (!buf) {
- return MRB_DUMP_GENERAL_FAILURE;
+ return NULL;
}
fseek(fp, offset_crc_body(), SEEK_SET);
while ((nbytes = fread(buf, 1, block_size, fp)) > 0) {
@@ -577,53 +649,75 @@ mrb_read_irep_file(mrb_state *mrb, FILE* fp)
}
mrb_free(mrb, buf);
if (nbytes == 0 && ferror(fp)) {
- return MRB_DUMP_READ_FAULT;
+ return NULL;
}
if (crcwk != crc) {
- return MRB_DUMP_INVALID_FILE_HEADER;
+ return NULL;
}
fseek(fp, fpos + section_size, SEEK_SET);
- sirep = mrb->irep_len;
- // read sections
+ /* read sections */
do {
fpos = ftell(fp);
if (fread(&section_header, sizeof(struct rite_section_header), 1, fp) == 0) {
- return MRB_DUMP_READ_FAULT;
+ return NULL;
}
- section_size = bin_to_uint32(section_header.section_size);
+ section_size = (size_t)bin_to_uint32(section_header.section_size);
if (memcmp(section_header.section_identify, RITE_SECTION_IREP_IDENTIFIER, sizeof(section_header.section_identify)) == 0) {
fseek(fp, fpos, SEEK_SET);
- result = read_rite_section_irep_file(mrb, fp);
- if (result < MRB_DUMP_OK) {
- return result;
- }
- total_nirep += result;
+ irep = read_section_irep_file(mrb, fp);
+ if (!irep) return NULL;
}
else if (memcmp(section_header.section_identify, RITE_SECTION_LINENO_IDENTIFIER, sizeof(section_header.section_identify)) == 0) {
+ if (!irep) return NULL; /* corrupted data */
fseek(fp, fpos, SEEK_SET);
- result = read_rite_section_lineno_file(mrb, fp, sirep);
- if (result < MRB_DUMP_OK) {
- return result;
+ result = read_section_lineno_file(mrb, fp, irep);
+ if (result < MRB_DUMP_OK) return NULL;
+ }
+ else if (memcmp(section_header.section_identify, RITE_SECTION_DEBUG_IDENTIFIER, sizeof(section_header.section_identify)) == 0) {
+ if (!irep) return NULL; /* corrupted data */
+ else {
+ uint8_t* const bin = (uint8_t*)mrb_malloc(mrb, section_size);
+
+ fseek(fp, fpos, SEEK_SET);
+ if (fread((char*)bin, section_size, 1, fp) != 1) {
+ mrb_free(mrb, bin);
+ return NULL;
+ }
+ result = read_section_debug(mrb, bin, irep, TRUE);
+ mrb_free(mrb, bin);
}
+ if (result < MRB_DUMP_OK) return NULL;
}
fseek(fp, fpos + section_size, SEEK_SET);
} while (memcmp(section_header.section_identify, RITE_BINARY_EOF, sizeof(section_header.section_identify)) != 0);
- return sirep;
+ return irep;
}
mrb_value
-mrb_load_irep_file(mrb_state *mrb, FILE* fp)
+mrb_load_irep_file_cxt(mrb_state *mrb, FILE* fp, mrbc_context *c)
{
- int n = mrb_read_irep_file(mrb, fp);
+ mrb_irep *irep = mrb_read_irep_file(mrb, fp);
+ mrb_value val;
+ struct RProc *proc;
- if (n < 0) {
- irep_error(mrb, n);
+ if (!irep) {
+ irep_error(mrb);
return mrb_nil_value();
}
- return mrb_run(mrb, mrb_proc_new(mrb, mrb->irep[n]), mrb_top_self(mrb));
+ proc = mrb_proc_new(mrb, irep);
+ mrb_irep_decref(mrb, irep);
+ if (c && c->no_exec) return mrb_obj_value(proc);
+ val = mrb_toplevel_run(mrb, proc);
+ return val;
+}
+
+mrb_value
+mrb_load_irep_file(mrb_state *mrb, FILE* fp)
+{
+ return mrb_load_irep_file_cxt(mrb, fp, NULL);
}
#endif /* ENABLE_STDIO */
generated by cgit v1.2.3 (git 2.39.1) at 2026-04-18 21:13:09 +0000