diff -Nru mruby-0.0.0~20131107+gitf80401de/build_config.rb mruby-0.0.0~20131214+git882afdea/build_config.rb --- mruby-0.0.0~20131107+gitf80401de/build_config.rb 2013-11-04 15:13:01.000000000 +0000 +++ mruby-0.0.0~20131214+git882afdea/build_config.rb 2013-12-10 15:41:48.000000000 +0000 @@ -1,6 +1,12 @@ MRuby::Build.new do |conf| # load specific toolchain settings - toolchain :gcc + + # Gets set by the VS command prompts. + if ENV['VisualStudioVersion'] + toolchain :visualcpp + else + toolchain :gcc + end # Use mrbgems # conf.gem 'examples/mrbgems/ruby_extension_example' diff -Nru mruby-0.0.0~20131107+gitf80401de/debian/changelog mruby-0.0.0~20131214+git882afdea/debian/changelog --- mruby-0.0.0~20131107+gitf80401de/debian/changelog 2013-11-07 03:24:52.000000000 +0000 +++ mruby-0.0.0~20131214+git882afdea/debian/changelog 2013-12-14 02:19:03.000000000 +0000 @@ -1,3 +1,9 @@ +mruby (0.0.0~20131214+git882afdea-1) unstable; urgency=medium + + * Snapshot, taken from the master (20131214). + + -- Nobuhiro Iwamatsu Sat, 14 Dec 2013 10:56:42 +0900 + mruby (0.0.0~20131107+gitf80401de-1) unstable; urgency=low * Snapshot, taken from the master (20131107). diff -Nru mruby-0.0.0~20131107+gitf80401de/doc/compile/README.md mruby-0.0.0~20131214+git882afdea/doc/compile/README.md --- mruby-0.0.0~20131107+gitf80401de/doc/compile/README.md 2013-11-04 15:13:01.000000000 +0000 +++ mruby-0.0.0~20131214+git882afdea/doc/compile/README.md 2013-12-10 15:41:48.000000000 +0000 @@ -59,17 +59,13 @@ toolchain :clang -#### Visual Studio 2010 +#### Visual Studio 2010, 2012 and 2013 -Toolchain configuration for Visual Studio 2010 on Windows. +Toolchain configuration for Visual Studio on Windows. If you use the +[Visual Studio Command Prompt](http://msdn.microsoft.com/en-us/library/ms229859\(v=vs.110\).aspx), +you normally do not have to specify this manually, since it gets automatically detected by our build process. - toolchain :vs2010 - -#### Visual Studio 2012 - -Toolchain configuration for Visual Studio 2012 on Windows. - - toolchain :vs2012 + toolchain :visualcpp #### Android diff -Nru mruby-0.0.0~20131107+gitf80401de/include/mrbconf.h mruby-0.0.0~20131214+git882afdea/include/mrbconf.h --- mruby-0.0.0~20131107+gitf80401de/include/mrbconf.h 2013-11-04 15:13:01.000000000 +0000 +++ mruby-0.0.0~20131214+git882afdea/include/mrbconf.h 2013-12-10 15:41:48.000000000 +0000 @@ -56,8 +56,11 @@ /* initial minimum size for string buffer */ //#define MRB_STR_BUF_MIN_SIZE 128 -/* array size for parser buffer */ -//#define MRB_PARSER_BUF_SIZE 1024 +/* arena size */ +//#define MRB_GC_ARENA_SIZE 100 + +/* fixed size GC arena */ +//#define MRB_GC_FIXED_ARENA /* -DDISABLE_XXXX to drop following features */ //#define DISABLE_STDIO /* use of stdio */ diff -Nru mruby-0.0.0~20131107+gitf80401de/include/mruby/compile.h mruby-0.0.0~20131214+git882afdea/include/mruby/compile.h --- mruby-0.0.0~20131107+gitf80401de/include/mruby/compile.h 2013-11-04 15:13:01.000000000 +0000 +++ mruby-0.0.0~20131214+git882afdea/include/mruby/compile.h 2013-12-10 15:41:48.000000000 +0000 @@ -96,9 +96,7 @@ mrb_ast_node *doc; }; -#ifndef MRB_PARSER_BUF_SIZE -# define MRB_PARSER_BUF_SIZE 1024 -#endif +#define MRB_PARSER_BUF_SIZE 1024 /* parser structure */ struct mrb_parser_state { diff -Nru mruby-0.0.0~20131107+gitf80401de/include/mruby/dump.h mruby-0.0.0~20131214+git882afdea/include/mruby/dump.h --- mruby-0.0.0~20131107+gitf80401de/include/mruby/dump.h 2013-11-04 15:13:01.000000000 +0000 +++ mruby-0.0.0~20131214+git882afdea/include/mruby/dump.h 2013-12-10 15:41:48.000000000 +0000 @@ -12,17 +12,16 @@ #endif #include "mruby.h" +#include "mruby/irep.h" #ifdef ENABLE_STDIO -int mrb_dump_irep_binary(mrb_state*, size_t, int, FILE*); -int mrb_dump_irep_cfunc(mrb_state *mrb, size_t n, int, FILE *f, const char *initname); -int32_t mrb_read_irep_file(mrb_state*, FILE*); -#endif -int32_t mrb_read_irep(mrb_state*, const uint8_t*); - -#ifdef ENABLE_STDIO +int mrb_dump_irep_binary(mrb_state*, mrb_irep*, int, FILE*); +int mrb_dump_irep_cfunc(mrb_state *mrb, mrb_irep*, int, FILE *f, const char *initname); +mrb_irep *mrb_read_irep_file(mrb_state*, FILE*); mrb_value mrb_load_irep_file(mrb_state*,FILE*); +mrb_value mrb_load_irep_file_cxt(mrb_state*, FILE*, mrbc_context*); #endif +mrb_irep *mrb_read_irep(mrb_state*, const uint8_t*); /* dump/load error code * @@ -43,7 +42,7 @@ /* Rite Binary File header */ #define RITE_BINARY_IDENTIFIER "RITE" -#define RITE_BINARY_FORMAT_VER "0001" +#define RITE_BINARY_FORMAT_VER "0002" #define RITE_COMPILER_NAME "MATZ" #define RITE_COMPILER_VERSION "0000" @@ -79,22 +78,14 @@ RITE_SECTION_HEADER; uint8_t rite_version[4]; // Rite Instruction Specification Version - uint8_t nirep[2]; // Number of ireps - uint8_t sirep[2]; // Start index }; struct rite_section_lineno_header { RITE_SECTION_HEADER; - - uint8_t nirep[2]; // Number of ireps - uint8_t sirep[2]; // Start index }; struct rite_section_debug_header { RITE_SECTION_HEADER; - - uint8_t nirep[2]; // Number of ireps - uint8_t sirep[2]; // Start index }; struct rite_binary_footer { diff -Nru mruby-0.0.0~20131107+gitf80401de/include/mruby/hash.h mruby-0.0.0~20131214+git882afdea/include/mruby/hash.h --- mruby-0.0.0~20131107+gitf80401de/include/mruby/hash.h 2013-11-04 15:13:01.000000000 +0000 +++ mruby-0.0.0~20131214+git882afdea/include/mruby/hash.h 2013-12-10 15:41:48.000000000 +0000 @@ -35,7 +35,7 @@ /* RHASH_TBL allocates st_table if not available. */ #define RHASH(obj) ((struct RHash*)(mrb_ptr(obj))) #define RHASH_TBL(h) (RHASH(h)->ht) -#define RHASH_IFNONE(h) mrb_iv_get(mrb, (h), mrb_intern2(mrb, "ifnone", 6)) +#define RHASH_IFNONE(h) mrb_iv_get(mrb, (h), mrb_intern_lit(mrb, "ifnone")) #define RHASH_PROCDEFAULT(h) RHASH_IFNONE(h) struct kh_ht * mrb_hash_tbl(mrb_state *mrb, mrb_value hash); diff -Nru mruby-0.0.0~20131107+gitf80401de/include/mruby/irep.h mruby-0.0.0~20131214+git882afdea/include/mruby/irep.h --- mruby-0.0.0~20131107+gitf80401de/include/mruby/irep.h 2013-11-04 15:13:01.000000000 +0000 +++ mruby-0.0.0~20131214+git882afdea/include/mruby/irep.h 2013-12-10 15:41:48.000000000 +0000 @@ -11,9 +11,16 @@ extern "C" { #endif +#include "mruby/compile.h" + +enum irep_pool_type { + IREP_TT_STRING, + IREP_TT_FIXNUM, + IREP_TT_FLOAT, +}; + /* Program data array struct */ typedef struct mrb_irep { - uint32_t idx; uint16_t nlocals; /* Number of local variables */ uint16_t nregs; /* Number of register variables */ uint8_t flags; @@ -21,19 +28,24 @@ mrb_code *iseq; mrb_value *pool; mrb_sym *syms; + struct mrb_irep **reps; /* debug info */ const char *filename; uint16_t *lines; struct mrb_irep_debug_info* debug_info; - size_t ilen, plen, slen; + size_t ilen, plen, slen, rlen, refcnt; } mrb_irep; #define MRB_ISEQ_NO_FREE 1 mrb_irep *mrb_add_irep(mrb_state *mrb); mrb_value mrb_load_irep(mrb_state*, const uint8_t*); +mrb_value mrb_load_irep_cxt(mrb_state*, const uint8_t*, mrbc_context*); +void mrb_irep_free(mrb_state*, struct mrb_irep*); +void mrb_irep_incref(mrb_state*, struct mrb_irep*); +void mrb_irep_decref(mrb_state*, struct mrb_irep*); #if defined(__cplusplus) } /* extern "C" { */ diff -Nru mruby-0.0.0~20131107+gitf80401de/include/mruby/string.h mruby-0.0.0~20131214+git882afdea/include/mruby/string.h --- mruby-0.0.0~20131107+gitf80401de/include/mruby/string.h 2013-11-04 15:13:01.000000000 +0000 +++ mruby-0.0.0~20131214+git882afdea/include/mruby/string.h 2013-12-10 15:41:48.000000000 +0000 @@ -65,6 +65,7 @@ int mrb_str_cmp(mrb_state *mrb, mrb_value str1, mrb_value str2); char *mrb_str_to_cstr(mrb_state *mrb, mrb_value str); +mrb_value mrb_str_pool(mrb_state *mrb, mrb_value str); /* For backward compatibility */ static inline mrb_value diff -Nru mruby-0.0.0~20131107+gitf80401de/include/mruby/value.h mruby-0.0.0~20131214+git882afdea/include/mruby/value.h --- mruby-0.0.0~20131107+gitf80401de/include/mruby/value.h 2013-11-04 15:13:01.000000000 +0000 +++ mruby-0.0.0~20131214+git882afdea/include/mruby/value.h 2013-12-10 15:41:48.000000000 +0000 @@ -183,6 +183,7 @@ } return v; } +#define mrb_float_pool(mrb,f) mrb_float_value(mrb,f) #else @@ -215,6 +216,7 @@ #if defined(MRB_WORD_BOXING) +#include #define MRB_TT_HAS_BASIC MRB_TT_FLOAT enum mrb_special_consts { @@ -263,8 +265,8 @@ }\ } while (0) -extern mrb_value -mrb_float_value(struct mrb_state *mrb, mrb_float f); +mrb_value mrb_float_value(struct mrb_state *mrb, mrb_float f); +mrb_value mrb_float_pool(struct mrb_state *mrb, mrb_float f); #else /* No MRB_xxx_BOXING */ @@ -298,6 +300,7 @@ MRB_SET_VALUE(v, MRB_TT_FLOAT, value.f, f); return v; } +#define mrb_float_pool(mrb,f) mrb_float_value(mrb,f) #endif /* no boxing */ diff -Nru mruby-0.0.0~20131107+gitf80401de/include/mruby.h mruby-0.0.0~20131214+git882afdea/include/mruby.h --- mruby-0.0.0~20131107+gitf80401de/include/mruby.h 2013-11-04 15:13:01.000000000 +0000 +++ mruby-0.0.0~20131214+git882afdea/include/mruby.h 2013-12-10 15:41:48.000000000 +0000 @@ -41,12 +41,13 @@ typedef uint32_t mrb_code; typedef uint32_t mrb_aspec; +struct mrb_irep; struct mrb_state; typedef void* (*mrb_allocf) (struct mrb_state *mrb, void*, size_t, void *ud); -#ifndef MRB_ARENA_SIZE -#define MRB_ARENA_SIZE 100 +#ifndef MRB_GC_ARENA_SIZE +#define MRB_GC_ARENA_SIZE 100 #endif typedef struct { @@ -105,8 +106,6 @@ struct RObject *exc; /* exception */ struct iv_tbl *globals; /* global variable table */ - struct mrb_irep **irep; /* program data array */ - size_t irep_len, irep_capa; struct RObject *top_self; struct RClass *object_class; /* Object class */ @@ -129,7 +128,12 @@ struct heap_page *sweeps; struct heap_page *free_heaps; size_t live; /* count of live objects */ - struct RBasic *arena[MRB_ARENA_SIZE]; /* GC protection array */ +#ifdef MRB_GC_FIXED_ARENA + struct RBasic *arena[MRB_GC_ARENA_SIZE]; /* GC protection array */ +#else + struct RBasic **arena; /* GC protection array */ + int arena_capa; +#endif int arena_idx; enum gc_state gc_state; /* state of gc */ @@ -225,7 +229,7 @@ mrb_value mrb_funcall_argv(mrb_state*, mrb_value, mrb_sym, int, mrb_value*); mrb_value mrb_funcall_with_block(mrb_state*, mrb_value, mrb_sym, int, mrb_value*, mrb_value); mrb_sym mrb_intern_cstr(mrb_state*,const char*); -mrb_sym mrb_intern2(mrb_state*,const char*,size_t); +mrb_sym mrb_intern(mrb_state*,const char*,size_t); mrb_sym mrb_intern_str(mrb_state*,mrb_value); mrb_value mrb_check_intern_cstr(mrb_state*,const char*); mrb_value mrb_check_intern(mrb_state*,const char*,size_t); @@ -235,12 +239,7 @@ mrb_value mrb_sym2str(mrb_state*,mrb_sym); mrb_value mrb_str_format(mrb_state *, int, const mrb_value *, mrb_value); -/* For backward compatibility. */ -static inline -mrb_sym mrb_intern(mrb_state *mrb,const char *cstr) -{ - return mrb_intern_cstr(mrb, cstr); -} +#define mrb_intern_lit(mrb, lit) mrb_intern(mrb, (lit), sizeof(lit) - 1) void *mrb_malloc(mrb_state*, size_t); /* raise RuntimeError if no mem */ void *mrb_calloc(mrb_state*, size_t, size_t); /* ditto */ @@ -256,7 +255,6 @@ mrb_state* mrb_open(void); mrb_state* mrb_open_allocf(mrb_allocf, void *ud); -void mrb_irep_free(mrb_state*, struct mrb_irep*); void mrb_close(mrb_state*); mrb_value mrb_top_self(mrb_state *); diff -Nru mruby-0.0.0~20131107+gitf80401de/mrbgems/mruby-bin-mirb/tools/mirb/mirb.c mruby-0.0.0~20131214+git882afdea/mrbgems/mruby-bin-mirb/tools/mirb/mirb.c --- mruby-0.0.0~20131107+gitf80401de/mrbgems/mruby-bin-mirb/tools/mirb/mirb.c 2013-11-04 15:13:01.000000000 +0000 +++ mruby-0.0.0~20131214+git882afdea/mrbgems/mruby-bin-mirb/tools/mirb/mirb.c 2013-12-10 15:41:48.000000000 +0000 @@ -236,6 +236,8 @@ } } +void codedump_all(mrb_state*, struct RProc*); + int main(int argc, char **argv) { @@ -365,6 +367,9 @@ /* generate bytecode */ struct RProc *proc = mrb_generate_code(mrb, parser); + if (args.verbose) { + codedump_all(mrb, proc); + } /* pass a proc for evaulation */ nregs = first_command ? 0: proc->body.irep->nregs; /* evaluate the bytecode */ @@ -379,7 +384,7 @@ } else { /* no */ - if (!mrb_respond_to(mrb, result, mrb_intern2(mrb, "inspect", 7))){ + if (!mrb_respond_to(mrb, result, mrb_intern_lit(mrb, "inspect"))){ result = mrb_any_to_s(mrb,result); } p(mrb, result, 1); diff -Nru mruby-0.0.0~20131107+gitf80401de/mrbgems/mruby-bin-mruby/tools/mruby/mruby.c mruby-0.0.0~20131214+git882afdea/mrbgems/mruby-bin-mruby/tools/mruby/mruby.c --- mruby-0.0.0~20131107+gitf80401de/mrbgems/mruby-bin-mruby/tools/mruby/mruby.c 2013-11-04 15:13:01.000000000 +0000 +++ mruby-0.0.0~20131214+git882afdea/mrbgems/mruby-bin-mruby/tools/mruby/mruby.c 2013-12-10 15:41:48.000000000 +0000 @@ -178,6 +178,8 @@ int i; struct _args args; mrb_value ARGV; + mrbc_context *c; + mrb_value v; if (mrb == NULL) { fputs("Invalid mrb_state, exiting mruby\n", stderr); @@ -197,29 +199,16 @@ } mrb_define_global_const(mrb, "ARGV", ARGV); + c = mrbc_context_new(mrb); + if (args.verbose) + c->dump_result = 1; + if (args.check_syntax) + c->no_exec = 1; if (args.mrbfile) { - n = mrb_read_irep_file(mrb, args.rfp); - if (n < 0) { - fprintf(stderr, "failed to load mrb file: %s\n", args.cmdline); - } - else if (!args.check_syntax) { - mrb_context_run(mrb, mrb_proc_new(mrb, mrb->irep[n]), mrb_top_self(mrb), 0); - n = 0; - if (mrb->exc) { - mrb_print_error(mrb); - n = -1; - } - } + v = mrb_load_irep_file_cxt(mrb, args.rfp, c); } else { - mrbc_context *c = mrbc_context_new(mrb); - mrb_sym zero_sym = mrb_intern2(mrb, "$0", 2); - mrb_value v; - - if (args.verbose) - c->dump_result = 1; - if (args.check_syntax) - c->no_exec = 1; + mrb_sym zero_sym = mrb_intern_lit(mrb, "$0"); if (args.rfp) { char *cmdline; @@ -233,17 +222,16 @@ mrb_gv_set(mrb, zero_sym, mrb_str_new(mrb, "-e", 2)); v = mrb_load_string_cxt(mrb, args.cmdline, c); } - - mrbc_context_free(mrb, c); - if (mrb->exc) { - if (!mrb_undef_p(v)) { - mrb_print_error(mrb); - } - n = -1; - } - else if (args.check_syntax) { - printf("Syntax OK\n"); + } + mrbc_context_free(mrb, c); + if (mrb->exc) { + if (!mrb_undef_p(v)) { + mrb_print_error(mrb); } + n = -1; + } + else if (args.check_syntax) { + printf("Syntax OK\n"); } cleanup(mrb, &args); diff -Nru mruby-0.0.0~20131107+gitf80401de/mrbgems/mruby-random/src/random.c mruby-0.0.0~20131214+git882afdea/mrbgems/mruby-random/src/random.c --- mruby-0.0.0~20131107+gitf80401de/mrbgems/mruby-random/src/random.c 2013-11-04 15:13:01.000000000 +0000 +++ mruby-0.0.0~20131214+git882afdea/mrbgems/mruby-random/src/random.c 2013-12-10 15:41:48.000000000 +0000 @@ -143,7 +143,7 @@ { mrb_value seed; - seed = mrb_gv_get(mrb, mrb_intern2(mrb, GLOBAL_RAND_SEED_KEY, GLOBAL_RAND_SEED_KEY_CSTR_LEN)); + seed = mrb_gv_get(mrb, mrb_intern(mrb, GLOBAL_RAND_SEED_KEY, GLOBAL_RAND_SEED_KEY_CSTR_LEN)); if (mrb_nil_p(seed)) { mrb_random_mt_g_srand(mrb, mrb_nil_value()); } @@ -167,8 +167,8 @@ seed = get_opt(mrb); seed = mrb_random_mt_g_srand(mrb, seed); - old_seed = mrb_gv_get(mrb, mrb_intern2(mrb, GLOBAL_RAND_SEED_KEY, GLOBAL_RAND_SEED_KEY_CSTR_LEN)); - mrb_gv_set(mrb, mrb_intern2(mrb, GLOBAL_RAND_SEED_KEY, GLOBAL_RAND_SEED_KEY_CSTR_LEN), seed); + old_seed = mrb_gv_get(mrb, mrb_intern(mrb, GLOBAL_RAND_SEED_KEY, GLOBAL_RAND_SEED_KEY_CSTR_LEN)); + mrb_gv_set(mrb, mrb_intern(mrb, GLOBAL_RAND_SEED_KEY, GLOBAL_RAND_SEED_KEY_CSTR_LEN), seed); return old_seed; } @@ -192,7 +192,7 @@ seed = get_opt(mrb); seed = mrb_random_mt_srand(mrb, t, seed); - mrb_iv_set(mrb, self, mrb_intern2(mrb, INSTANCE_RAND_SEED_KEY, INSTANCE_RAND_SEED_KEY_CSTR_LEN), seed); + mrb_iv_set(mrb, self, mrb_intern(mrb, INSTANCE_RAND_SEED_KEY, INSTANCE_RAND_SEED_KEY_CSTR_LEN), seed); DATA_PTR(self) = t; @@ -205,7 +205,7 @@ mrb_value seed; mt_state *t = DATA_PTR(self); - seed = mrb_iv_get(mrb, self, mrb_intern2(mrb, INSTANCE_RAND_SEED_KEY, INSTANCE_RAND_SEED_KEY_CSTR_LEN)); + seed = mrb_iv_get(mrb, self, mrb_intern(mrb, INSTANCE_RAND_SEED_KEY, INSTANCE_RAND_SEED_KEY_CSTR_LEN)); if (mrb_nil_p(seed)) { mrb_random_mt_srand(mrb, t, mrb_nil_value()); } @@ -231,8 +231,8 @@ seed = get_opt(mrb); seed = mrb_random_mt_srand(mrb, t, seed); - old_seed = mrb_iv_get(mrb, self, mrb_intern2(mrb, INSTANCE_RAND_SEED_KEY, INSTANCE_RAND_SEED_KEY_CSTR_LEN)); - mrb_iv_set(mrb, self, mrb_intern2(mrb, INSTANCE_RAND_SEED_KEY, INSTANCE_RAND_SEED_KEY_CSTR_LEN), seed); + old_seed = mrb_iv_get(mrb, self, mrb_intern(mrb, INSTANCE_RAND_SEED_KEY, INSTANCE_RAND_SEED_KEY_CSTR_LEN)); + mrb_iv_set(mrb, self, mrb_intern(mrb, INSTANCE_RAND_SEED_KEY, INSTANCE_RAND_SEED_KEY_CSTR_LEN), seed); return old_seed; } @@ -265,6 +265,7 @@ for (i = RARRAY_LEN(ary) - 1; i > 0; i--) { mrb_int j; + mrb_value tmp; if (mrb_nil_p(random)) { j = mrb_fixnum(mrb_random_mt_g_rand(mrb, mrb_fixnum_value(RARRAY_LEN(ary)))); @@ -273,9 +274,9 @@ j = mrb_fixnum(mrb_random_mt_rand(mrb, DATA_PTR(random), mrb_fixnum_value(RARRAY_LEN(ary)))); } - mrb_value t = RARRAY_PTR(ary)[i]; + tmp = RARRAY_PTR(ary)[i]; RARRAY_PTR(ary)[i] = RARRAY_PTR(ary)[j]; - RARRAY_PTR(ary)[j] = t; + RARRAY_PTR(ary)[j] = tmp; } } diff -Nru mruby-0.0.0~20131107+gitf80401de/mrbgems/mruby-struct/src/struct.c mruby-0.0.0~20131214+git882afdea/mrbgems/mruby-struct/src/struct.c --- mruby-0.0.0~20131107+gitf80401de/mrbgems/mruby-struct/src/struct.c 2013-11-04 15:13:01.000000000 +0000 +++ mruby-0.0.0~20131214+git882afdea/mrbgems/mruby-struct/src/struct.c 2013-12-10 15:41:48.000000000 +0000 @@ -49,7 +49,7 @@ mrb_value mrb_struct_s_members(mrb_state *mrb, mrb_value klass) { - mrb_value members = struct_ivar_get(mrb, klass, mrb_intern2(mrb, "__members__", 11)); + mrb_value members = struct_ivar_get(mrb, klass, mrb_intern_lit(mrb, "__members__")); if (mrb_nil_p(members)) { mrb_raise(mrb, E_TYPE_ERROR, "uninitialized struct"); @@ -176,7 +176,7 @@ buf[len] = '='; buf[len+1] = '\0'; - mid = mrb_intern2(mrb, buf, len+1); + mid = mrb_intern(mrb, buf, len+1); mrb_free(mrb, buf); return mid; } @@ -191,7 +191,7 @@ /* get base id */ name = mrb_sym2name_len(mrb, mrb->c->ci->mid, &len); - mid = mrb_intern2(mrb, name, len-1); /* omit last "=" */ + mid = mrb_intern(mrb, name, len-1); /* omit last "=" */ members = mrb_struct_members(mrb, obj); ptr_members = RARRAY_PTR(members); @@ -258,7 +258,7 @@ } MRB_SET_INSTANCE_TT(c, MRB_TT_ARRAY); nstr = mrb_obj_value(c); - mrb_iv_set(mrb, nstr, mrb_intern2(mrb, "__members__", 11), members); + mrb_iv_set(mrb, nstr, mrb_intern_lit(mrb, "__members__"), members); mrb_define_class_method(mrb, c, "new", mrb_instance_new, MRB_ARGS_ANY()); mrb_define_class_method(mrb, c, "[]", mrb_instance_new, MRB_ARGS_ANY()); @@ -393,7 +393,7 @@ { mrb_value members; - members = struct_ivar_get(mrb, mrb_obj_value(klass), mrb_intern2(mrb, "__members__", 11)); + members = struct_ivar_get(mrb, mrb_obj_value(klass), mrb_intern_lit(mrb, "__members__")); if (!mrb_array_p(members)) { mrb_raise(mrb, E_TYPE_ERROR, "broken members"); } diff -Nru mruby-0.0.0~20131107+gitf80401de/src/array.c mruby-0.0.0~20131214+git882afdea/src/array.c --- mruby-0.0.0~20131107+gitf80401de/src/array.c 2013-11-04 15:13:01.000000000 +0000 +++ mruby-0.0.0~20131214+git882afdea/src/array.c 2013-12-10 15:41:48.000000000 +0000 @@ -309,7 +309,7 @@ a1 = RARRAY(ary1); a2 = RARRAY(ary2); if (a1->len == a2->len && a1->ptr == a2->ptr) return mrb_fixnum_value(0); else { - mrb_sym cmp = mrb_intern2(mrb, "<=>", 3); + mrb_sym cmp = mrb_intern_lit(mrb, "<=>"); len = RARRAY_LEN(ary1); if (len > RARRAY_LEN(ary2)) { @@ -1070,7 +1070,7 @@ if (mrb_obj_equal(mrb, ary1, ary2)) return mrb_true_value(); if (mrb_special_const_p(ary2)) return mrb_false_value(); if (!mrb_array_p(ary2)) { - if (!mrb_respond_to(mrb, ary2, mrb_intern2(mrb, "to_ary", 6))) { + if (!mrb_respond_to(mrb, ary2, mrb_intern_lit(mrb, "to_ary"))) { return mrb_false_value(); } else { @@ -1124,8 +1124,8 @@ mrb_define_class_method(mrb, a, "[]", mrb_ary_s_create, MRB_ARGS_ANY()); /* 15.2.12.4.1 */ - mrb_define_method(mrb, a, "*", mrb_ary_times, MRB_ARGS_REQ(1)); /* 15.2.12.5.1 */ - mrb_define_method(mrb, a, "+", mrb_ary_plus, MRB_ARGS_REQ(1)); /* 15.2.12.5.2 */ + mrb_define_method(mrb, a, "+", mrb_ary_plus, MRB_ARGS_REQ(1)); /* 15.2.12.5.1 */ + mrb_define_method(mrb, a, "*", mrb_ary_times, MRB_ARGS_REQ(1)); /* 15.2.12.5.2 */ mrb_define_method(mrb, a, "<<", mrb_ary_push_m, MRB_ARGS_REQ(1)); /* 15.2.12.5.3 */ mrb_define_method(mrb, a, "[]", mrb_ary_aget, MRB_ARGS_ANY()); /* 15.2.12.5.4 */ mrb_define_method(mrb, a, "[]=", mrb_ary_aset, MRB_ARGS_ANY()); /* 15.2.12.5.5 */ diff -Nru mruby-0.0.0~20131107+gitf80401de/src/backtrace.c mruby-0.0.0~20131214+git882afdea/src/backtrace.c --- mruby-0.0.0~20131107+gitf80401de/src/backtrace.c 2013-11-04 15:13:01.000000000 +0000 +++ mruby-0.0.0~20131214+git882afdea/src/backtrace.c 2013-12-10 15:41:48.000000000 +0000 @@ -65,7 +65,7 @@ int i, line; func(mrb, stream, 1, "trace:\n"); - ciidx = mrb_fixnum(mrb_obj_iv_get(mrb, exc, mrb_intern2(mrb, "ciidx", 5))); + ciidx = mrb_fixnum(mrb_obj_iv_get(mrb, exc, mrb_intern_lit(mrb, "ciidx"))); if (ciidx >= mrb->c->ciend - mrb->c->cibase) ciidx = 10; /* ciidx is broken... */ @@ -88,7 +88,7 @@ pc = mrb->c->cibase[i+1].pc - 1; } else { - pc = (mrb_code*)mrb_cptr(mrb_obj_iv_get(mrb, exc, mrb_intern2(mrb, "lastpc", 6))); + pc = (mrb_code*)mrb_cptr(mrb_obj_iv_get(mrb, exc, mrb_intern_lit(mrb, "lastpc"))); } filename = mrb_debug_get_filename(irep, pc - irep->iseq); line = mrb_debug_get_line(irep, pc - irep->iseq); diff -Nru mruby-0.0.0~20131107+gitf80401de/src/class.c mruby-0.0.0~20131214+git882afdea/src/class.c --- mruby-0.0.0~20131107+gitf80401de/src/class.c 2013-11-04 15:13:01.000000000 +0000 +++ mruby-0.0.0~20131214+git882afdea/src/class.c 2013-12-10 15:41:48.000000000 +0000 @@ -53,7 +53,7 @@ mrb_name_class(mrb_state *mrb, struct RClass *c, mrb_sym name) { mrb_obj_iv_set(mrb, (struct RObject*)c, - mrb_intern2(mrb, "__classid__", 11), mrb_symbol_value(name)); + mrb_intern_lit(mrb, "__classid__"), mrb_symbol_value(name)); } #define make_metaclass(mrb, c) prepare_singleton_class((mrb), (struct RBasic*)(c)) @@ -89,7 +89,7 @@ o->c = sc; mrb_field_write_barrier(mrb, (struct RBasic*)o, (struct RBasic*)sc); mrb_field_write_barrier(mrb, (struct RBasic*)sc, (struct RBasic*)o); - mrb_obj_iv_set(mrb, (struct RObject*)sc, mrb_intern2(mrb, "__attached__", 12), mrb_obj_value(o)); + mrb_obj_iv_set(mrb, (struct RObject*)sc, mrb_intern_lit(mrb, "__attached__"), mrb_obj_value(o)); } struct RClass* @@ -116,7 +116,7 @@ mrb_name_class(mrb, c, id); mrb_const_set(mrb, outer, id, mrb_obj_value(c)); mrb_obj_iv_set(mrb, (struct RObject*)c, - mrb_intern2(mrb, "__outer__", 9), outer); + mrb_intern_lit(mrb, "__outer__"), outer); } struct RClass* @@ -124,7 +124,7 @@ { mrb_value outer; - outer = mrb_obj_iv_get(mrb, (struct RObject*)c, mrb_intern2(mrb, "__outer__", 9)); + outer = mrb_obj_iv_get(mrb, (struct RObject*)c, mrb_intern_lit(mrb, "__outer__")); if (mrb_nil_p(outer)) return 0; return mrb_class_ptr(outer); } @@ -1061,7 +1061,7 @@ obj = mrb_instance_alloc(mrb, cv); mrb_get_args(mrb, "*&", &argv, &argc, &blk); - mrb_funcall_with_block(mrb, obj, mrb_intern2(mrb, "initialize", 10), argc, argv, blk); + mrb_funcall_with_block(mrb, obj, mrb_intern_lit(mrb, "initialize"), argc, argv, blk); return obj; } @@ -1072,7 +1072,7 @@ mrb_value obj; obj = mrb_instance_alloc(mrb, mrb_obj_value(c)); - mrb_funcall_argv(mrb, obj, mrb_intern2(mrb, "initialize", 10), argc, argv); + mrb_funcall_argv(mrb, obj, mrb_intern_lit(mrb, "initialize"), argc, argv); return obj; } @@ -1163,7 +1163,7 @@ mrb_get_args(mrb, "n*", &name, &a, &alen); - if (mrb_respond_to(mrb,mod,mrb_intern2(mrb, "inspect",7))){ + if (mrb_respond_to(mrb,mod,mrb_intern_lit(mrb, "inspect"))){ inspect = mrb_funcall(mrb, mod, "inspect", 0); if (RSTRING_LEN(inspect) > 64) { inspect = mrb_any_to_s(mrb, mod); @@ -1215,7 +1215,7 @@ mrb_value path; const char *name; size_t len; - mrb_sym classpath = mrb_intern2(mrb, "__classpath__", 13); + mrb_sym classpath = mrb_intern_lit(mrb, "__classpath__"); path = mrb_obj_iv_get(mrb, (struct RObject*)c, classpath); if (mrb_nil_p(path)) { @@ -1376,7 +1376,7 @@ mrb_value str; if (mrb_type(klass) == MRB_TT_SCLASS) { - mrb_value v = mrb_iv_get(mrb, klass, mrb_intern2(mrb, "__attached__", 12)); + mrb_value v = mrb_iv_get(mrb, klass, mrb_intern_lit(mrb, "__attached__")); str = mrb_str_new(mrb, "#prev) { + codegen_scope *tmp = s->prev; mrb_pool_close(s->mpool); - s = s->prev; + s = tmp; } - mrb_pool_close(s->mpool); #ifdef ENABLE_STDIO if (s->filename && s->lineno) { fprintf(stderr, "codegen error:%s:%d: %s\n", s->filename, s->lineno, message); @@ -112,19 +113,19 @@ return p; } -void* +static void* codegen_malloc(codegen_scope *s, size_t len) { - void *p = mrb_malloc(s->mrb, len); + void *p = mrb_malloc_simple(s->mrb, len); if (!p) codegen_error(s, "mrb_malloc"); return p; } -void* +static void* codegen_realloc(codegen_scope *s, void *p, size_t len) { - p = mrb_realloc(s->mrb, p, len); + p = mrb_realloc_simple(s->mrb, p, len); if (!p && len > 0) codegen_error(s, "mrb_realloc"); return p; @@ -396,34 +397,65 @@ new_lit(codegen_scope *s, mrb_value val) { size_t i; + mrb_value *pv; switch (mrb_type(val)) { case MRB_TT_STRING: for (i=0; iirep->plen; i++) { - mrb_value pv = s->irep->pool[i]; mrb_int len; + pv = &s->irep->pool[i]; - if (mrb_type(pv) != MRB_TT_STRING) continue; - if ((len = RSTRING_LEN(pv)) != RSTRING_LEN(val)) continue; - if (memcmp(RSTRING_PTR(pv), RSTRING_PTR(val), len) == 0) + if (mrb_type(*pv) != MRB_TT_STRING) continue; + if ((len = RSTRING_LEN(*pv)) != RSTRING_LEN(val)) continue; + if (memcmp(RSTRING_PTR(*pv), RSTRING_PTR(val), len) == 0) return i; } break; case MRB_TT_FLOAT: - default: for (i=0; iirep->plen; i++) { - if (mrb_obj_equal(s->mrb, s->irep->pool[i], val)) return i; + pv = &s->irep->pool[i]; + if (mrb_type(*pv) != MRB_TT_FLOAT) continue; + if (mrb_float(*pv) == mrb_float(val)) return i; + } + break; + case MRB_TT_FIXNUM: + for (i=0; iirep->plen; i++) { + pv = &s->irep->pool[i]; + if (mrb_type(*pv) != MRB_TT_FIXNUM) continue; + if (mrb_fixnum(*pv) == mrb_fixnum(val)) return i; } break; + default: + /* should not happen */ + return 0; } if (s->irep->plen == s->pcapa) { s->pcapa *= 2; s->irep->pool = (mrb_value *)codegen_realloc(s, s->irep->pool, sizeof(mrb_value)*s->pcapa); } - s->irep->pool[s->irep->plen] = val; + + pv = &s->irep->pool[s->irep->plen]; i = s->irep->plen++; + switch (mrb_type(val)) { + case MRB_TT_STRING: + *pv = mrb_str_pool(s->mrb, val); + break; + + case MRB_TT_FLOAT: +#ifdef MRB_WORD_BOXING + *pv = mrb_float_pool(s->mrb, mrb_float(val)); + break; +#endif + case MRB_TT_FIXNUM: + *pv = val; + break; + + default: + /* should not happen */ + break; + } return i; } @@ -498,7 +530,7 @@ for_body(codegen_scope *s, node *tree) { codegen_scope *prev = s; - int idx, base = s->irep->idx; + int idx; struct loopinfo *lp; node *n2; mrb_code c; @@ -507,7 +539,6 @@ codegen(s, tree->cdr->car, VAL); // generate loop-block s = scope_new(s->mrb, s, tree->car); - idx = s->irep->idx; lp = loop_push(s, LOOP_FOR); lp->pc1 = new_label(s); @@ -532,20 +563,18 @@ loop_pop(s, NOVAL); scope_finish(s); s = prev; - genop(s, MKOP_Abc(OP_LAMBDA, cursp(), idx - base, OP_L_BLOCK)); + genop(s, MKOP_Abc(OP_LAMBDA, cursp(), s->irep->rlen-1, OP_L_BLOCK)); pop(); - idx = new_msym(s, mrb_intern2(s->mrb, "each", 4)); + idx = new_msym(s, mrb_intern_lit(s->mrb, "each")); genop(s, MKOP_ABC(OP_SENDB, cursp(), idx, 0)); } static int lambda_body(codegen_scope *s, node *tree, int blk) { - int idx, base = s->irep->idx; mrb_code c; - + codegen_scope *parent = s; s = scope_new(s->mrb, s, tree->car); - idx = s->irep->idx; s->mscope = !blk; if (blk) { @@ -624,15 +653,13 @@ loop_pop(s, NOVAL); } scope_finish(s); - - return idx - base; + return parent->irep->rlen - 1; } static int scope_body(codegen_scope *s, node *tree) { codegen_scope *scope = scope_new(s->mrb, s, tree->car); - int idx = scope->irep->idx; codegen(scope, tree->cdr, VAL); if (!s->iseq) { @@ -650,9 +677,11 @@ } } scope_finish(scope); - if (s->irep) - return idx - s->irep->idx; - return 0; + if (!s->irep) { + /* should not happen */ + return 0; + } + return s->irep->rlen - 1; } static mrb_bool @@ -678,7 +707,7 @@ name2[len] = '='; name2[len+1] = '\0'; - return mrb_intern2(s->mrb, name2, len+1); + return mrb_intern(s->mrb, name2, len+1); } static int @@ -947,7 +976,7 @@ gen_send_intern(codegen_scope *s) { pop(); - genop(s, MKOP_ABC(OP_SEND, cursp(), new_msym(s, mrb_intern2(s->mrb, "intern", 6)), 0)); + genop(s, MKOP_ABC(OP_SEND, cursp(), new_msym(s, mrb_intern_lit(s->mrb, "intern")), 0)); push(); } static void @@ -1147,12 +1176,12 @@ codegen(s, n4->car, VAL); } else { - genop(s, MKOP_ABx(OP_GETCONST, cursp(), new_msym(s, mrb_intern2(s->mrb, "StandardError", 13)))); + genop(s, MKOP_ABx(OP_GETCONST, cursp(), new_msym(s, mrb_intern_lit(s->mrb, "StandardError")))); push(); } genop(s, MKOP_AB(OP_MOVE, cursp(), exc)); pop(); - genop(s, MKOP_ABC(OP_SEND, cursp(), new_msym(s, mrb_intern2(s->mrb, "===", 3)), 1)); + genop(s, MKOP_ABC(OP_SEND, cursp(), new_msym(s, mrb_intern_lit(s->mrb, "===")), 1)); tmp = new_label(s); genop(s, MKOP_AsBx(OP_JMPIF, cursp(), pos2)); pos2 = tmp; @@ -1356,7 +1385,7 @@ if (head) { genop(s, MKOP_AB(OP_MOVE, cursp(), head)); pop(); - genop(s, MKOP_ABC(OP_SEND, cursp(), new_msym(s, mrb_intern2(s->mrb, "===", 3)), 1)); + genop(s, MKOP_ABC(OP_SEND, cursp(), new_msym(s, mrb_intern_lit(s->mrb, "===")), 1)); } else { pop(); @@ -1696,7 +1725,7 @@ } pop_n(n+1); if (sendv) n = CALL_MAXARGS; - genop(s, MKOP_ABC(OP_SEND, cursp(), new_msym(s, mrb_intern2(s->mrb, "call", 4)), n)); + genop(s, MKOP_ABC(OP_SEND, cursp(), new_msym(s, mrb_intern_lit(s->mrb, "call")), n)); if (val) push(); } break; @@ -1966,7 +1995,7 @@ default: { - int sym = new_msym(s, mrb_intern2(s->mrb, "-", 1)); + int sym = new_msym(s, mrb_intern_lit(s->mrb, "-")); genop(s, MKOP_ABx(OP_LOADI, cursp(), 0)); push(); @@ -2034,7 +2063,7 @@ char *p = (char*)tree->car; size_t len = (intptr_t)tree->cdr; int ai = mrb_gc_arena_save(s->mrb); - int sym = new_sym(s, mrb_intern2(s->mrb, "Kernel", 6)); + int sym = new_sym(s, mrb_intern_lit(s->mrb, "Kernel")); int off = new_lit(s, mrb_str_new(s->mrb, p, len)); genop(s, MKOP_A(OP_OCLASS, cursp())); @@ -2042,7 +2071,7 @@ push(); genop(s, MKOP_ABx(OP_STRING, cursp(), off)); pop(); - sym = new_sym(s, mrb_intern2(s->mrb, "`", 1)); + sym = new_sym(s, mrb_intern_lit(s->mrb, "`")); genop(s, MKOP_ABC(OP_SEND, cursp(), sym, 1)); mrb_gc_arena_restore(s->mrb, ai); push(); @@ -2054,7 +2083,7 @@ char *p1 = (char*)tree->car; char *p2 = (char*)tree->cdr; int ai = mrb_gc_arena_save(s->mrb); - int sym = new_sym(s, mrb_intern2(s->mrb, REGEXP_CLASS, REGEXP_CLASS_CSTR_LEN)); + int sym = new_sym(s, mrb_intern_lit(s->mrb, REGEXP_CLASS)); int off = new_lit(s, mrb_str_new(s->mrb, p1, strlen(p1))); int argc = 1; @@ -2070,7 +2099,7 @@ pop(); } pop(); - sym = new_sym(s, mrb_intern2(s->mrb, "compile", 7)); + sym = new_sym(s, mrb_intern_lit(s->mrb, "compile")); genop(s, MKOP_ABC(OP_SEND, cursp(), sym, argc)); mrb_gc_arena_restore(s->mrb, ai); push(); @@ -2081,7 +2110,7 @@ if (val) { node *n = tree->car; int ai = mrb_gc_arena_save(s->mrb); - int sym = new_sym(s, mrb_intern2(s->mrb, REGEXP_CLASS, REGEXP_CLASS_CSTR_LEN)); + int sym = new_sym(s, mrb_intern_lit(s->mrb, REGEXP_CLASS)); int argc = 1; int off; char *p; @@ -2118,7 +2147,7 @@ pop(); } pop(); - sym = new_sym(s, mrb_intern2(s->mrb, "compile", 7)); + sym = new_sym(s, mrb_intern_lit(s->mrb, "compile")); genop(s, MKOP_ABC(OP_SEND, cursp(), sym, argc)); mrb_gc_arena_restore(s->mrb, ai); push(); @@ -2183,7 +2212,7 @@ { int a = new_msym(s, sym(tree->car)); int b = new_msym(s, sym(tree->cdr)); - int c = new_msym(s, mrb_intern2(s->mrb, "alias_method", 12)); + int c = new_msym(s, mrb_intern_lit(s->mrb,"alias_method")); genop(s, MKOP_A(OP_TCLASS, cursp())); push(); @@ -2202,7 +2231,7 @@ case NODE_UNDEF: { - int undef = new_msym(s, mrb_intern2(s->mrb, "undef_method", 12)); + int undef = new_msym(s, mrb_intern_lit(s->mrb, "undef_method")); int num = 0; node *t = tree; @@ -2343,6 +2372,21 @@ } } +static void +scope_add_irep(codegen_scope *s, mrb_irep *irep) +{ + if (s->irep == NULL) { + s->irep = irep; + return; + } + if (s->irep->rlen == s->rcapa) { + s->rcapa *= 2; + s->irep->reps = (mrb_irep**)codegen_realloc(s, s->irep->reps, sizeof(mrb_irep*)*s->rcapa); + } + s->irep->reps[s->irep->rlen] = irep; + s->irep->rlen++; +} + static codegen_scope* scope_new(mrb_state *mrb, codegen_scope *prev, node *lv) { @@ -2360,16 +2404,21 @@ p->mscope = 0; p->irep = mrb_add_irep(mrb); + scope_add_irep(prev, p->irep); + + p->rcapa = 8; + p->irep->reps = (mrb_irep**)mrb_malloc(mrb, sizeof(mrb_irep*)*p->rcapa); p->icapa = 1024; p->iseq = (mrb_code*)mrb_malloc(mrb, sizeof(mrb_code)*p->icapa); + p->irep->iseq = p->iseq; p->pcapa = 32; p->irep->pool = (mrb_value*)mrb_malloc(mrb, sizeof(mrb_value)*p->pcapa); p->irep->plen = 0; p->scapa = 256; - p->irep->syms = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym)*256); + p->irep->syms = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym)*p->scapa); p->irep->slen = 0; p->lv = lv; @@ -2418,8 +2467,9 @@ irep->lines = 0; } } - irep->pool = (mrb_value *)codegen_realloc(s, irep->pool, sizeof(mrb_value)*irep->plen); - irep->syms = (mrb_sym *)codegen_realloc(s, irep->syms, sizeof(mrb_sym)*irep->slen); + irep->pool = (mrb_value*)codegen_realloc(s, irep->pool, sizeof(mrb_value)*irep->plen); + irep->syms = (mrb_sym*)codegen_realloc(s, irep->syms, sizeof(mrb_sym)*irep->slen); + irep->reps = (mrb_irep**)codegen_realloc(s, irep->reps, sizeof(mrb_irep*)*irep->rlen); if (s->filename) { s->irep->filename = mrb_parser_get_filename(s->parser, s->filename_index); mrb_debug_info_append_file(mrb, s->irep, s->debug_start_pos, s->pc); @@ -2515,8 +2565,8 @@ mrb_code c; if (!irep) return; - printf("irep %d nregs=%d nlocals=%d pools=%d syms=%d\n", irep->idx, - irep->nregs, irep->nlocals, (int)irep->plen, (int)irep->slen); + printf("irep %p nregs=%d nlocals=%d pools=%d syms=%d reps=%d\n", irep, + irep->nregs, irep->nlocals, (int)irep->plen, (int)irep->slen, (int)irep->rlen); for (i=0; iilen; i++) { ai = mrb_gc_arena_save(mrb); printf("%03d ", i); @@ -2759,9 +2809,8 @@ break; case OP_STRING: { - mrb_value s = irep->pool[GETARG_Bx(c)]; - - s = mrb_str_dump(mrb, s); + mrb_value v = irep->pool[GETARG_Bx(c)]; + mrb_value s = mrb_str_dump(mrb, mrb_str_new(mrb, RSTRING_PTR(v), RSTRING_LEN(v))); printf("OP_STRING\tR%d\t%s\n", GETARG_A(c), RSTRING_PTR(s)); } break; @@ -2784,7 +2833,7 @@ mrb_sym2name(mrb, irep->syms[GETARG_B(c)])); break; case OP_EXEC: - printf("OP_EXEC\tR%d\tI(%d)\n", GETARG_A(c), irep->idx+GETARG_Bx(c)); + printf("OP_EXEC\tR%d\tI(%+d)\n", GETARG_A(c), GETARG_Bx(c)); break; case OP_SCLASS: printf("OP_SCLASS\tR%d\tR%d\n", GETARG_A(c), GETARG_B(c)); @@ -2796,7 +2845,7 @@ printf("OP_ERR\tL(%d)\n", GETARG_Bx(c)); break; case OP_EPUSH: - printf("OP_EPUSH\t:I(%d)\n", irep->idx+GETARG_Bx(c)); + printf("OP_EPUSH\t:I(%+d)\n", GETARG_Bx(c)); break; case OP_ONERR: printf("OP_ONERR\t%03d\n", i+GETARG_sBx(c)); @@ -2825,24 +2874,31 @@ #endif } -void -codedump_all(mrb_state *mrb, struct RProc *proc) +static void +codedump_recur(mrb_state *mrb, mrb_irep *irep) { size_t i; - mrb_irep *irep = proc->body.irep; - for (i=irep->idx; iirep_len; i++) { - codedump(mrb, mrb->irep[i]); + codedump(mrb, irep); + for (i=0; irlen; i++) { + codedump_recur(mrb, irep->reps[i]); } } -static int -codegen_start(mrb_state *mrb, parser_state *p) +void +codedump_all(mrb_state *mrb, struct RProc *proc) +{ + return codedump_recur(mrb, proc->body.irep); +} + +struct RProc* +mrb_generate_code(mrb_state *mrb, parser_state *p) { codegen_scope *scope = scope_new(mrb, 0, 0); + struct RProc *proc; if (!scope) { - return -1; + return NULL; } scope->mrb = mrb; scope->parser = p; @@ -2851,21 +2907,17 @@ if (setjmp(scope->jmp) == 0) { // prepare irep codegen(scope, p->tree, NOVAL); + proc = mrb_proc_new(mrb, scope->irep); + mrb_irep_decref(mrb, scope->irep); mrb_pool_close(scope->mpool); - return 0; + return proc; } else { - return -1; + if (scope->filename == scope->irep->filename) { + scope->irep->filename = NULL; + } + mrb_irep_decref(mrb, scope->irep); + mrb_pool_close(scope->mpool); + return NULL; } } - -struct RProc* -mrb_generate_code(mrb_state *mrb, parser_state *p) -{ - int start = mrb->irep_len; - int n; - - n = codegen_start(mrb, p); - if (n < 0) return NULL; - return mrb_proc_new(mrb, mrb->irep[start]); -} diff -Nru mruby-0.0.0~20131107+gitf80401de/src/debug.c mruby-0.0.0~20131214+git882afdea/src/debug.c --- mruby-0.0.0~20131107+gitf80401de/src/debug.c 2013-11-04 15:13:01.000000000 +0000 +++ mruby-0.0.0~20131214+git882afdea/src/debug.c 2013-12-10 15:41:48.000000000 +0000 @@ -154,7 +154,7 @@ info->pc_count = end_pos; fn_len = strlen(irep->filename); - ret->filename_sym = mrb_intern2(mrb, irep->filename, fn_len); + ret->filename_sym = mrb_intern(mrb, irep->filename, fn_len); len = 0; ret->filename = mrb_sym2name_len(mrb, ret->filename_sym, &len); diff -Nru mruby-0.0.0~20131107+gitf80401de/src/dump.c mruby-0.0.0~20131214+git882afdea/src/dump.c --- mruby-0.0.0~20131107+gitf80401de/src/dump.c 2013-11-04 15:13:01.000000000 +0000 +++ mruby-0.0.0~20131214+git882afdea/src/dump.c 2013-12-10 15:41:48.000000000 +0000 @@ -13,7 +13,7 @@ #include "mruby/numeric.h" #include "mruby/debug.h" -static size_t get_irep_record_size(mrb_state *mrb, mrb_irep *irep); +static size_t get_irep_record_size_1(mrb_state *mrb, mrb_irep *irep); static uint32_t get_irep_header_size(mrb_state *mrb) @@ -21,7 +21,7 @@ uint32_t size = 0; size += sizeof(uint32_t) * 1; - size += sizeof(uint16_t) * 2; + size += sizeof(uint16_t) * 3; return size; } @@ -31,9 +31,10 @@ { uint8_t *cur = buf; - cur += uint32_to_bin(get_irep_record_size(mrb, irep), cur); /* record size */ + cur += uint32_to_bin(get_irep_record_size_1(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 */ + cur += uint16_to_bin((uint16_t)irep->rlen, cur); /* number of child irep */ return (cur - buf); } @@ -90,14 +91,12 @@ break; case MRB_TT_STRING: - str = mrb_str_to_str(mrb, irep->pool[pool_no]); - size += RSTRING_LEN(str); + size += RSTRING_LEN(irep->pool[pool_no]); break; default: break; } - mrb_gc_arena_restore(mrb, ai); } @@ -119,24 +118,24 @@ 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: + cur += uint8_to_bin(IREP_TT_FIXNUM, cur); /* data type */ 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: + cur += uint8_to_bin(IREP_TT_FLOAT, cur); /* data type */ 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); + cur += uint8_to_bin(IREP_TT_STRING, cur); /* data type */ + char_ptr = RSTRING_PTR(irep->pool[pool_no]); + len = RSTRING_LEN(irep->pool[pool_no]); break; default: @@ -204,47 +203,68 @@ return (int)(cur - buf); } - - static size_t -get_irep_record_size(mrb_state *mrb, mrb_irep *irep) +get_irep_record_size_1(mrb_state *mrb, mrb_irep *irep) { uint32_t size = 0; - //size += sizeof(uint16_t); /* rlen */ size += get_irep_header_size(mrb); size += get_iseq_block_size(mrb, irep); size += get_pool_block_size(mrb, irep); size += get_syms_block_size(mrb, irep); + return size; +} +static size_t +get_irep_record_size(mrb_state *mrb, mrb_irep *irep) +{ + uint32_t size = 0; + size_t irep_no; + + size = get_irep_record_size_1(mrb, irep); + for (irep_no = 0; irep_no < irep->rlen; irep_no++) { + size += get_irep_record_size(mrb, irep->reps[irep_no]); + } return size; } static int write_irep_record(mrb_state *mrb, mrb_irep *irep, uint8_t* bin, uint32_t *irep_record_size) { + size_t i; + if (irep == NULL) { return MRB_DUMP_INVALID_IREP; } - *irep_record_size = get_irep_record_size(mrb, irep); + *irep_record_size = get_irep_record_size_1(mrb, irep); if (*irep_record_size == 0) { return MRB_DUMP_GENERAL_FAILURE; } memset(bin, 0, *irep_record_size); - //bin += uint16_to_bin(*irep_record_size, bin); bin += write_irep_header(mrb, irep, bin); bin += write_iseq_block(mrb, irep, bin); bin += write_pool_block(mrb, irep, bin); bin += write_syms_block(mrb, irep, bin); + for (i = 0; i < irep->rlen; i++) { + int result; + uint32_t rlen; + + result = write_irep_record(mrb, irep->reps[i], bin, &rlen); + if (result != MRB_DUMP_OK) { + return result; + } + *irep_record_size += rlen; + bin += rlen; + } return MRB_DUMP_OK; } static size_t -mrb_write_eof(mrb_state *mrb, uint8_t *bin) +write_footer(mrb_state *mrb, uint8_t *bin) { struct rite_binary_footer footer; @@ -257,58 +277,50 @@ static int -mrb_write_section_irep_header(mrb_state *mrb, uint32_t section_size, uint16_t nirep, uint16_t sirep, uint8_t *bin) +write_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)); - uint16_to_bin(nirep, header->nirep); - uint16_to_bin(sirep, header->sirep); return MRB_DUMP_OK; } static int -mrb_write_section_irep(mrb_state *mrb, size_t start_index, uint8_t *bin) +write_section_irep(mrb_state *mrb, mrb_irep *irep, uint8_t *bin) { int result; - size_t irep_no; uint32_t section_size = 0, rlen = 0; /* size of irep record */ uint8_t *cur = bin; - if (mrb == NULL || start_index >= mrb->irep_len || bin == NULL) { + if (mrb == NULL || bin == NULL) { return MRB_DUMP_INVALID_ARGUMENT; } cur += sizeof(struct rite_section_irep_header); section_size += sizeof(struct rite_section_irep_header); - for (irep_no = start_index; irep_no < mrb->irep_len; irep_no++) { - result = write_irep_record(mrb, mrb->irep[irep_no], cur, &rlen); - if (result != MRB_DUMP_OK) { - return result; - } - cur += rlen; - section_size += rlen; + result = write_irep_record(mrb, irep, cur, &rlen); + if (result != MRB_DUMP_OK) { + return result; } - - mrb_write_section_irep_header(mrb, section_size, mrb->irep_len - start_index, start_index, bin); + cur += rlen; + section_size += rlen; + write_section_irep_header(mrb, section_size, bin); return MRB_DUMP_OK; } static int -mrb_write_section_lineno_header(mrb_state *mrb, uint32_t section_size, uint16_t nirep, uint16_t sirep, uint8_t *bin) +write_section_lineno_header(mrb_state *mrb, uint32_t section_size, uint8_t *bin) { struct rite_section_lineno_header *header = (struct rite_section_lineno_header*)bin; // TODO memcpy(header->section_identify, RITE_SECTION_LINENO_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; } @@ -327,12 +339,11 @@ if (irep->lines) { size += sizeof(uint16_t) * irep->ilen; // lineno } - return size; } static int -write_lineno_record(mrb_state *mrb, mrb_irep *irep, uint8_t* bin) +write_lineno_record_1(mrb_state *mrb, mrb_irep *irep, uint8_t* bin) { uint8_t *cur = bin; size_t filename_len = 0, iseq_no; @@ -365,26 +376,39 @@ } static int -mrb_write_section_lineno(mrb_state *mrb, size_t start_index, uint8_t *bin) +write_lineno_record(mrb_state *mrb, mrb_irep *irep, uint8_t* bin) +{ + size_t i; + uint32_t rlen, size = 0; + + rlen = write_lineno_record_1(mrb, irep, bin); + bin += rlen; + size += rlen; + for (i=0; irlen; i++) { + rlen = write_lineno_record(mrb, irep, bin); + bin += rlen; + size += rlen; + } + return size; +} + +static int +write_section_lineno(mrb_state *mrb, mrb_irep *irep, uint8_t *bin) { - size_t irep_no; uint32_t section_size = 0, rlen = 0; /* size of irep record */ uint8_t *cur = bin; - if (mrb == NULL || start_index >= mrb->irep_len || bin == NULL) { + if (mrb == NULL || bin == NULL) { return MRB_DUMP_INVALID_ARGUMENT; } cur += sizeof(struct rite_section_lineno_header); section_size += sizeof(struct rite_section_lineno_header); - for (irep_no = start_index; irep_no < mrb->irep_len; irep_no++) { - rlen = write_lineno_record(mrb, mrb->irep[irep_no], cur); - cur += rlen; - section_size += rlen; - } + rlen = write_lineno_record(mrb, irep, cur); + section_size += rlen; - mrb_write_section_lineno_header(mrb, section_size, mrb->irep_len - start_index, start_index, bin); + write_section_lineno_header(mrb, section_size, bin); return MRB_DUMP_OK; } @@ -394,11 +418,12 @@ { size_t ret = 0; uint32_t f_idx; + size_t i; ret += sizeof(uint32_t); // record size ret += sizeof(uint16_t); // file count - for(f_idx = 0; f_idx < irep->debug_info->flen; ++f_idx) { + for (f_idx = 0; f_idx < irep->debug_info->flen; ++f_idx) { mrb_irep_debug_info_file const* file = irep->debug_info->files[f_idx]; ret += sizeof(uint32_t); // position @@ -419,6 +444,9 @@ default: mrb_assert(0); break; } } + for (i=0; irlen; i++) { + ret += get_debug_record_size(mrb, irep->reps[i]); + } return ret; } @@ -428,14 +456,50 @@ { size_t i; - for(i = 0; i < ary_len; ++i) { - if(ary[i] == s) { return i; } + for (i = 0; i < ary_len; ++i) { + if (ary[i] == s) { return i; } } return -1; } +static size_t +get_filename_table_size(mrb_state *mrb, mrb_irep *irep, mrb_sym **fp, size_t *lp) +{ + mrb_sym *filenames = *fp; + size_t tsize = 0; + size_t file_i; + size_t size = 0; + mrb_irep_debug_info *di = irep->debug_info; + + if (lp == NULL) { + lp = &tsize; + } + for (file_i = 0; file_i < di->flen; ++file_i) { + mrb_irep_debug_info_file *file; + size_t filename_len; + size_t i; + + file = di->files[file_i]; + if (find_filename_index(filenames, *lp, file->filename_sym) == -1) { + // register filename + *lp += 1; + *fp = filenames = (mrb_sym *)mrb_realloc(mrb, filenames, sizeof(mrb_sym) * (*lp)); + filenames[*lp - 1] = file->filename_sym; + + // filename + mrb_sym2name_len(mrb, file->filename_sym, &filename_len); + size += sizeof(uint16_t) + filename_len; + } + for (i=0; irlen; i++) { + size += get_filename_table_size(mrb, irep->reps[i], fp, lp); + filenames = *fp; + } + } + return size; +} + static int -write_debug_record(mrb_state *mrb, mrb_irep *irep, uint8_t *bin, mrb_sym const* filenames, size_t filenames_len) +write_debug_record_1(mrb_state *mrb, mrb_irep *irep, uint8_t *bin, mrb_sym const* filenames, size_t filenames_len) { uint8_t *cur; uint32_t f_idx; @@ -444,7 +508,7 @@ 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) { + 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]; @@ -453,7 +517,7 @@ // filename index filename_idx = find_filename_index(filenames, filenames_len, - file->filename_sym); + file->filename_sym); mrb_assert(filename_idx != -1); cur += uint16_to_bin(filename_idx, cur); @@ -463,14 +527,14 @@ switch(file->line_type) { case mrb_debug_line_ary: { size_t l; - for(l = 0; l < file->line_entry_count; ++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) { + 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); } @@ -483,26 +547,70 @@ ret = cur - bin; uint32_to_bin(ret, bin); - mrb_assert((cur - bin) == (int)get_debug_record_size(mrb, irep)); - return ret; } static int -mrb_write_section_debug(mrb_state *mrb, size_t start_index, uint8_t *cur) +write_debug_record(mrb_state *mrb, mrb_irep *irep, uint8_t *bin, mrb_sym const* filenames, size_t filenames_len) +{ + uint32_t size, len; + size_t irep_no; + + size = len = write_debug_record_1(mrb, irep, bin, filenames, filenames_len); + bin += len; + for (irep_no = 0; irep_no < irep->rlen; irep_no++) { + len = write_debug_record(mrb, irep->reps[irep_no], bin, filenames, filenames_len); + bin += len; + size += len; + } + + mrb_assert(size == (int)get_debug_record_size(mrb, irep)); + return size; +} + +static int +write_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 int +write_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; + size_t filenames_len = 0, i; uint8_t *filenames_len_out; - size_t irep_i; - size_t file_i; - uint16_t fn_len; - size_t i; + uint32_t dlen; - if (mrb == NULL || start_index >= mrb->irep_len || cur == NULL) { + if (mrb == NULL || cur == NULL) { return MRB_DUMP_INVALID_ARGUMENT; } @@ -511,44 +619,22 @@ section_size += sizeof(struct rite_section_debug_header); // filename table - filenames = (mrb_sym *)mrb_malloc(mrb, sizeof(mrb_sym *) * 1); - filenames_len = 0; + filenames = (mrb_sym *)mrb_malloc(mrb, sizeof(mrb_sym) * 1); filenames_len_out = cur; cur += sizeof(uint16_t); section_size += sizeof(uint16_t); - for (irep_i = start_index; irep_i < mrb->irep_len; ++irep_i) { - mrb_irep_debug_info *debug_info = mrb->irep[irep_i]->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, filenames_len, file->filename_sym) != -1) continue; - - // register filename - filenames = (mrb_sym*)mrb_realloc(mrb, filenames, sizeof(mrb_sym*) * ++filenames_len); - filenames[filenames_len - 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; - - section_size += sizeof(uint16_t) + fn_len; - } + section_size += write_filename_table(mrb, irep, &cur, &filenames, &filenames_len); + for (i=0; irlen; i++) { + section_size += write_filename_table(mrb, irep->reps[i], &cur, &filenames, &filenames_len); } uint16_to_bin(filenames_len, filenames_len_out); - // records - for (i = start_index; i < mrb->irep_len; ++i) { - uint32_t rlen = write_debug_record(mrb, mrb->irep[i], cur, filenames, filenames_len); - cur += rlen; - section_size += rlen; - } + // 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)); uint32_to_bin(section_size, header->section_size); - uint16_to_bin(mrb->irep_len - start_index, header->nirep); - uint16_to_bin(start_index, header->sirep); mrb_free(mrb, filenames); @@ -575,124 +661,88 @@ return MRB_DUMP_OK; } -mrb_bool is_debug_info_defined(mrb_state *mrb, size_t const start_index) +static mrb_bool +is_debug_info_defined(mrb_irep *irep) { size_t i; - for (i = start_index; i < mrb->irep_len; ++i) { - if (!mrb->irep[i]->debug_info) { return 0; } + + if (!irep->debug_info) return 0; + for (i=0; irlen; i++) { + if (!is_debug_info_defined(irep->reps[i])) return 0; } return 1; } static int -mrb_dump_irep(mrb_state *mrb, size_t start_index, int debug_info, uint8_t **bin, size_t *bin_size) +dump_irep(mrb_state *mrb, mrb_irep *irep, int debug_info, uint8_t **bin, size_t *bin_size) { int result = MRB_DUMP_GENERAL_FAILURE; - size_t section_size = 0; size_t section_irep_size; size_t section_lineno_size = 0; - size_t irep_no; uint8_t *cur = NULL; + mrb_bool const debug_info_defined = is_debug_info_defined(irep); - mrb_bool const debug_info_defined = is_debug_info_defined(mrb, start_index); - - if (mrb == NULL || start_index >= mrb->irep_len) { + if (mrb == NULL) { *bin = NULL; return MRB_DUMP_GENERAL_FAILURE; } section_irep_size = sizeof(struct rite_section_irep_header); - for (irep_no = start_index; irep_no < mrb->irep_len; irep_no++) { - section_irep_size += get_irep_record_size(mrb, mrb->irep[irep_no]); - } - section_size += section_irep_size; + section_irep_size += get_irep_record_size(mrb, irep); /* DEBUG section size */ if (debug_info) { if (debug_info_defined) { mrb_sym *filenames; - size_t filenames_len; - size_t irep_i; - size_t file_i; section_lineno_size += sizeof(struct rite_section_debug_header); - // filename table - filenames = (mrb_sym *)mrb_malloc(mrb, sizeof(mrb_sym *) + 1); - filenames_len = 0; + filenames = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym) + 1); + // filename table size section_lineno_size += sizeof(uint16_t); - for (irep_i = start_index; irep_i < mrb->irep_len; ++irep_i) { - mrb_irep_debug_info *di = mrb->irep[irep_i]->debug_info; - - for(file_i = 0; file_i < di->flen; ++file_i) { - mrb_irep_debug_info_file *file; - size_t filename_len; - - file = di->files[file_i]; - if(find_filename_index(filenames, filenames_len, file->filename_sym) != -1) continue; - - // register filename - filenames = (mrb_sym *)mrb_realloc(mrb, filenames, sizeof(mrb_sym*) * ++filenames_len); - filenames[filenames_len - 1] = file->filename_sym; - - // filename - mrb_sym2name_len(mrb, file->filename_sym, &filename_len); - section_lineno_size += sizeof(uint16_t) + filename_len; - } - } + section_lineno_size += get_filename_table_size(mrb, irep, &filenames, NULL); mrb_free(mrb, filenames); - for(irep_no = start_index; irep_no < mrb->irep_len; ++irep_no) { - section_lineno_size += get_debug_record_size(mrb, mrb->irep[irep_no]); - } - section_size += section_lineno_size; + section_lineno_size += get_debug_record_size(mrb, irep); } else { section_lineno_size += sizeof(struct rite_section_lineno_header); - for (irep_no = start_index; irep_no < mrb->irep_len; irep_no++) { - section_lineno_size += get_lineno_record_size(mrb, mrb->irep[irep_no]); - } - section_size += section_lineno_size; + section_lineno_size += get_lineno_record_size(mrb, irep); } } - *bin_size += sizeof(struct rite_binary_header) + section_size + sizeof(struct rite_binary_footer); - cur = *bin = (uint8_t *)mrb_malloc(mrb, *bin_size); + *bin_size = sizeof(struct rite_binary_header) + + section_irep_size + section_lineno_size + + sizeof(struct rite_binary_footer); + cur = *bin = (uint8_t*)mrb_malloc(mrb, *bin_size); if (cur == NULL) { goto error_exit; } - cur += sizeof(struct rite_binary_header); - result = mrb_write_section_irep(mrb, start_index, cur); + result = write_section_irep(mrb, irep, cur); if (result != MRB_DUMP_OK) { goto error_exit; } - cur += section_irep_size; /* write DEBUG section */ if (debug_info) { - if(debug_info_defined) { - result = mrb_write_section_debug(mrb, start_index, cur); - if(result != MRB_DUMP_OK) { - goto error_exit; - } - cur += section_lineno_size; + if (debug_info_defined) { + result = write_section_debug(mrb, irep, cur); } else { - result = mrb_write_section_lineno(mrb, start_index, cur); - if (result != MRB_DUMP_OK) { - goto error_exit; - } - cur += section_lineno_size; + result = write_section_lineno(mrb, irep, cur); } + if (result != MRB_DUMP_OK) { + goto error_exit; + } + cur += section_lineno_size; } - mrb_write_eof(mrb, cur); - - result = write_rite_binary_header(mrb, *bin_size, *bin); + write_footer(mrb, cur); + write_rite_binary_header(mrb, *bin_size, *bin); error_exit: if (result != MRB_DUMP_OK) { @@ -706,7 +756,7 @@ #ifdef ENABLE_STDIO int -mrb_dump_irep_binary(mrb_state *mrb, size_t start_index, int debug_info, FILE* fp) +mrb_dump_irep_binary(mrb_state *mrb, mrb_irep *irep, int debug_info, FILE* fp) { uint8_t *bin = NULL; size_t bin_size = 0; @@ -716,7 +766,7 @@ return MRB_DUMP_INVALID_ARGUMENT; } - result = mrb_dump_irep(mrb, start_index, debug_info, &bin, &bin_size); + result = dump_irep(mrb, irep, debug_info, &bin, &bin_size); if (result == MRB_DUMP_OK) { fwrite(bin, bin_size, 1, fp); } @@ -742,7 +792,7 @@ } int -mrb_dump_irep_cfunc(mrb_state *mrb, size_t start_index, int debug_info, FILE *fp, const char *initname) +mrb_dump_irep_cfunc(mrb_state *mrb, mrb_irep *irep, int debug_info, FILE *fp, const char *initname) { uint8_t *bin = NULL; size_t bin_size = 0, bin_idx = 0; @@ -752,12 +802,12 @@ return MRB_DUMP_INVALID_ARGUMENT; } - result = mrb_dump_irep(mrb, start_index, debug_info, &bin, &bin_size); + result = dump_irep(mrb, irep, debug_info, &bin, &bin_size); if (result == MRB_DUMP_OK) { fprintf(fp, "#include \n"); // for uint8_t under at least Darwin fprintf(fp, "const uint8_t %s[] = {", initname); while (bin_idx < bin_size) { - if (bin_idx % 16 == 0 ) fputs("\n", fp); + if (bin_idx % 16 == 0) fputs("\n", fp); fprintf(fp, "0x%02x,", bin[bin_idx++]); } fputs("\n};\n", fp); diff -Nru mruby-0.0.0~20131107+gitf80401de/src/error.c mruby-0.0.0~20131214+git882afdea/src/error.c --- mruby-0.0.0~20131107+gitf80401de/src/error.c 2013-11-04 15:13:01.000000000 +0000 +++ mruby-0.0.0~20131214+git882afdea/src/error.c 2013-12-10 15:41:48.000000000 +0000 @@ -25,7 +25,7 @@ } mrb_value -mrb_exc_new3(mrb_state *mrb, struct RClass* c, mrb_value str) +mrb_exc_new_str(mrb_state *mrb, struct RClass* c, mrb_value str) { str = mrb_str_to_str(mrb, str); return mrb_funcall(mrb, mrb_obj_value(c), "new", 1, str); @@ -45,7 +45,7 @@ mrb_value mesg; if (mrb_get_args(mrb, "|o", &mesg) == 1) { - mrb_iv_set(mrb, exc, mrb_intern2(mrb, "mesg", 4), mesg); + mrb_iv_set(mrb, exc, mrb_intern_lit(mrb, "mesg"), mesg); } return exc; } @@ -74,7 +74,7 @@ if (argc == 0) return self; if (mrb_obj_equal(mrb, self, a)) return self; exc = mrb_obj_clone(mrb, self); - mrb_iv_set(mrb, exc, mrb_intern2(mrb, "mesg", 4), a); + mrb_iv_set(mrb, exc, mrb_intern_lit(mrb, "mesg"), a); return exc; } @@ -90,7 +90,7 @@ static mrb_value exc_to_s(mrb_state *mrb, mrb_value exc) { - mrb_value mesg = mrb_attr_get(mrb, exc, mrb_intern2(mrb, "mesg", 4)); + mrb_value mesg = mrb_attr_get(mrb, exc, mrb_intern_lit(mrb, "mesg")); if (mrb_nil_p(mesg)) return mrb_str_new_cstr(mrb, mrb_obj_classname(mrb, exc)); return mesg; @@ -124,9 +124,9 @@ { mrb_value str, mesg, file, line; - mesg = mrb_attr_get(mrb, exc, mrb_intern2(mrb, "mesg", 4)); - file = mrb_attr_get(mrb, exc, mrb_intern2(mrb, "file", 4)); - line = mrb_attr_get(mrb, exc, mrb_intern2(mrb, "line", 4)); + mesg = mrb_attr_get(mrb, exc, mrb_intern_lit(mrb, "mesg")); + file = mrb_attr_get(mrb, exc, mrb_intern_lit(mrb, "file")); + line = mrb_attr_get(mrb, exc, mrb_intern_lit(mrb, "line")); if (!mrb_nil_p(file) && !mrb_nil_p(line)) { str = file; @@ -163,7 +163,7 @@ mrb_value obj; mrb_value mesg; mrb_bool equal_p; - mrb_sym id_mesg = mrb_intern2(mrb, "mesg", 4); + mrb_sym id_mesg = mrb_intern_lit(mrb, "mesg"); mrb_get_args(mrb, "o", &obj); if (mrb_obj_equal(mrb, exc, obj)) { @@ -171,7 +171,7 @@ } else { if (mrb_obj_class(mrb, exc) != mrb_obj_class(mrb, obj)) { - if (mrb_respond_to(mrb, obj, mrb_intern2(mrb, "message", 7))) { + if (mrb_respond_to(mrb, obj, mrb_intern_lit(mrb, "message"))) { mesg = mrb_funcall(mrb, obj, "message", 0); } else @@ -193,7 +193,7 @@ mrb_callinfo *ci = mrb->c->ci; mrb_code *pc = ci->pc; - mrb_obj_iv_set(mrb, exc, mrb_intern2(mrb, "ciidx", 5), mrb_fixnum_value(ci - mrb->c->cibase)); + mrb_obj_iv_set(mrb, exc, mrb_intern_lit(mrb, "ciidx"), mrb_fixnum_value(ci - mrb->c->cibase)); while (ci >= mrb->c->cibase) { mrb_code *err = ci->err; @@ -204,8 +204,8 @@ int32_t const line = mrb_debug_get_line(irep, err - irep->iseq); char const* file = mrb_debug_get_filename(irep, err - irep->iseq); if (line != -1 && file) { - mrb_obj_iv_set(mrb, exc, mrb_intern2(mrb, "file", 4), mrb_str_new_cstr(mrb, file)); - mrb_obj_iv_set(mrb, exc, mrb_intern2(mrb, "line", 4), mrb_fixnum_value(line)); + mrb_obj_iv_set(mrb, exc, mrb_intern_lit(mrb, "file"), mrb_str_new_cstr(mrb, file)); + mrb_obj_iv_set(mrb, exc, mrb_intern_lit(mrb, "line"), mrb_fixnum_value(line)); return; } } @@ -231,7 +231,7 @@ { mrb_value mesg; mesg = mrb_str_new_cstr(mrb, msg); - mrb_exc_raise(mrb, mrb_exc_new3(mrb, c, mesg)); + mrb_exc_raise(mrb, mrb_exc_new_str(mrb, c, mesg)); } mrb_value @@ -297,7 +297,7 @@ va_start(args, fmt); mesg = mrb_vformat(mrb, fmt, args); va_end(args); - mrb_exc_raise(mrb, mrb_exc_new3(mrb, c, mesg)); + mrb_exc_raise(mrb, mrb_exc_new_str(mrb, c, mesg)); } void @@ -350,7 +350,7 @@ int sysexit_status(mrb_state *mrb, mrb_value err) { - mrb_value st = mrb_iv_get(mrb, err, mrb_intern2(mrb, "status", 6)); + mrb_value st = mrb_iv_get(mrb, err, mrb_intern_lit(mrb, "status")); return mrb_fixnum(st); } @@ -376,7 +376,7 @@ if (isstr) { mesg = mrb_check_string_type(mrb, argv[0]); if (!mrb_nil_p(mesg)) { - mesg = mrb_exc_new3(mrb, E_RUNTIME_ERROR, mesg); + mesg = mrb_exc_new_str(mrb, E_RUNTIME_ERROR, mesg); break; } } @@ -388,7 +388,7 @@ n = 1; exception_call: { - mrb_sym exc = mrb_intern2(mrb, "exception", 9); + mrb_sym exc = mrb_intern_lit(mrb, "exception"); if (mrb_respond_to(mrb, argv[0], exc)) { mesg = mrb_funcall_argv(mrb, argv[0], exc, n, argv+1); } diff -Nru mruby-0.0.0~20131107+gitf80401de/src/error.h mruby-0.0.0~20131214+git882afdea/src/error.h --- mruby-0.0.0~20131107+gitf80401de/src/error.h 2013-11-04 15:13:01.000000000 +0000 +++ mruby-0.0.0~20131214+git882afdea/src/error.h 2013-12-10 15:41:48.000000000 +0000 @@ -9,7 +9,7 @@ void mrb_sys_fail(mrb_state *mrb, const char *mesg); int sysexit_status(mrb_state *mrb, mrb_value err); -mrb_value mrb_exc_new3(mrb_state *mrb, struct RClass* c, mrb_value str); +mrb_value mrb_exc_new_str(mrb_state *mrb, struct RClass* c, mrb_value str); mrb_value make_exception(mrb_state *mrb, int argc, mrb_value *argv, int isstr); mrb_value mrb_make_exception(mrb_state *mrb, int argc, mrb_value *argv); mrb_value mrb_format(mrb_state *mrb, const char *format, ...); diff -Nru mruby-0.0.0~20131107+gitf80401de/src/etc.c mruby-0.0.0~20131214+git882afdea/src/etc.c --- mruby-0.0.0~20131107+gitf80401de/src/etc.c 2013-11-04 15:13:01.000000000 +0000 +++ mruby-0.0.0~20131214+git882afdea/src/etc.c 2013-12-10 15:41:48.000000000 +0000 @@ -199,6 +199,16 @@ } mrb_value +mrb_float_pool(mrb_state *mrb, mrb_float f) +{ + struct RFloat *nf = (struct RFloat *)mrb_malloc(mrb, sizeof(struct RFloat)); + nf->tt = MRB_TT_FLOAT; + nf->c = mrb->float_class; + nf->f = f; + return mrb_obj_value(nf); +} + +mrb_value mrb_cptr_value(mrb_state *mrb, void *p) { mrb_value v; diff -Nru mruby-0.0.0~20131107+gitf80401de/src/gc.c mruby-0.0.0~20131214+git882afdea/src/gc.c --- mruby-0.0.0~20131107+gitf80401de/src/gc.c 2013-11-04 15:13:01.000000000 +0000 +++ mruby-0.0.0~20131214+git882afdea/src/gc.c 2013-12-10 15:41:48.000000000 +0000 @@ -370,10 +370,16 @@ static void gc_protect(mrb_state *mrb, struct RBasic *p) { - if (mrb->arena_idx >= MRB_ARENA_SIZE) { + if (mrb->arena_idx >= MRB_GC_ARENA_SIZE) { +#ifdef MRB_GC_FIXED_ARENA /* arena overflow error */ - mrb->arena_idx = MRB_ARENA_SIZE - 4; /* force room in arena */ + mrb->arena_idx = MRB_GC_ARENA_SIZE - 4; /* force room in arena */ mrb_raise(mrb, E_RUNTIME_ERROR, "arena overflow error"); +#else + /* extend arena */ + mrb->arena_capa *= 1.5; + mrb->arena = (struct RBasic**)mrb_realloc(mrb, mrb->arena, sizeof(struct RBasic*)*mrb->arena_capa); +#endif } mrb->arena[mrb->arena_idx++] = p; } @@ -640,6 +646,16 @@ mrb_gc_free_str(mrb, (struct RString*)obj); break; + case MRB_TT_PROC: + { + struct RProc *p = (struct RProc*)obj; + + if (!MRB_PROC_CFUNC_P(p) && p->body.irep) { + mrb_irep_decref(mrb, p->body.irep); + } + } + break; + case MRB_TT_RANGE: mrb_free(mrb, ((struct RRange*)obj)->edges); break; @@ -663,7 +679,7 @@ static void root_scan_phase(mrb_state *mrb) { - size_t i, e, j; + size_t i, e; if (!is_minor_gc(mrb)) { mrb->gray_list = NULL; @@ -686,19 +702,6 @@ if (mrb->root_c != mrb->c) { mark_context(mrb, mrb->c); } - - /* mark irep pool */ - if (mrb->irep) { - size_t len = mrb->irep_len; - if (len > mrb->irep_capa) len = mrb->irep_capa; - for (i=0; iirep[i]; - if (!irep) continue; - for (j=0; jplen; j++) { - mrb_gc_mark_value(mrb, irep->pool[j]); - } - } - } } static size_t @@ -1044,6 +1047,20 @@ void mrb_gc_arena_restore(mrb_state *mrb, int idx) { +#ifndef MRB_GC_FIXED_ARENA + int capa = mrb->arena_capa; + + if (idx < capa / 2) { + capa *= 0.66; + if (capa < MRB_GC_ARENA_SIZE) { + capa = MRB_GC_ARENA_SIZE; + } + if (capa != mrb->arena_capa) { + mrb->arena = (struct RBasic**)mrb_realloc(mrb, mrb->arena, sizeof(struct RBasic*)*capa); + mrb->arena_capa = capa; + } + } +#endif mrb->arena_idx = idx; } diff -Nru mruby-0.0.0~20131107+gitf80401de/src/hash.c mruby-0.0.0~20131214+git882afdea/src/hash.c --- mruby-0.0.0~20131107+gitf80401de/src/hash.c 2013-11-04 15:13:01.000000000 +0000 +++ mruby-0.0.0~20131214+git882afdea/src/hash.c 2013-12-10 15:41:48.000000000 +0000 @@ -266,7 +266,7 @@ RHASH(hash)->flags |= MRB_HASH_PROC_DEFAULT; ifnone = block; } - mrb_iv_set(mrb, hash, mrb_intern2(mrb, "ifnone", 6), ifnone); + mrb_iv_set(mrb, hash, mrb_intern_lit(mrb, "ifnone"), ifnone); return hash; } @@ -425,7 +425,7 @@ mrb_get_args(mrb, "o", &ifnone); mrb_hash_modify(mrb, hash); - mrb_iv_set(mrb, hash, mrb_intern2(mrb, "ifnone", 6), ifnone); + mrb_iv_set(mrb, hash, mrb_intern_lit(mrb, "ifnone"), ifnone); RHASH(hash)->flags &= ~(MRB_HASH_PROC_DEFAULT); return ifnone; @@ -476,7 +476,7 @@ mrb_get_args(mrb, "o", &ifnone); mrb_hash_modify(mrb, hash); - mrb_iv_set(mrb, hash, mrb_intern2(mrb, "ifnone", 6), ifnone); + mrb_iv_set(mrb, hash, mrb_intern_lit(mrb, "ifnone"), ifnone); RHASH(hash)->flags |= MRB_HASH_PROC_DEFAULT; return ifnone; @@ -734,7 +734,7 @@ else { ifnone = RHASH_IFNONE(hash2); } - mrb_iv_set(mrb, hash, mrb_intern2(mrb, "ifnone", 6), ifnone); + mrb_iv_set(mrb, hash, mrb_intern_lit(mrb, "ifnone"), ifnone); return hash; } @@ -1004,7 +1004,7 @@ if (mrb_obj_equal(mrb, hash1, hash2)) return mrb_true_value(); if (!mrb_hash_p(hash2)) { - if (!mrb_respond_to(mrb, hash2, mrb_intern2(mrb, "to_hash", 7))) { + if (!mrb_respond_to(mrb, hash2, mrb_intern_lit(mrb, "to_hash"))) { return mrb_false_value(); } if (eql) diff -Nru mruby-0.0.0~20131107+gitf80401de/src/kernel.c mruby-0.0.0~20131214+git882afdea/src/kernel.c --- mruby-0.0.0~20131107+gitf80401de/src/kernel.c 2013-11-04 15:13:01.000000000 +0000 +++ mruby-0.0.0~20131214+git882afdea/src/kernel.c 2013-12-10 15:41:48.000000000 +0000 @@ -29,7 +29,7 @@ mrb_bool mrb_obj_basic_to_s_p(mrb_state *mrb, mrb_value obj) { - struct RProc *me = mrb_method_search(mrb, mrb_class(mrb, obj), mrb_intern2(mrb, "to_s", 4)); + struct RProc *me = mrb_method_search(mrb, mrb_class(mrb, obj), mrb_intern_lit(mrb, "to_s")); if (me && MRB_PROC_CFUNC_P(me) && (me->body.func == mrb_any_to_s)) return TRUE; return FALSE; @@ -280,7 +280,7 @@ clone->super = klass->super; if (klass->iv) { mrb_iv_copy(mrb, mrb_obj_value(clone), mrb_obj_value(klass)); - mrb_obj_iv_set(mrb, (struct RObject*)clone, mrb_intern2(mrb, "__attached__", 12), obj); + mrb_obj_iv_set(mrb, (struct RObject*)clone, mrb_intern_lit(mrb, "__attached__"), obj); } if (klass->mt) { clone->mt = kh_copy(mt, mrb, klass->mt); @@ -944,7 +944,7 @@ /* fall through */ default: exc = mrb_make_exception(mrb, argc, a); - mrb_obj_iv_set(mrb, mrb_obj_ptr(exc), mrb_intern2(mrb, "lastpc", 6), mrb_cptr_value(mrb, mrb->c->ci->pc)); + mrb_obj_iv_set(mrb, mrb_obj_ptr(exc), mrb_intern_lit(mrb, "lastpc"), mrb_cptr_value(mrb, mrb->c->ci->pc)); mrb_exc_raise(mrb, exc); break; } @@ -1049,7 +1049,7 @@ } if (!respond_to_p) { - rtm_id = mrb_intern2(mrb, "respond_to_missing?", 19); + rtm_id = mrb_intern_lit(mrb, "respond_to_missing?"); if (basic_obj_respond_to(mrb, self, rtm_id, !mrb_test(priv))) { return mrb_funcall_argv(mrb, self, rtm_id, argc, argv); } @@ -1151,5 +1151,5 @@ mrb_define_method(mrb, krn, "to_s", mrb_any_to_s, MRB_ARGS_NONE()); /* 15.3.1.3.46 */ mrb_include_module(mrb, mrb->object_class, mrb->kernel_module); - mrb_alias_method(mrb, mrb->module_class, mrb_intern2(mrb, "dup", 3), mrb_intern2(mrb, "clone", 5)); + mrb_alias_method(mrb, mrb->module_class, mrb_intern_lit(mrb, "dup"), mrb_intern_lit(mrb, "clone")); } diff -Nru mruby-0.0.0~20131107+gitf80401de/src/load.c mruby-0.0.0~20131214+git882afdea/src/load.c --- mruby-0.0.0~20131107+gitf80401de/src/load.c 2013-11-04 15:13:01.000000000 +0000 +++ mruby-0.0.0~20131214+git882afdea/src/load.c 2013-12-10 15:41:48.000000000 +0000 @@ -30,31 +30,6 @@ # 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]); - } - } -} - static size_t offset_crc_body(void) { @@ -62,10 +37,9 @@ 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, uint32_t *len) { - int ret; size_t i; const uint8_t *src = bin; uint16_t tt, pool_data_len, snl; @@ -84,19 +58,21 @@ irep->nregs = bin_to_uint16(src); src += sizeof(uint16_t); + // number of child irep + irep->rlen = bin_to_uint16(src); + src += sizeof(uint16_t); + // Binary Data Section // ISEQ BLOCK irep->ilen = 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; + return NULL; } for (i = 0; i < irep->ilen; i++) { irep->iseq[i] = bin_to_uint32(src); //iseq @@ -109,36 +85,36 @@ src += sizeof(uint32_t); if (plen > 0) { if (SIZE_ERROR_MUL(sizeof(mrb_value), plen)) { - ret = MRB_DUMP_GENERAL_FAILURE; - goto error_exit; + return NULL; } - irep->pool = (mrb_value *)mrb_malloc(mrb, sizeof(mrb_value) * plen); + 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; } for (i = 0; i < plen; i++) { mrb_value s; + 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); src += pool_data_len; switch (tt) { //pool data - case MRB_TT_FIXNUM: + 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; } @@ -152,13 +128,11 @@ 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; + return NULL; } for (i = 0; i < irep->slen; i++) { @@ -170,53 +144,47 @@ continue; } - irep->syms[i] = mrb_intern2(mrb, (char *)src, snl); + irep->syms[i] = mrb_intern(mrb, (char *)src, snl); src += snl + 1; mrb_gc_arena_restore(mrb, ai); } } + + irep->reps = (mrb_irep**)mrb_malloc(mrb, sizeof(mrb_irep*)*irep->rlen); *len = src - bin; - ret = MRB_DUMP_OK; -error_exit: - return ret; + 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, uint32_t *len) { - 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); + size_t i; - sirep = mrb->irep_len; - nirep = bin_to_uint16(header->nirep); + bin += *len; + for (i=0; irlen; i++) { + uint32_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); + 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) +{ + uint32_t len; + + bin += sizeof(struct rite_section_irep_header); + return read_irep_record(mrb, bin, &len); } 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, uint32_t *len) { int ret; size_t i, fname_len, niseq; @@ -231,13 +199,11 @@ 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; + return MRB_DUMP_GENERAL_FAILURE; } memcpy(fname, bin, fname_len); fname[fname_len] = '\0'; @@ -249,63 +215,58 @@ *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; + 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); - } - - 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, uint32_t *lenp) { - int result; + int result = read_lineno_record_1(mrb, bin, irep, lenp); size_t i; + + if (result != MRB_DUMP_OK) return result; + for (i = 0; i < irep->rlen; i++) { + uint32_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) +{ uint32_t len; - uint16_t nirep; - uint16_t n; - const struct rite_section_lineno_header *header; 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 - 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; - bin += len; - } - - result = sirep + bin_to_uint16(header->sirep); -error_exit: - return result; + return read_lineno_record(mrb, bin, irep, &len); } static int -read_rite_debug_record(mrb_state *mrb, const uint8_t *start, size_t irepno, uint32_t *len, const mrb_sym *filenames, size_t filenames_len) +read_debug_record(mrb_state *mrb, const uint8_t *start, mrb_irep* irep, uint32_t *len, const mrb_sym *filenames, size_t filenames_len) { const uint8_t *bin = start; - mrb_irep *irep = mrb->irep[irepno]; - size_t record_size; + size_t record_size, i; uint16_t f_idx; if(irep->debug_info) { return MRB_DUMP_INVALID_IREP; } @@ -368,19 +329,28 @@ return MRB_DUMP_GENERAL_FAILURE; } + for (i = 0; i < irep->rlen; i++) { + uint32_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; + } + *len = bin - start; return MRB_DUMP_OK; } static int -read_rite_section_debug(mrb_state *mrb, const uint8_t *start, size_t sirep) +read_section_debug(mrb_state *mrb, const uint8_t *start, mrb_irep *irep) { const uint8_t *bin; struct rite_section_debug_header *header; uint16_t i; + uint32_t len = 0; int result; - uint16_t nirep; size_t filenames_len; mrb_sym *filenames; @@ -388,37 +358,31 @@ header = (struct rite_section_debug_header *)bin; bin += sizeof(struct rite_section_debug_header); - nirep = bin_to_uint16(header->nirep); - filenames_len = bin_to_uint16(bin); bin += sizeof(uint16_t); - filenames = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym*) * filenames_len); + filenames = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym) * filenames_len); for(i = 0; i < filenames_len; ++i) { uint16_t f_len = bin_to_uint16(bin); bin += sizeof(uint16_t); - filenames[i] = mrb_intern2(mrb, (const char *)bin, f_len); + filenames[i] = mrb_intern(mrb, (const char *)bin, f_len); bin += f_len; } - for(i = sirep; i < (sirep + nirep); ++i) { - uint32_t len = 0; - result = read_rite_debug_record(mrb, bin, i, &len, filenames, filenames_len); - if (result != MRB_DUMP_OK) { goto debug_exit; } - bin += len; - } + result = read_debug_record(mrb, bin, irep, &len, filenames, filenames_len); + if (result != MRB_DUMP_OK) goto debug_exit; + bin += len; if ((bin - start) != bin_to_uint32(header->section_size)) { - return MRB_DUMP_GENERAL_FAILURE; + result = MRB_DUMP_GENERAL_FAILURE; } - result = sirep + bin_to_uint16(header->sirep); 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; @@ -438,226 +402,195 @@ 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); - if (result < MRB_DUMP_OK) { - return result; - } - total_nirep += result; + irep = read_section_irep(mrb, bin); + if (!irep) return NULL; } 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); + if (!irep) return NULL; /* corrupted data */ + result = read_section_lineno(mrb, bin, irep); if (result < MRB_DUMP_OK) { - return result; + return NULL; } } else if (memcmp(section_header->section_identify, RITE_SECTION_DEBUG_IDENTIFIER, sizeof(section_header->section_identify)) == 0) { - result = read_rite_section_debug(mrb, bin, sirep); + if (!irep) return NULL; /* corrupted data */ + result = read_section_debug(mrb, bin, irep); 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_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_context_run(mrb, mrb_proc_new(mrb, mrb->irep[n]), mrb_top_self(mrb), 0); + proc = mrb_proc_new(mrb, irep); + mrb_irep_decref(mrb, irep); + if (c && c->no_exec) return mrb_obj_value(proc); + val = mrb_context_run(mrb, proc, mrb_top_self(mrb), 0); + 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; + uint32_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; + buf_size = bin_to_uint32(&header[0]); + if (SIZE_ERROR(buf_size)) { + return MRB_DUMP_GENERAL_FAILURE; } - - //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; + ptr = mrb_malloc(mrb, buf_size); + if (!ptr) { + return MRB_DUMP_GENERAL_FAILURE; } + 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; + 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; + uint32_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 = bin_to_uint32(&header[0]); + if (SIZE_ERROR(buf_size)) { + return NULL; + } + ptr = mrb_malloc(mrb, buf_size); + if (!ptr) return NULL; + 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); + mrb_free(mrb, ptr); + if (!irep) return NULL; + for (i=0; irlen; i++) { + irep->reps[i] = read_irep_record_file(mrb, fp); + if (!irep->reps[i]) return NULL; } - if (result < MRB_DUMP_OK) { - irep_free(sirep, mrb); + 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 result; + 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 nbytes; - size_t sirep; struct rite_section_header section_header; long fpos; size_t block_size = 1 << 14; @@ -666,22 +599,22 @@ 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; + return NULL; } 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 */ @@ -692,7 +625,7 @@ 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) { @@ -700,66 +633,75 @@ } 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 do { fpos = ftell(fp); if (fread(§ion_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); 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) { - uint8_t* const bin = mrb_malloc(mrb, section_size); - fseek(fp, fpos, SEEK_SET); - if(fread((char*)bin, section_size, 1, fp) != 1) { + if (!irep) return NULL; /* corrupted data */ + else { + uint8_t* const bin = 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); mrb_free(mrb, bin); - return MRB_DUMP_READ_FAULT; - } - result = read_rite_section_debug(mrb, bin, sirep); - mrb_free(mrb, bin); - if (result < MRB_DUMP_OK) { - return result; } + 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_context_run(mrb, mrb_proc_new(mrb, mrb->irep[n]), mrb_top_self(mrb), 0); + proc = mrb_proc_new(mrb, irep); + mrb_irep_decref(mrb, irep); + if (c && c->no_exec) return mrb_obj_value(proc); + val = mrb_context_run(mrb, proc, mrb_top_self(mrb), 0); + 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 */ diff -Nru mruby-0.0.0~20131107+gitf80401de/src/numeric.c mruby-0.0.0~20131214+git882afdea/src/numeric.c --- mruby-0.0.0~20131107+gitf80401de/src/numeric.c 2013-11-04 15:13:01.000000000 +0000 +++ mruby-0.0.0~20131214+git882afdea/src/numeric.c 2013-12-10 15:41:48.000000000 +0000 @@ -1071,7 +1071,7 @@ if (mrb_float_p(x)) { mrb_raise(mrb, E_TYPE_ERROR, "non float value"); - z = 0; /* not reached. just supress warnings. */ + z = 0; /* not reached. just suppress warnings. */ } else { mrb_float d = mrb_float(x); diff -Nru mruby-0.0.0~20131107+gitf80401de/src/parse.y mruby-0.0.0~20131214+git882afdea/src/parse.y --- mruby-0.0.0~20131107+gitf80401de/src/parse.y 2013-11-04 15:13:01.000000000 +0000 +++ mruby-0.0.0~20131214+git882afdea/src/parse.y 2013-12-10 15:41:48.000000000 +0000 @@ -66,23 +66,23 @@ #define nsym(x) ((node*)(intptr_t)(x)) static inline mrb_sym -intern_gen(parser_state *p, const char *s) +intern_cstr_gen(parser_state *p, const char *s) { return mrb_intern_cstr(p->mrb, s); } -#define intern(s) intern_gen(p,(s)) +#define intern_cstr(s) intern_cstr_gen(p,(s)) static inline mrb_sym -intern_gen2(parser_state *p, const char *s, size_t len) +intern_gen(parser_state *p, const char *s, size_t len) { - return mrb_intern2(p->mrb, s, len); + return mrb_intern(p->mrb, s, len); } -#define intern2(s,len) intern_gen2(p,(s),(len)) +#define intern(s,len) intern_gen(p,(s),(len)) static inline mrb_sym intern_gen_c(parser_state *p, const char c) { - return mrb_intern2(p->mrb, &c, 1); + return mrb_intern(p->mrb, &c, 1); } #define intern_c(c) intern_gen_c(p,(c)) @@ -538,7 +538,7 @@ const char *s = (const char*)str->cdr->car; size_t len = (size_t)str->cdr->cdr; - return mrb_intern2(p->mrb, s, len); + return mrb_intern(p->mrb, s, len); } // (:lvar . a) @@ -800,14 +800,14 @@ static node* call_uni_op(parser_state *p, node *recv, char *m) { - return new_call(p, recv, intern(m), 0); + return new_call(p, recv, intern_cstr(m), 0); } // (:call a op b) static node* call_bin_op(parser_state *p, node *recv, char *m, node *arg1) { - return new_call(p, recv, intern(m), list1(list1(arg1))); + return new_call(p, recv, intern_cstr(m), list1(list1(arg1))); } static void @@ -1284,7 +1284,7 @@ } | primary_value '[' opt_call_args rbracket tOP_ASGN command_call { - $$ = new_op_asgn(p, new_call(p, $1, intern2("[]",2), $3), $5, $6); + $$ = new_op_asgn(p, new_call(p, $1, intern("[]",2), $3), $5, $6); } | primary_value '.' tIDENTIFIER tOP_ASGN command_call { @@ -1523,7 +1523,7 @@ } | primary_value '[' opt_call_args rbracket { - $$ = new_call(p, $1, intern2("[]",2), $3); + $$ = new_call(p, $1, intern("[]",2), $3); } | primary_value '.' tIDENTIFIER { @@ -1562,7 +1562,7 @@ } | primary_value '[' opt_call_args rbracket { - $$ = new_call(p, $1, intern2("[]",2), $3); + $$ = new_call(p, $1, intern("[]",2), $3); } | primary_value '.' tIDENTIFIER { @@ -1648,31 +1648,31 @@ op : '|' { $$ = intern_c('|'); } | '^' { $$ = intern_c('^'); } | '&' { $$ = intern_c('&'); } - | tCMP { $$ = intern2("<=>",3); } - | tEQ { $$ = intern2("==",2); } - | tEQQ { $$ = intern2("===",3); } - | tMATCH { $$ = intern2("=~",2); } - | tNMATCH { $$ = intern2("!~",2); } + | tCMP { $$ = intern("<=>",3); } + | tEQ { $$ = intern("==",2); } + | tEQQ { $$ = intern("===",3); } + | tMATCH { $$ = intern("=~",2); } + | tNMATCH { $$ = intern("!~",2); } | '>' { $$ = intern_c('>'); } - | tGEQ { $$ = intern2(">=",2); } + | tGEQ { $$ = intern(">=",2); } | '<' { $$ = intern_c('<'); } - | tLEQ { $$ = intern2("<=",2); } - | tNEQ { $$ = intern2("!=",2); } - | tLSHFT { $$ = intern2("<<",2); } - | tRSHFT { $$ = intern2(">>",2); } + | tLEQ { $$ = intern("<=",2); } + | tNEQ { $$ = intern("!=",2); } + | tLSHFT { $$ = intern("<<",2); } + | tRSHFT { $$ = intern(">>",2); } | '+' { $$ = intern_c('+'); } | '-' { $$ = intern_c('-'); } | '*' { $$ = intern_c('*'); } | tSTAR { $$ = intern_c('*'); } | '/' { $$ = intern_c('/'); } | '%' { $$ = intern_c('%'); } - | tPOW { $$ = intern2("**",2); } + | tPOW { $$ = intern("**",2); } | '!' { $$ = intern_c('!'); } | '~' { $$ = intern_c('~'); } - | tUPLUS { $$ = intern2("+@",2); } - | tUMINUS { $$ = intern2("-@",2); } - | tAREF { $$ = intern2("[]",2); } - | tASET { $$ = intern2("[]=",3); } + | tUPLUS { $$ = intern("+@",2); } + | tUMINUS { $$ = intern("-@",2); } + | tAREF { $$ = intern("[]",2); } + | tASET { $$ = intern("[]=",3); } | '`' { $$ = intern_c('`'); } ; @@ -1708,7 +1708,7 @@ } | primary_value '[' opt_call_args rbracket tOP_ASGN arg { - $$ = new_op_asgn(p, new_call(p, $1, intern2("[]",2), $3), $5, $6); + $$ = new_op_asgn(p, new_call(p, $1, intern("[]",2), $3), $5, $6); } | primary_value '.' tIDENTIFIER tOP_ASGN arg { @@ -2520,11 +2520,11 @@ } | primary_value '.' paren_args { - $$ = new_call(p, $1, intern2("call",4), $3); + $$ = new_call(p, $1, intern("call",4), $3); } | primary_value tCOLON2 paren_args { - $$ = new_call(p, $1, intern2("call",4), $3); + $$ = new_call(p, $1, intern("call",4), $3); } | keyword_super paren_args { @@ -2536,7 +2536,7 @@ } | primary_value '[' opt_call_args rbracket { - $$ = new_call(p, $1, intern2("[]",2), $3); + $$ = new_call(p, $1, intern("[]",2), $3); } ; @@ -3316,14 +3316,14 @@ else { #ifdef ENABLE_STDIO if (p->f) { - if (feof(p->f)) goto end_retry; + if (feof(p->f)) goto eof; c = fgetc(p->f); - if (c == EOF) goto end_retry; + if (c == EOF) goto eof; } else #endif if (!p->s || p->s >= p->send) { - goto end_retry; + goto eof; } else { c = (unsigned char)*p->s++; @@ -3332,7 +3332,7 @@ p->column++; return c; - end_retry: + eof: if (!p->cxt) return -1; else { mrbc_context *cxt = p->cxt; @@ -3867,6 +3867,9 @@ return 0; } } else { + if (c == -1) { + return 0; /* missing here document identifier */ + } if (! identchar(c)) { pushback(p, c); if (indent) pushback(p, '-'); @@ -3930,7 +3933,10 @@ case '\0': /* NUL */ case '\004': /* ^D */ case '\032': /* ^Z */ + return 0; case -1: /* end of script. */ + if (p->heredocs_from_nextline) + goto maybe_heredoc; return 0; /* white spaces */ @@ -3943,6 +3949,7 @@ skip(p, '\n'); /* fall through */ case '\n': + maybe_heredoc: heredoc_treat_nextline(p); switch (p->lstate) { case EXPR_BEG: @@ -3989,7 +3996,7 @@ case '*': if ((c = nextc(p)) == '*') { if ((c = nextc(p)) == '=') { - yylval.id = intern2("**",2); + yylval.id = intern("**",2); p->lstate = EXPR_BEG; return tOP_ASGN; } @@ -4098,7 +4105,7 @@ } if (c == '<') { if ((c = nextc(p)) == '=') { - yylval.id = intern2("<<",2); + yylval.id = intern("<<",2); p->lstate = EXPR_BEG; return tOP_ASGN; } @@ -4119,7 +4126,7 @@ } if (c == '>') { if ((c = nextc(p)) == '=') { - yylval.id = intern2(">>",2); + yylval.id = intern(">>",2); p->lstate = EXPR_BEG; return tOP_ASGN; } @@ -4233,7 +4240,7 @@ if ((c = nextc(p)) == '&') { p->lstate = EXPR_BEG; if ((c = nextc(p)) == '=') { - yylval.id = intern2("&&",2); + yylval.id = intern("&&",2); p->lstate = EXPR_BEG; return tOP_ASGN; } @@ -4267,7 +4274,7 @@ if ((c = nextc(p)) == '|') { p->lstate = EXPR_BEG; if ((c = nextc(p)) == '=') { - yylval.id = intern2("||",2); + yylval.id = intern("||",2); p->lstate = EXPR_BEG; return tOP_ASGN; } @@ -4871,7 +4878,7 @@ tokadd(p, '$'); tokadd(p, c); tokfix(p); - yylval.id = intern(tok(p)); + yylval.id = intern_cstr(tok(p)); return tGVAR; case '-': @@ -4881,7 +4888,7 @@ pushback(p, c); gvar: tokfix(p); - yylval.id = intern(tok(p)); + yylval.id = intern_cstr(tok(p)); return tGVAR; case '&': /* $&: last match */ @@ -5033,7 +5040,7 @@ p->lstate = EXPR_BEG; nextc(p); tokfix(p); - yylval.id = intern(tok(p)); + yylval.id = intern_cstr(tok(p)); return tLABEL; } } @@ -5046,7 +5053,7 @@ enum mrb_lex_state_enum state = p->lstate; p->lstate = kw->state; if (state == EXPR_FNAME) { - yylval.id = intern(kw->name); + yylval.id = intern_cstr(kw->name); return kw->id[0]; } if (p->lstate == EXPR_BEG) { @@ -5091,7 +5098,7 @@ } } { - mrb_sym ident = intern(tok(p)); + mrb_sym ident = intern_cstr(tok(p)); yylval.id = ident; #if 0 @@ -5374,11 +5381,11 @@ if (proc == NULL) { static const char msg[] = "codegen error"; mrb->exc = mrb_obj_ptr(mrb_exc_new(mrb, E_SCRIPT_ERROR, msg, sizeof(msg) - 1)); - return mrb_nil_value(); + return mrb_undef_value(); } if (c) { if (c->dump_result) codedump_all(mrb, proc); - if (c->no_exec) return mrb_fixnum_value(0); + if (c->no_exec) return mrb_obj_value(proc); if (c->target_class) { target = c->target_class; } diff -Nru mruby-0.0.0~20131107+gitf80401de/src/proc.c mruby-0.0.0~20131214+git882afdea/src/proc.c --- mruby-0.0.0~20131107+gitf80401de/src/proc.c 2013-11-04 15:13:01.000000000 +0000 +++ mruby-0.0.0~20131214+git882afdea/src/proc.c 2013-12-10 15:41:48.000000000 +0000 @@ -22,6 +22,7 @@ p->target_class = (mrb->c->ci) ? mrb->c->ci->target_class : 0; p->body.irep = irep; p->env = 0; + mrb_irep_incref(mrb, irep); return p; } @@ -80,6 +81,9 @@ { a->flags = b->flags; a->body = b->body; + if (!MRB_PROC_CFUNC_P(a)) { + a->body.irep->refcnt++; + }; a->target_class = b->target_class; a->env = b->env; } @@ -181,15 +185,14 @@ mrb_init_proc(mrb_state *mrb) { struct RProc *m; - mrb_irep *call_irep = (mrb_irep *)mrb_alloca(mrb, sizeof(mrb_irep)); + mrb_irep *call_irep = (mrb_irep *)mrb_malloc(mrb, sizeof(mrb_irep)); static const mrb_irep mrb_irep_zero = { 0 }; - if ( call_iseq == NULL || call_irep == NULL ) + if (call_irep == NULL) return; *call_irep = mrb_irep_zero; call_irep->flags = MRB_ISEQ_NO_FREE; - call_irep->idx = -1; call_irep->iseq = call_iseq; call_irep->ilen = 1; @@ -201,8 +204,8 @@ mrb_define_method(mrb, mrb->proc_class, "arity", mrb_proc_arity, MRB_ARGS_NONE()); m = mrb_proc_new(mrb, call_irep); - mrb_define_method_raw(mrb, mrb->proc_class, mrb_intern2(mrb, "call", 4), m); - mrb_define_method_raw(mrb, mrb->proc_class, mrb_intern2(mrb, "[]", 2), m); + mrb_define_method_raw(mrb, mrb->proc_class, mrb_intern_lit(mrb, "call"), m); + mrb_define_method_raw(mrb, mrb->proc_class, mrb_intern_lit(mrb, "[]"), m); mrb_define_class_method(mrb, mrb->kernel_module, "lambda", proc_lambda, MRB_ARGS_NONE()); /* 15.3.1.2.6 */ mrb_define_method(mrb, mrb->kernel_module, "lambda", proc_lambda, MRB_ARGS_NONE()); /* 15.3.1.3.27 */ diff -Nru mruby-0.0.0~20131107+gitf80401de/src/re.h mruby-0.0.0~20131214+git882afdea/src/re.h --- mruby-0.0.0~20131107+gitf80401de/src/re.h 2013-11-04 15:13:01.000000000 +0000 +++ mruby-0.0.0~20131214+git882afdea/src/re.h 2013-12-10 15:41:48.000000000 +0000 @@ -8,6 +8,5 @@ #define RE_H #define REGEXP_CLASS "Regexp" -#define REGEXP_CLASS_CSTR_LEN 6 #endif diff -Nru mruby-0.0.0~20131107+gitf80401de/src/state.c mruby-0.0.0~20131214+git882afdea/src/state.c --- mruby-0.0.0~20131107+gitf80401de/src/state.c 2013-11-04 15:13:01.000000000 +0000 +++ mruby-0.0.0~20131214+git882afdea/src/state.c 2013-12-10 15:41:48.000000000 +0000 @@ -11,6 +11,7 @@ #include "mruby/irep.h" #include "mruby/variable.h" #include "mruby/debug.h" +#include "mruby/string.h" void mrb_init_heap(mrb_state*); void mrb_init_core(mrb_state*); @@ -41,6 +42,11 @@ mrb->allocf = f; mrb->current_white_part = MRB_GC_WHITE_A; +#ifndef MRB_GC_FIXED_ARENA + mrb->arena = (struct RBasic**)mrb_malloc(mrb, sizeof(struct RBasic*)*MRB_GC_ARENA_SIZE); + mrb->arena_capa = MRB_GC_ARENA_SIZE; +#endif + mrb_init_heap(mrb); mrb->c = (struct mrb_context*)mrb_malloc(mrb, sizeof(struct mrb_context)); *mrb->c = mrb_context_zero; @@ -107,18 +113,72 @@ void mrb_free_heap(mrb_state *mrb); void -mrb_irep_free(mrb_state *mrb, struct mrb_irep *irep) +mrb_irep_incref(mrb_state *mrb, mrb_irep *irep) { + irep->refcnt++; +} + +void +mrb_irep_decref(mrb_state *mrb, mrb_irep *irep) +{ + irep->refcnt--; + if (irep->refcnt == 0) { + mrb_irep_free(mrb, irep); + } +} + +void +mrb_irep_free(mrb_state *mrb, mrb_irep *irep) +{ + size_t i; + if (!(irep->flags & MRB_ISEQ_NO_FREE)) mrb_free(mrb, irep->iseq); + for (i=0; iplen; i++) { + if (mrb_type(irep->pool[i]) == MRB_TT_STRING) { + mrb_free(mrb, mrb_str_ptr(irep->pool[i])->ptr); + mrb_free(mrb, mrb_obj_ptr(irep->pool[i])); + } +#ifdef MRB_WORD_BOXING + else if (mrb_type(irep->pool[i]) == MRB_TT_FLOAT) { + mrb_free(mrb, mrb_obj_ptr(irep->pool[i])); + } +#endif + } mrb_free(mrb, irep->pool); mrb_free(mrb, irep->syms); + for (i=0; irlen; i++) { + mrb_irep_decref(mrb, irep->reps[i]); + } + mrb_free(mrb, irep->reps); mrb_free(mrb, (void *)irep->filename); mrb_free(mrb, irep->lines); mrb_debug_info_free(mrb, irep->debug_info); mrb_free(mrb, irep); } +mrb_value +mrb_str_pool(mrb_state *mrb, mrb_value str) +{ + struct RString *s = mrb_str_ptr(str); + struct RString *ns; + mrb_int len; + + ns = (struct RString *)mrb_malloc(mrb, sizeof(struct RString)); + ns->tt = MRB_TT_STRING; + ns->c = mrb->string_class; + + len = s->len; + ns->len = len; + ns->ptr = (char *)mrb_malloc(mrb, (size_t)len+1); + if (s->ptr) { + memcpy(ns->ptr, s->ptr, len); + } + ns->ptr[len] = '\0'; + + return mrb_obj_value(ns); +} + void mrb_free_context(mrb_state *mrb, struct mrb_context *c) { @@ -133,20 +193,17 @@ void mrb_close(mrb_state *mrb) { - size_t i; - mrb_final_core(mrb); /* free */ mrb_gc_free_gv(mrb); - for (i=0; iirep_len; i++) { - mrb_irep_free(mrb, mrb->irep[i]); - } - mrb_free(mrb, mrb->irep); mrb_free_context(mrb, mrb->root_c); mrb_free_symtbl(mrb); mrb_free_heap(mrb); mrb_alloca_free(mrb); +#ifndef MRB_GC_FIXED_ARENA + mrb_free(mrb, mrb->arena); +#endif mrb_free(mrb, mrb); } @@ -160,28 +217,9 @@ static const mrb_irep mrb_irep_zero = { 0 }; mrb_irep *irep; - if (!mrb->irep) { - size_t max = MRB_IREP_ARRAY_INIT_SIZE; - - if (mrb->irep_len > max) max = mrb->irep_len+1; - mrb->irep = (mrb_irep **)mrb_calloc(mrb, max, sizeof(mrb_irep*)); - mrb->irep_capa = max; - } - else if (mrb->irep_capa <= mrb->irep_len) { - size_t i; - size_t old_capa = mrb->irep_capa; - while (mrb->irep_capa <= mrb->irep_len) { - mrb->irep_capa *= 2; - } - mrb->irep = (mrb_irep **)mrb_realloc(mrb, mrb->irep, sizeof(mrb_irep*)*mrb->irep_capa); - for (i = old_capa; i < mrb->irep_capa; i++) { - mrb->irep[i] = NULL; - } - } irep = (mrb_irep *)mrb_malloc(mrb, sizeof(mrb_irep)); *irep = mrb_irep_zero; - mrb->irep[mrb->irep_len] = irep; - irep->idx = mrb->irep_len++; + irep->refcnt = 1; return irep; } diff -Nru mruby-0.0.0~20131107+gitf80401de/src/string.c mruby-0.0.0~20131214+git882afdea/src/string.c --- mruby-0.0.0~20131107+gitf80401de/src/string.c 2013-11-04 15:13:01.000000000 +0000 +++ mruby-0.0.0~20131214+git882afdea/src/string.c 2013-12-10 15:41:48.000000000 +0000 @@ -332,34 +332,6 @@ } /* - * call-seq: (Caution! string literal) - * String.new(str="") => new_str - * - * Returns a new string object containing a copy of str. - */ - -mrb_value -mrb_str_literal(mrb_state *mrb, mrb_value str) -{ - struct RString *s, *orig; - mrb_shared_string *shared; - - s = mrb_obj_alloc_string(mrb); - orig = mrb_str_ptr(str); - if (!(orig->flags & MRB_STR_SHARED)) { - str_make_shared(mrb, orig); - } - shared = orig->aux.shared; - shared->refcnt++; - s->ptr = shared->ptr; - s->len = shared->len; - s->aux.shared = shared; - s->flags |= MRB_STR_SHARED; - - return mrb_obj_value(s); -} - -/* * call-seq: * char* str = String("abcd"), len=strlen("abcd") * @@ -574,10 +546,10 @@ mrb_get_args(mrb, "o", &str2); if (!mrb_string_p(str2)) { - if (!mrb_respond_to(mrb, str2, mrb_intern2(mrb, "to_s", 4))) { + if (!mrb_respond_to(mrb, str2, mrb_intern_lit(mrb, "to_s"))) { return mrb_nil_value(); } - else if (!mrb_respond_to(mrb, str2, mrb_intern2(mrb, "<=>", 3))) { + else if (!mrb_respond_to(mrb, str2, mrb_intern_lit(mrb, "<=>"))) { return mrb_nil_value(); } else { @@ -613,7 +585,7 @@ if (mrb_obj_equal(mrb, str1, str2)) return TRUE; if (!mrb_string_p(str2)) { if (mrb_nil_p(str2)) return FALSE; - if (!mrb_respond_to(mrb, str2, mrb_intern2(mrb, "to_str", 6))) { + if (!mrb_respond_to(mrb, str2, mrb_intern_lit(mrb, "to_str"))) { return FALSE; } str2 = mrb_funcall(mrb, str2, "to_str", 0); diff -Nru mruby-0.0.0~20131107+gitf80401de/src/symbol.c mruby-0.0.0~20131214+git882afdea/src/symbol.c --- mruby-0.0.0~20131107+gitf80401de/src/symbol.c 2013-11-04 15:13:01.000000000 +0000 +++ mruby-0.0.0~20131214+git882afdea/src/symbol.c 2013-12-10 15:41:48.000000000 +0000 @@ -35,7 +35,7 @@ KHASH_DEFINE (n2s, symbol_name, mrb_sym, 1, sym_hash_func, sym_hash_equal) /* ------------------------------------------------------ */ mrb_sym -mrb_intern2(mrb_state *mrb, const char *name, size_t len) +mrb_intern(mrb_state *mrb, const char *name, size_t len) { khash_t(n2s) *h = mrb->name2sym; symbol_name sname; @@ -63,13 +63,13 @@ mrb_sym mrb_intern_cstr(mrb_state *mrb, const char *name) { - return mrb_intern2(mrb, name, strlen(name)); + return mrb_intern(mrb, name, strlen(name)); } mrb_sym mrb_intern_str(mrb_state *mrb, mrb_value str) { - return mrb_intern2(mrb, RSTRING_PTR(str), RSTRING_LEN(str)); + return mrb_intern(mrb, RSTRING_PTR(str), RSTRING_LEN(str)); } mrb_value diff -Nru mruby-0.0.0~20131107+gitf80401de/src/variable.c mruby-0.0.0~20131214+git882afdea/src/variable.c --- mruby-0.0.0~20131107+gitf80401de/src/variable.c 2013-11-04 15:13:01.000000000 +0000 +++ mruby-0.0.0~20131214+git882afdea/src/variable.c 2013-12-10 15:41:48.000000000 +0000 @@ -563,6 +563,7 @@ mrb_value str = *(mrb_value*)p; const char *s; size_t len; + mrb_value ins; /* need not to show internal data */ if (RSTRING_PTR(str)[0] == '-') { /* first element */ @@ -575,7 +576,13 @@ s = mrb_sym2name_len(mrb, sym, &len); mrb_str_cat(mrb, str, s, len); mrb_str_cat(mrb, str, "=", 1); - mrb_str_append(mrb, str, mrb_inspect(mrb, v)); + if (mrb_type(v) == MRB_TT_OBJECT) { + ins = mrb_any_to_s(mrb, v); + } + else { + ins = mrb_inspect(mrb, v); + } + mrb_str_append(mrb, str, ins); return 0; } @@ -884,7 +891,7 @@ goto L_RETRY; } name = mrb_symbol_value(sym); - return mrb_funcall_argv(mrb, mrb_obj_value(base), mrb_intern2(mrb, "const_missing", 13), 1, &name); + return mrb_funcall_argv(mrb, mrb_obj_value(base), mrb_intern_lit(mrb, "const_missing"), 1, &name); } mrb_value @@ -963,7 +970,7 @@ ary = *(mrb_value*)p; s = mrb_sym2name_len(mrb, sym, &len); - if (len > 1 && ISUPPER(s[0])) { + if (len >= 1 && ISUPPER(s[0])) { mrb_ary_push(mrb, ary, mrb_symbol_value(sym)); } return 0; @@ -1064,7 +1071,7 @@ buf[2] = 0; for (i = 1; i <= 9; ++i) { buf[1] = (char)(i + '0'); - mrb_ary_push(mrb, ary, mrb_symbol_value(mrb_intern2(mrb, buf, 2))); + mrb_ary_push(mrb, ary, mrb_symbol_value(mrb_intern_lit(mrb, buf))); } return ary; } @@ -1127,7 +1134,7 @@ { mrb_value name; - name = mrb_obj_iv_get(mrb, (struct RObject*)c, mrb_intern2(mrb, "__classid__", 11)); + name = mrb_obj_iv_get(mrb, (struct RObject*)c, mrb_intern_lit(mrb, "__classid__")); if (mrb_nil_p(name)) { if (!outer) return 0; diff -Nru mruby-0.0.0~20131107+gitf80401de/src/vm.c mruby-0.0.0~20131214+git882afdea/src/vm.c --- mruby-0.0.0~20131107+gitf80401de/src/vm.c 2013-11-04 15:13:01.000000000 +0000 +++ mruby-0.0.0~20131214+git882afdea/src/vm.c 2013-12-10 15:41:48.000000000 +0000 @@ -69,19 +69,23 @@ #define TO_STR(x) TO_STR_(x) #define TO_STR_(x) #x +#define ARENA_RESTORE(mrb,ai) (mrb)->arena_idx = (ai) + static inline void stack_clear(mrb_value *from, size_t count) { +#ifndef MRB_NAN_BOXING const mrb_value mrb_value_zero = { { 0 } }; while (count-- > 0) { -#ifndef MRB_NAN_BOXING *from++ = mrb_value_zero; + } #else + while (count-- > 0) { SET_NIL_VALUE(*from); from++; -#endif } +#endif } static inline void @@ -128,39 +132,39 @@ /** def rec ; $deep =+ 1 ; if $deep > 1000 ; return 0 ; end ; rec ; end */ static void +stack_extend_alloc(mrb_state *mrb, int room) +{ + mrb_value *oldbase = mrb->c->stbase; + int size = mrb->c->stend - mrb->c->stbase; + int off = mrb->c->stack - mrb->c->stbase; + + /* Use linear stack growth. + It is slightly slower than doubling the stack space, + but it saves memory on small devices. */ + if (room <= size) + size += MRB_STACK_GROWTH; + else + size += room; + + mrb->c->stbase = (mrb_value *)mrb_realloc(mrb, mrb->c->stbase, sizeof(mrb_value) * size); + mrb->c->stack = mrb->c->stbase + off; + mrb->c->stend = mrb->c->stbase + size; + envadjust(mrb, oldbase, mrb->c->stbase); + /* Raise an exception if the new stack size will be too large, + to prevent infinite recursion. However, do this only after resizing the stack, so mrb_raise has stack space to work with. */ + if (size > MRB_STACK_MAX) { + mrb_raise(mrb, E_RUNTIME_ERROR, "stack level too deep. (limit=" TO_STR(MRB_STACK_MAX) ")"); + } +} + +static inline void stack_extend(mrb_state *mrb, int room, int keep) { if (mrb->c->stack + room >= mrb->c->stend) { - int size, off; - - mrb_value *oldbase = mrb->c->stbase; - - size = mrb->c->stend - mrb->c->stbase; - off = mrb->c->stack - mrb->c->stbase; - - /* do not leave uninitialized malloc region */ - if (keep > size) keep = size; - - /* Use linear stack growth. - It is slightly slower than doubling thestack space, - but it saves memory on small devices. */ - if (room <= size) - size += MRB_STACK_GROWTH; - else - size += room; - - mrb->c->stbase = (mrb_value *)mrb_realloc(mrb, mrb->c->stbase, sizeof(mrb_value) * size); - mrb->c->stack = mrb->c->stbase + off; - mrb->c->stend = mrb->c->stbase + size; - envadjust(mrb, oldbase, mrb->c->stbase); - /* Raise an exception if the new stack size will be too large, - to prevent infinite recursion. However, do this only after resizing the stack, so mrb_raise has stack space to work with. */ - if (size > MRB_STACK_MAX) { - mrb_raise(mrb, E_RUNTIME_ERROR, "stack level too deep. (limit=" TO_STR(MRB_STACK_MAX) ")"); - } + stack_extend_alloc(mrb, room); } - if (room > keep) { + /* do not leave uninitialized malloc region */ stack_clear(&(mrb->c->stack[keep]), room - keep); } } @@ -355,7 +359,7 @@ p = mrb_method_search_vm(mrb, &c, mid); if (!p) { undef = mid; - mid = mrb_intern2(mrb, "method_missing", 14); + mid = mrb_intern_lit(mrb, "method_missing"); p = mrb_method_search_vm(mrb, &c, mid); n++; argc++; } @@ -488,7 +492,7 @@ msg = mrb_str_buf_new(mrb, sizeof(lead) + 7); mrb_str_buf_cat(mrb, msg, lead, sizeof(lead) - 1); mrb_str_buf_cat(mrb, msg, kind_str[kind], kind_str_len[kind]); - exc = mrb_exc_new3(mrb, E_LOCALJUMP_ERROR, msg); + exc = mrb_exc_new_str(mrb, E_LOCALJUMP_ERROR, msg); mrb->exc = mrb_obj_ptr(exc); } @@ -507,11 +511,12 @@ str = mrb_format(mrb, "wrong number of arguments (%S for %S)", mrb_fixnum_value(mrb->c->ci->argc), mrb_fixnum_value(num)); } - exc = mrb_exc_new3(mrb, E_ARGUMENT_ERROR, str); + exc = mrb_exc_new_str(mrb, E_ARGUMENT_ERROR, str); mrb->exc = mrb_obj_ptr(exc); } -#define ERR_PC_HOOK(mrb, pc) mrb->c->ci->err = pc; +#define ERR_PC_SET(mrb, pc) mrb->c->ci->err = pc; +#define ERR_PC_CLR(mrb) mrb->c->ci->err = 0; #ifdef ENABLE_DEBUG #define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs)); #else @@ -616,7 +621,7 @@ CASE(OP_LOADL) { /* A Bx R(A) := Pool(Bx) */ - regs[GETARG_A(i)] = pool[GETARG_Bx(i)]; + regs[GETARG_A(i)] = pool[GETARG_Bx(i)]; NEXT; } @@ -688,8 +693,9 @@ CASE(OP_GETCV) { /* A B R(A) := ivget(Sym(B)) */ - ERR_PC_HOOK(mrb, pc); + ERR_PC_SET(mrb, pc); regs[GETARG_A(i)] = mrb_vm_cv_get(mrb, syms[GETARG_Bx(i)]); + ERR_PC_CLR(mrb); NEXT; } @@ -703,8 +709,9 @@ /* A B R(A) := constget(Sym(B)) */ mrb_value val; - ERR_PC_HOOK(mrb, pc); + ERR_PC_SET(mrb, pc); val = mrb_vm_const_get(mrb, syms[GETARG_Bx(i)]); + ERR_PC_CLR(mrb); regs = mrb->c->stack; regs[GETARG_A(i)] = val; NEXT; @@ -721,8 +728,9 @@ mrb_value val; int a = GETARG_A(i); - ERR_PC_HOOK(mrb, pc); + ERR_PC_SET(mrb, pc); val = mrb_const_get(mrb, regs[a], syms[GETARG_Bx(i)]); + ERR_PC_CLR(mrb); regs = mrb->c->stack; regs[a] = val; NEXT; @@ -830,7 +838,7 @@ /* Bx ensure_push(SEQ[Bx]) */ struct RProc *p; - p = mrb_closure_new(mrb, mrb->irep[irep->idx+GETARG_Bx(i)]); + p = mrb_closure_new(mrb, irep->reps[GETARG_Bx(i)]); /* push ensure_stack */ if (mrb->c->esize <= mrb->c->ci->eidx) { if (mrb->c->esize == 0) mrb->c->esize = 16; @@ -838,7 +846,7 @@ mrb->c->ensure = (struct RProc **)mrb_realloc(mrb, mrb->c->ensure, sizeof(struct RProc*) * mrb->c->esize); } mrb->c->ensure[mrb->c->ci->eidx++] = p; - mrb_gc_arena_restore(mrb, ai); + ARENA_RESTORE(mrb, ai); NEXT; } @@ -850,7 +858,7 @@ for (n=0; nc->ci->eidx); } - mrb_gc_arena_restore(mrb, ai); + ARENA_RESTORE(mrb, ai); NEXT; } @@ -891,7 +899,7 @@ if (!m) { mrb_value sym = mrb_symbol_value(mid); - mid = mrb_intern2(mrb, "method_missing", 14); + mid = mrb_intern_lit(mrb, "method_missing"); m = mrb_method_search_vm(mrb, &c, mid); if (n == CALL_MAXARGS) { mrb_ary_unshift(mrb, regs[a+1], sym); @@ -1048,7 +1056,7 @@ c = mrb->c->ci->target_class->super; m = mrb_method_search_vm(mrb, &c, mid); if (!m) { - mid = mrb_intern2(mrb, "method_missing", 14); + mid = mrb_intern_lit(mrb, "method_missing"); m = mrb_method_search_vm(mrb, &c, mid); if (n == CALL_MAXARGS) { mrb_ary_unshift(mrb, regs[a+1], mrb_symbol_value(ci->mid)); @@ -1156,7 +1164,7 @@ rest->len = m1+len+m2; } regs[a+1] = stack[m1+r+m2]; - mrb_gc_arena_restore(mrb, ai); + ARENA_RESTORE(mrb, ai); NEXT; } @@ -1261,8 +1269,8 @@ L_RAISE: ci = mrb->c->ci; - mrb_obj_iv_ifnone(mrb, mrb->exc, mrb_intern2(mrb, "lastpc", 6), mrb_cptr_value(mrb, pc)); - mrb_obj_iv_ifnone(mrb, mrb->exc, mrb_intern2(mrb, "ciidx", 5), mrb_fixnum_value(ci - mrb->c->cibase)); + mrb_obj_iv_ifnone(mrb, mrb->exc, mrb_intern_lit(mrb, "lastpc"), mrb_cptr_value(mrb, pc)); + mrb_obj_iv_ifnone(mrb, mrb->exc, mrb_intern_lit(mrb, "ciidx"), mrb_fixnum_value(ci - mrb->c->cibase)); eidx = ci->eidx; if (ci == mrb->c->cibase) { if (ci->ridx == 0) goto L_STOP; @@ -1279,7 +1287,7 @@ mrb->jmp = prev_jmp; mrb_longjmp(mrb); } - while (eidx > ci->eidx) { + while (eidx > ci[-1].eidx) { ecall(mrb, --eidx); } if (ci == mrb->c->cibase) { @@ -1327,7 +1335,7 @@ goto L_RAISE; } if (mrb->c->prev->ci == mrb->c->prev->cibase) { - mrb_value exc = mrb_exc_new3(mrb, E_RUNTIME_ERROR, mrb_str_new(mrb, "double resume", 13)); + mrb_value exc = mrb_exc_new_str(mrb, E_RUNTIME_ERROR, mrb_str_new(mrb, "double resume", 13)); mrb->exc = mrb_obj_ptr(exc); goto L_RAISE; } @@ -1387,7 +1395,7 @@ if (!m) { mrb_value sym = mrb_symbol_value(mid); - mid = mrb_intern2(mrb, "method_missing", 14); + mid = mrb_intern_lit(mrb, "method_missing"); m = mrb_method_search_vm(mrb, &c, mid); if (n == CALL_MAXARGS) { mrb_ary_unshift(mrb, regs[a+1], sym); @@ -1531,7 +1539,7 @@ default: goto L_SEND; } - mrb_gc_arena_restore(mrb, ai); + ARENA_RESTORE(mrb, ai); NEXT; } @@ -1848,7 +1856,7 @@ CASE(OP_ARRAY) { /* A B C R(A) := ary_new(R(B),R(B+1)..R(B+C)) */ regs[GETARG_A(i)] = mrb_ary_new_from_values(mrb, GETARG_C(i), ®s[GETARG_B(i)]); - mrb_gc_arena_restore(mrb, ai); + ARENA_RESTORE(mrb, ai); NEXT; } @@ -1856,7 +1864,7 @@ /* A B mrb_ary_concat(R(A),R(B)) */ mrb_ary_concat(mrb, regs[GETARG_A(i)], mrb_ary_splat(mrb, regs[GETARG_B(i)])); - mrb_gc_arena_restore(mrb, ai); + ARENA_RESTORE(mrb, ai); NEXT; } @@ -1928,14 +1936,14 @@ } } } - mrb_gc_arena_restore(mrb, ai); + ARENA_RESTORE(mrb, ai); NEXT; } CASE(OP_STRING) { /* A Bx R(A) := str_new(Lit(Bx)) */ - regs[GETARG_A(i)] = mrb_str_literal(mrb, pool[GETARG_Bx(i)]); - mrb_gc_arena_restore(mrb, ai); + regs[GETARG_A(i)] = mrb_str_dup(mrb, pool[GETARG_Bx(i)]); + ARENA_RESTORE(mrb, ai); NEXT; } @@ -1957,7 +1965,7 @@ b+=2; } regs[GETARG_A(i)] = hash; - mrb_gc_arena_restore(mrb, ai); + ARENA_RESTORE(mrb, ai); NEXT; } @@ -1967,14 +1975,14 @@ int c = GETARG_c(i); if (c & OP_L_CAPTURE) { - p = mrb_closure_new(mrb, mrb->irep[irep->idx+GETARG_b(i)]); + p = mrb_closure_new(mrb, irep->reps[GETARG_b(i)]); } else { - p = mrb_proc_new(mrb, mrb->irep[irep->idx+GETARG_b(i)]); + p = mrb_proc_new(mrb, irep->reps[GETARG_b(i)]); } if (c & OP_L_STRICT) p->flags |= MRB_PROC_STRICT; regs[GETARG_A(i)] = mrb_obj_value(p); - mrb_gc_arena_restore(mrb, ai); + ARENA_RESTORE(mrb, ai); NEXT; } @@ -1998,7 +2006,7 @@ } c = mrb_vm_define_class(mrb, base, super, id); regs[a] = mrb_obj_value(c); - mrb_gc_arena_restore(mrb, ai); + ARENA_RESTORE(mrb, ai); NEXT; } @@ -2015,7 +2023,7 @@ } c = mrb_vm_define_module(mrb, base, id); regs[a] = mrb_obj_value(c); - mrb_gc_arena_restore(mrb, ai); + ARENA_RESTORE(mrb, ai); NEXT; } @@ -2038,7 +2046,7 @@ /* prepare stack */ mrb->c->stack += a; - p = mrb_proc_new(mrb, mrb->irep[irep->idx+GETARG_Bx(i)]); + p = mrb_proc_new(mrb, irep->reps[GETARG_Bx(i)]); p->target_class = ci->target_class; ci->proc = p; @@ -2069,14 +2077,14 @@ struct RClass *c = mrb_class_ptr(regs[a]); mrb_define_method_vm(mrb, c, syms[GETARG_B(i)], regs[a+1]); - mrb_gc_arena_restore(mrb, ai); + ARENA_RESTORE(mrb, ai); NEXT; } CASE(OP_SCLASS) { /* A B R(A) := R(B).singleton_class */ regs[GETARG_A(i)] = mrb_singleton_class(mrb, regs[GETARG_B(i)]); - mrb_gc_arena_restore(mrb, ai); + ARENA_RESTORE(mrb, ai); NEXT; } @@ -2096,7 +2104,7 @@ /* A B C R(A) := range_new(R(B),R(B+1),C) */ int b = GETARG_B(i); regs[GETARG_A(i)] = mrb_range_new(mrb, regs[b], regs[b+1], GETARG_C(i)); - mrb_gc_arena_restore(mrb, ai); + ARENA_RESTORE(mrb, ai); NEXT; } @@ -2120,6 +2128,7 @@ ecall(mrb, n); } } + mrb->c->ci->err = 0; mrb->jmp = prev_jmp; if (mrb->exc) { return mrb_obj_value(mrb->exc); @@ -2129,14 +2138,14 @@ CASE(OP_ERR) { /* Bx raise RuntimeError with message Lit(Bx) */ - mrb_value msg = pool[GETARG_Bx(i)]; + mrb_value msg = mrb_str_dup(mrb, pool[GETARG_Bx(i)]); mrb_value exc; if (GETARG_A(i) == 0) { - exc = mrb_exc_new3(mrb, E_RUNTIME_ERROR, msg); + exc = mrb_exc_new_str(mrb, E_RUNTIME_ERROR, msg); } else { - exc = mrb_exc_new3(mrb, E_LOCALJUMP_ERROR, msg); + exc = mrb_exc_new_str(mrb, E_LOCALJUMP_ERROR, msg); } mrb->exc = mrb_obj_ptr(exc); goto L_RAISE; diff -Nru mruby-0.0.0~20131107+gitf80401de/tasks/mruby_build.rake mruby-0.0.0~20131214+git882afdea/tasks/mruby_build.rake --- mruby-0.0.0~20131107+gitf80401de/tasks/mruby_build.rake 2013-11-04 15:13:01.000000000 +0000 +++ mruby-0.0.0~20131214+git882afdea/tasks/mruby_build.rake 2013-12-10 15:41:48.000000000 +0000 @@ -87,6 +87,11 @@ MRuby.targets[@name].instance_eval(&block) end + def enable_debug + compilers.each { |c| c.defines += %w(MRB_DEBUG) } + @mrbc.compile_options += ' -g' + end + def toolchain(name) tc = Toolchain.toolchains[name.to_s] fail "Unknown #{name} toolchain" unless tc @@ -98,7 +103,7 @@ end def mrbcfile - MRuby.targets['host'].exefile("#{MRuby.targets['host'].build_dir}/bin/mrbc") + MRuby.targets[@name].exefile("#{MRuby.targets[@name].build_dir}/bin/mrbc") end def compilers @@ -199,6 +204,10 @@ super end + def mrbcfile + MRuby.targets['host'].exefile("#{MRuby.targets['host'].build_dir}/bin/mrbc") + end + def run_test mrbtest = exefile("#{build_dir}/test/mrbtest") if (@test_runner.command == nil) diff -Nru mruby-0.0.0~20131107+gitf80401de/tasks/toolchains/gcc.rake mruby-0.0.0~20131214+git882afdea/tasks/toolchains/gcc.rake --- mruby-0.0.0~20131107+gitf80401de/tasks/toolchains/gcc.rake 2013-11-04 15:13:01.000000000 +0000 +++ mruby-0.0.0~20131214+git882afdea/tasks/toolchains/gcc.rake 2013-12-10 15:41:48.000000000 +0000 @@ -1,7 +1,7 @@ MRuby::Toolchain.new(:gcc) do |conf| - [conf.cc, conf.cxx, conf.objc, conf.asm].each do |cc| + [conf.cc, conf.objc, conf.asm].each do |cc| cc.command = ENV['CC'] || 'gcc' - cc.flags = [ENV['CFLAGS'] || %w(-g -O3 -Wall -Werror-implicit-function-declaration)] + cc.flags = [ENV['CFLAGS'] || %w(-g -std=gnu99 -O3 -Wall -Werror-implicit-function-declaration)] cc.include_paths = ["#{MRUBY_ROOT}/include"] cc.defines = %w(DISABLE_GEMS) cc.option_include_path = '-I%s' @@ -9,6 +9,16 @@ cc.compile_options = '%{flags} -MMD -o %{outfile} -c %{infile}' end + [conf.cxx].each do |cxx| + cxx.command = ENV['CXX'] || 'g++' + cxx.flags = [ENV['CXXFLAGS'] || ENV['CFLAGS'] || %w(-g -O3 -Wall -Werror-implicit-function-declaration)] + cxx.include_paths = ["#{MRUBY_ROOT}/include"] + cxx.defines = %w(DISABLE_GEMS) + cxx.option_include_path = '-I%s' + cxx.option_define = '-D%s' + cxx.compile_options = '%{flags} -MMD -o %{outfile} -c %{infile}' + end + conf.linker do |linker| linker.command = ENV['LD'] || 'gcc' linker.flags = [ENV['LDFLAGS'] || %w()] diff -Nru mruby-0.0.0~20131107+gitf80401de/tasks/toolchains/visualcpp.rake mruby-0.0.0~20131214+git882afdea/tasks/toolchains/visualcpp.rake --- mruby-0.0.0~20131107+gitf80401de/tasks/toolchains/visualcpp.rake 1970-01-01 00:00:00.000000000 +0000 +++ mruby-0.0.0~20131214+git882afdea/tasks/toolchains/visualcpp.rake 2013-12-10 15:41:48.000000000 +0000 @@ -0,0 +1,44 @@ +MRuby::Toolchain.new(:visualcpp) do |conf| + [conf.cc, conf.cxx].each do |cc| + cc.command = ENV['CC'] || 'cl.exe' + cc.flags = [ENV['CFLAGS'] || %w(/c /nologo /W3 /D_DEBUG /MDd /Zi /Od /RTC1 /DHAVE_STRING_H /DNO_GETTIMEOFDAY /D_CRT_SECURE_NO_WARNINGS)] + cc.include_paths = ["#{MRUBY_ROOT}/include"] + cc.defines = %w(DISABLE_GEMS) + cc.option_include_path = '/I%s' + cc.option_define = '/D%s' + cc.compile_options = "%{flags} /Fo%{outfile} %{infile}" + end + + conf.linker do |linker| + linker.command = ENV['LD'] || 'link.exe' + linker.flags = [ENV['LDFLAGS'] || %w(/nologo)] + linker.libraries = %w() + linker.library_paths = %w() + linker.option_library = '%s.lib' + linker.option_library_path = '/LIBPATH:%s' + linker.link_options = "%{flags} /OUT:%{outfile} %{objs} %{flags_before_libraries} %{libs} %{flags_after_libraries}" + end + + conf.archiver do |archiver| + archiver.command = ENV['AR'] || 'lib.exe' + archiver.archive_options = '/nologo /OUT:%{outfile} %{objs}' + end + + conf.yacc do |yacc| + yacc.command = ENV['YACC'] || 'bison.exe' + yacc.compile_options = '-o %{outfile} %{infile}' + end + + conf.gperf do |gperf| + gperf.command = 'gperf.exe' + gperf.compile_options = '-L ANSI-C -C -p -j1 -i 1 -g -o -t -N mrb_reserved_word -k"1,3,$" %{infile} > %{outfile}' + end + + conf.exts do |exts| + exts.object = '.obj' + exts.executable = '.exe' + exts.library = '.lib' + end + + conf.file_separator = '\\' +end diff -Nru mruby-0.0.0~20131107+gitf80401de/tasks/toolchains/vs2010.rake mruby-0.0.0~20131214+git882afdea/tasks/toolchains/vs2010.rake --- mruby-0.0.0~20131107+gitf80401de/tasks/toolchains/vs2010.rake 2013-11-04 15:13:01.000000000 +0000 +++ mruby-0.0.0~20131214+git882afdea/tasks/toolchains/vs2010.rake 1970-01-01 00:00:00.000000000 +0000 @@ -1,3 +0,0 @@ -MRuby::Toolchain.new(:vs2010) do |conf| - toolchain :vs2012 -end diff -Nru mruby-0.0.0~20131107+gitf80401de/tasks/toolchains/vs2012.rake mruby-0.0.0~20131214+git882afdea/tasks/toolchains/vs2012.rake --- mruby-0.0.0~20131107+gitf80401de/tasks/toolchains/vs2012.rake 2013-11-04 15:13:01.000000000 +0000 +++ mruby-0.0.0~20131214+git882afdea/tasks/toolchains/vs2012.rake 1970-01-01 00:00:00.000000000 +0000 @@ -1,44 +0,0 @@ -MRuby::Toolchain.new(:vs2012) do |conf| - [conf.cc, conf.cxx].each do |cc| - cc.command = ENV['CC'] || 'cl.exe' - cc.flags = [ENV['CFLAGS'] || %w(/c /nologo /W3 /D_DEBUG /MDd /Zi /Od /RTC1 /DHAVE_STRING_H /DNO_GETTIMEOFDAY /D_CRT_SECURE_NO_WARNINGS)] - cc.include_paths = ["#{MRUBY_ROOT}/include"] - cc.defines = %w(DISABLE_GEMS) - cc.option_include_path = '/I%s' - cc.option_define = '/D%s' - cc.compile_options = "%{flags} /Fo%{outfile} %{infile}" - end - - conf.linker do |linker| - linker.command = ENV['LD'] || 'link.exe' - linker.flags = [ENV['LDFLAGS'] || %w(/nologo)] - linker.libraries = %w() - linker.library_paths = %w() - linker.option_library = '%s.lib' - linker.option_library_path = '/LIBPATH:%s' - linker.link_options = "%{flags} /OUT:%{outfile} %{objs} %{flags_before_libraries} %{libs} %{flags_after_libraries}" - end - - conf.archiver do |archiver| - archiver.command = ENV['AR'] || 'lib.exe' - archiver.archive_options = '/nologo /OUT:%{outfile} %{objs}' - end - - conf.yacc do |yacc| - yacc.command = ENV['YACC'] || 'bison.exe' - yacc.compile_options = '-o %{outfile} %{infile}' - end - - conf.gperf do |gperf| - gperf.command = 'gperf.exe' - gperf.compile_options = '-L ANSI-C -C -p -j1 -i 1 -g -o -t -N mrb_reserved_word -k"1,3,$" %{infile} > %{outfile}' - end - - conf.exts do |exts| - exts.object = '.obj' - exts.executable = '.exe' - exts.library = '.lib' - end - - conf.file_separator = '\\' -end diff -Nru mruby-0.0.0~20131107+gitf80401de/test/driver.c mruby-0.0.0~20131214+git882afdea/test/driver.c --- mruby-0.0.0~20131107+gitf80401de/test/driver.c 2013-11-04 15:13:01.000000000 +0000 +++ mruby-0.0.0~20131214+git882afdea/test/driver.c 2013-12-10 15:41:48.000000000 +0000 @@ -34,8 +34,8 @@ { /* Error check */ /* $ko_test and $kill_test should be 0 */ - mrb_value ko_test = mrb_gv_get(mrb, mrb_intern2(mrb, "$ko_test", 8)); - mrb_value kill_test = mrb_gv_get(mrb, mrb_intern2(mrb, "$kill_test", 10)); + mrb_value ko_test = mrb_gv_get(mrb, mrb_intern(mrb, "$ko_test", 8)); + mrb_value kill_test = mrb_gv_get(mrb, mrb_intern(mrb, "$kill_test", 10)); return mrb_fixnum_p(ko_test) && mrb_fixnum(ko_test) == 0 && mrb_fixnum_p(kill_test) && mrb_fixnum(kill_test) == 0; } @@ -104,7 +104,7 @@ if (argc == 2 && argv[1][0] == '-' && argv[1][1] == 'v') { printf("verbose mode: enable\n\n"); - mrb_gv_set(mrb, mrb_intern2(mrb, "$mrbtest_verbose", 16), mrb_true_value()); + mrb_gv_set(mrb, mrb_intern(mrb, "$mrbtest_verbose", 16), mrb_true_value()); } krn = mrb->kernel_module; diff -Nru mruby-0.0.0~20131107+gitf80401de/test/t/array.rb mruby-0.0.0~20131214+git882afdea/test/t/array.rb --- mruby-0.0.0~20131107+gitf80401de/test/t/array.rb 2013-11-04 15:13:01.000000000 +0000 +++ mruby-0.0.0~20131214+git882afdea/test/t/array.rb 2013-12-10 15:41:48.000000000 +0000 @@ -17,7 +17,11 @@ assert_equal([1, 2, 3], Array.[](1,2,3)) end -assert('Array#*', '15.2.12.5.1') do +assert('Array#+', '15.2.12.5.1') do + assert_equal([1, 1], [1].+([1])) +end + +assert('Array#*', '15.2.12.5.2') do assert_raise(ArgumentError) do # this will cause an exception due to the wrong argument [1].*(-1) @@ -26,10 +30,6 @@ assert_equal([], [1].*(0)) end -assert('Array#+', '15.2.12.5.2') do - assert_equal([1, 1], [1].+([1])) -end - assert('Array#<<', '15.2.12.5.3') do assert_equal([1, 1], [1].<<(1)) end diff -Nru mruby-0.0.0~20131107+gitf80401de/test/t/kernel.rb mruby-0.0.0~20131214+git882afdea/test/t/kernel.rb --- mruby-0.0.0~20131107+gitf80401de/test/t/kernel.rb 2013-11-04 15:13:01.000000000 +0000 +++ mruby-0.0.0~20131214+git882afdea/test/t/kernel.rb 2013-12-10 15:41:48.000000000 +0000 @@ -281,6 +281,10 @@ assert('Kernel#is_a?', '15.3.1.3.24') do assert_true is_a?(Kernel) assert_false is_a?(Array) + + assert_raise TypeError do + 42.is_a?(42) + end end assert('Kernel#iterator?', '15.3.1.3.25') do diff -Nru mruby-0.0.0~20131107+gitf80401de/test/t/module.rb mruby-0.0.0~20131214+git882afdea/test/t/module.rb --- mruby-0.0.0~20131107+gitf80401de/test/t/module.rb 2013-11-04 15:13:01.000000000 +0000 +++ mruby-0.0.0~20131214+git882afdea/test/t/module.rb 2013-12-10 15:41:48.000000000 +0000 @@ -276,16 +276,16 @@ assert('Module.constants', '15.2.2.4.24') do $n = [] module TestA - Const = 1 + C = 1 end class TestB include TestA - Const2 = 1 + C2 = 1 $n = constants.sort end - assert_equal [ :Const ], TestA.constants - assert_equal [ :Const, :Const2 ], $n + assert_equal [ :C ], TestA.constants + assert_equal [ :C, :C2 ], $n end assert('Module#include', '15.2.2.4.27') do diff -Nru mruby-0.0.0~20131107+gitf80401de/tools/mrbc/mrbc.c mruby-0.0.0~20131214+git882afdea/tools/mrbc/mrbc.c --- mruby-0.0.0~20131107+gitf80401de/tools/mrbc/mrbc.c 2013-11-04 15:13:01.000000000 +0000 +++ mruby-0.0.0~20131214+git882afdea/tools/mrbc/mrbc.c 2013-12-10 15:41:48.000000000 +0000 @@ -11,8 +11,6 @@ void mrb_show_version(mrb_state *); void mrb_show_copyright(mrb_state *); -void parser_dump(mrb_state*, struct mrb_ast_node*, int); -void codedump_all(mrb_state*, int); struct mrbc_args { int argc; @@ -181,13 +179,14 @@ return 0; } -static int +static mrb_value load_file(mrb_state *mrb, struct mrbc_args *args) { mrbc_context *c; mrb_value result; char *input = args->argv[args->idx]; FILE *infile; + int need_close = FALSE; c = mrbc_context_new(mrb); if (args->verbose) @@ -196,38 +195,43 @@ if (input[0] == '-' && input[1] == '\0') { infile = stdin; } - else if ((infile = fopen(input, "r")) == NULL) { - fprintf(stderr, "%s: cannot open program file. (%s)\n", args->prog, input); - return EXIT_FAILURE; + else { + need_close = TRUE; + if ((infile = fopen(input, "r")) == NULL) { + fprintf(stderr, "%s: cannot open program file. (%s)\n", args->prog, input); + return mrb_nil_value(); + } } mrbc_filename(mrb, c, input); args->idx++; if (args->idx < args->argc) { + need_close = FALSE; mrbc_partial_hook(mrb, c, partial_hook, (void*)args); } result = mrb_load_file_cxt(mrb, infile, c); - if (mrb_undef_p(result) || mrb_fixnum(result) < 0) { - mrbc_context_free(mrb, c); - return EXIT_FAILURE; - } + if (need_close) fclose(infile); mrbc_context_free(mrb, c); - return EXIT_SUCCESS; + if (mrb_undef_p(result)) { + return mrb_nil_value(); + } + return result; } static int -dump_file(mrb_state *mrb, FILE *wfp, const char *outfile, struct mrbc_args *args) +dump_file(mrb_state *mrb, FILE *wfp, const char *outfile, struct RProc *proc, struct mrbc_args *args) { int n = MRB_DUMP_OK; + mrb_irep *irep = proc->body.irep; if (args->initname) { - n = mrb_dump_irep_cfunc(mrb, 0, args->debug_info, wfp, args->initname); + n = mrb_dump_irep_cfunc(mrb, irep, args->debug_info, wfp, args->initname); if (n == MRB_DUMP_INVALID_ARGUMENT) { fprintf(stderr, "%s: invalid C language symbol name\n", args->initname); } } else { - n = mrb_dump_irep_binary(mrb, 0, args->debug_info, wfp); + n = mrb_dump_irep_binary(mrb, irep, args->debug_info, wfp); } if (n != MRB_DUMP_OK) { fprintf(stderr, "%s: error in mrb dump (%s) %d\n", args->prog, outfile, n); @@ -242,6 +246,7 @@ int n, result; struct mrbc_args args; FILE *wfp; + mrb_value load; if (mrb == NULL) { fputs("Invalid mrb_state, exiting mrbc\n", stderr); @@ -269,7 +274,8 @@ } args.idx = n; - if (load_file(mrb, &args) == EXIT_FAILURE) { + load = load_file(mrb, &args); + if (mrb_nil_p(load)) { cleanup(mrb, &args); return EXIT_FAILURE; } @@ -295,7 +301,7 @@ fprintf(stderr, "Output file is required\n"); return EXIT_FAILURE; } - result = dump_file(mrb, wfp, args.outfile, &args); + result = dump_file(mrb, wfp, args.outfile, mrb_proc_ptr(load), &args); fclose(wfp); cleanup(mrb, &args); if (result != MRB_DUMP_OK) { diff -Nru mruby-0.0.0~20131107+gitf80401de/travis_config.rb mruby-0.0.0~20131214+git882afdea/travis_config.rb --- mruby-0.0.0~20131107+gitf80401de/travis_config.rb 2013-11-04 15:13:01.000000000 +0000 +++ mruby-0.0.0~20131214+git882afdea/travis_config.rb 2013-12-10 15:41:48.000000000 +0000 @@ -1,7 +1,16 @@ +MRuby::Build.new('debug') do |conf| + toolchain :gcc + enable_debug + + # include all core GEMs + conf.gembox 'full-core' + conf.cc.defines += %w(MRB_GC_FIXED_ARENA) +end + MRuby::Build.new do |conf| toolchain :gcc # include all core GEMs conf.gembox 'full-core' - conf.cc.defines = %w(MRB_DEBUG) + conf.cc.defines += %w(MRB_GC_FIXED_ARENA) end