From d085ac228e089e72e8bf583ba4b7affa9a027080 Mon Sep 17 00:00:00 2001 From: Masaki Muranaka Date: Sat, 29 Sep 2012 17:00:32 +0900 Subject: mrb_long2int(n) : Remove as unused. defines.h : Remove as already commented out. --- src/struct.c | 3 --- 1 file changed, 3 deletions(-) diff --git a/src/struct.c b/src/struct.c index a5ffe6453..a1ad2e1c0 100644 --- a/src/struct.c +++ b/src/struct.c @@ -11,7 +11,6 @@ #include "mruby/struct.h" #include "mruby/array.h" #include -//#include "defines.h" #ifdef ENABLE_REGEXP #include "encoding.h" @@ -20,8 +19,6 @@ #include "mruby/string.h" #include "mruby/class.h" #include "mruby/variable.h" -//#include "defines.h" -#define mrb_long2int(n) ((int)(n)) static struct RClass * -- cgit v1.2.3 From cd58b12d847ad14e2471dbcf38bec7341a2d9da2 Mon Sep 17 00:00:00 2001 From: Masaki Muranaka Date: Sat, 29 Sep 2012 17:02:36 +0900 Subject: Remove extern mrb_top_self. It is declared in mruby.h. --- mrblib/init_mrblib.c | 1 - 1 file changed, 1 deletion(-) diff --git a/mrblib/init_mrblib.c b/mrblib/init_mrblib.c index a845489f5..72355e3eb 100644 --- a/mrblib/init_mrblib.c +++ b/mrblib/init_mrblib.c @@ -11,7 +11,6 @@ mrb_init_mrblib(mrb_state *mrb) { int n = mrb_read_irep(mrb, mrblib_irep); - extern mrb_value mrb_top_self(mrb_state *mrb); mrb_run(mrb, mrb_proc_new(mrb, mrb->irep[n]), mrb_top_self(mrb)); } -- cgit v1.2.3 From af8f039b90bc34a0d6d7d0b0fbd6f2e8fe3d183b Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Sun, 30 Sep 2012 08:41:36 +0900 Subject: mruby should exit with 0 on success --- tools/mruby/mruby.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tools/mruby/mruby.c b/tools/mruby/mruby.c index 444170270..c36e76066 100644 --- a/tools/mruby/mruby.c +++ b/tools/mruby/mruby.c @@ -215,6 +215,7 @@ main(int argc, char **argv) if (!mrb_undef_p(v)) { p(mrb, mrb_obj_value(mrb->exc)); } + n = -1; } else if (args.check_syntax) { printf("Syntax OK\n"); @@ -222,5 +223,5 @@ main(int argc, char **argv) } cleanup(mrb, &args); - return n > 0 ? 0 : 1; + return n == 0 ? EXIT_SUCCESS : EXIT_FAILURE; } -- cgit v1.2.3 From a3d7960a444cdb532eaaff359dbdabc3e9c93fe1 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Sun, 30 Sep 2012 08:42:10 +0900 Subject: wrong termination of mrb_run on exception; close #480 --- src/vm.c | 4 ---- 1 file changed, 4 deletions(-) diff --git a/src/vm.c b/src/vm.c index ce77f5b05..924520340 100644 --- a/src/vm.c +++ b/src/vm.c @@ -1103,10 +1103,6 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self) while (ci[0].ridx == ci[-1].ridx) { cipop(mrb); ci = mrb->ci; - if (ci->acc < 0) { - mrb->jmp = prev_jmp; - longjmp(*(jmp_buf*)mrb->jmp, 1); - } while (eidx > mrb->ci->eidx) { ecall(mrb, --eidx); } -- cgit v1.2.3 From 5c2afd239c527be5d4117dfaea14902450937ac3 Mon Sep 17 00:00:00 2001 From: Akira Kuroda Date: Sun, 30 Sep 2012 17:25:50 +0900 Subject: add test case for Array#unshift, <=>, and * --- test/t/array.rb | 19 ++++++++++++++++--- 1 file changed, 16 insertions(+), 3 deletions(-) diff --git a/test/t/array.rb b/test/t/array.rb index cb99cea6a..560faf8e7 100644 --- a/test/t/array.rb +++ b/test/t/array.rb @@ -14,7 +14,17 @@ assert('Array.[]', '15.2.12.4.1') do end assert('Array#*', '15.2.12.5.1') do - [1].*(3) == [1, 1, 1] + e2 = nil + begin + # this will cause an exception due to the wrong argument + [1].*(-1) + rescue => e1 + e2 = e1 + end + a = [1].*(3) + b = [1].*(0) + a == [1, 1, 1] and b == [] and + e2.class == ArgumentError end assert('Array#+', '15.2.12.5.2') do @@ -256,8 +266,10 @@ end assert('Array#unshift', '15.2.12.5.30') do a = [2,3] b = a.unshift(1) + c = [2,3] + d = c.unshift(0, 1) - a == [1,2,3] and b == [1,2,3] + a == [1,2,3] and b == [1,2,3] and c == [0,1,2,3] and d == [0,1,2,3] end assert('Array#to_s', '15.2.12.5.31') do @@ -279,8 +291,9 @@ end assert('Array#<=>', '15.2.12.5.36') do r1 = [ "a", "a", "c" ] <=> [ "a", "b", "c" ] #=> -1 r2 = [ 1, 2, 3, 4, 5, 6 ] <=> [ 1, 2 ] #=> +1 + r3 = [ "a", "b", "c" ] <=> [ "a", "b", "c" ] #=> 0 - r1 == -1 and r2 == +1 + r1 == -1 and r2 == +1 and r3 == 0 end # Not ISO specified -- cgit v1.2.3 From 3a6b6518d66ff0acf11a8163404eb4e9c7bbcf1b Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Thu, 4 Oct 2012 11:30:28 +0900 Subject: should handle exception from Ruby implemented method called from funcall; close #484 --- src/vm.c | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/src/vm.c b/src/vm.c index 924520340..7bf3af9d4 100644 --- a/src/vm.c +++ b/src/vm.c @@ -455,7 +455,6 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self) int ai = mrb->arena_idx; jmp_buf *prev_jmp = (jmp_buf *)mrb->jmp; jmp_buf c_jmp; - ptrdiff_t ciidx = mrb->ci - mrb->cibase; #ifdef DIRECT_THREADED static void *optable[] = { @@ -1096,13 +1095,13 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self) ci = mrb->ci; eidx = mrb->ci->eidx; if (ci == mrb->cibase) goto L_STOP; - if (ciidx == ci - mrb->cibase){ - mrb->jmp = prev_jmp; - longjmp(*(jmp_buf*)mrb->jmp, 1); - } while (ci[0].ridx == ci[-1].ridx) { cipop(mrb); ci = mrb->ci; + if (ci[1].acc < 0 && prev_jmp) { + mrb->jmp = prev_jmp; + longjmp(*(jmp_buf*)mrb->jmp, 1); + } while (eidx > mrb->ci->eidx) { ecall(mrb, --eidx); } -- cgit v1.2.3 From 2830624410855384029770da5d42af9995a327a6 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Thu, 4 Oct 2012 14:20:33 +0900 Subject: fix indent of mrb_exc_raise --- src/error.c | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/error.c b/src/error.c index 1f352c853..5570d35f9 100644 --- a/src/error.c +++ b/src/error.c @@ -208,12 +208,12 @@ exc_debug_info(mrb_state *mrb, struct RObject *exc) void mrb_exc_raise(mrb_state *mrb, mrb_value exc) { - mrb->exc = (struct RObject*)mrb_object(exc); - exc_debug_info(mrb, mrb->exc); - if (!mrb->jmp) { - abort(); - } - longjmp(*(jmp_buf*)mrb->jmp, 1); + mrb->exc = (struct RObject*)mrb_object(exc); + exc_debug_info(mrb, mrb->exc); + if (!mrb->jmp) { + abort(); + } + longjmp(*(jmp_buf*)mrb->jmp, 1); } void -- cgit v1.2.3 From 0d9b91083b93ec0abd10031dcb5bb892551d5c66 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Thu, 4 Oct 2012 14:39:44 +0900 Subject: specify know capacity of an array --- tools/mruby/mruby.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/mruby/mruby.c b/tools/mruby/mruby.c index c36e76066..a45d86526 100644 --- a/tools/mruby/mruby.c +++ b/tools/mruby/mruby.c @@ -176,7 +176,7 @@ main(int argc, char **argv) return n; } - ARGV = mrb_ary_new(mrb); + ARGV = mrb_ary_new_capa(mrb, args.argc); for (i = 0; i < args.argc; i++) { mrb_ary_push(mrb, ARGV, mrb_str_new(mrb, args.argv[i], strlen(args.argv[i]))); } -- cgit v1.2.3 From 70916d030cc6f29e34fe3c07afddc07c7fa7c29b Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Thu, 4 Oct 2012 14:56:24 +0900 Subject: script file name should not be in ARGV --- tools/mruby/mruby.c | 22 ++++++++++++++-------- 1 file changed, 14 insertions(+), 8 deletions(-) diff --git a/tools/mruby/mruby.c b/tools/mruby/mruby.c index a45d86526..2ab9e845c 100644 --- a/tools/mruby/mruby.c +++ b/tools/mruby/mruby.c @@ -25,6 +25,7 @@ void mrb_show_copyright(mrb_state *); struct _args { FILE *rfp; char* cmdline; + int fname : 1; int mrbfile : 1; int check_syntax : 1; int verbose : 1; @@ -131,9 +132,14 @@ append_cmdline: if (args->rfp == NULL && args->cmdline == NULL) { if (*argv == NULL) args->rfp = stdin; - else if ((args->rfp = fopen(*argv, args->mrbfile ? "rb" : "r")) == NULL) { - printf("%s: Cannot open program file. (%s)\n", *origargv, *argv); - return 0; + else { + args->rfp = fopen(argv[0], args->mrbfile ? "rb" : "r"); + if (args->rfp == NULL) { + printf("%s: Cannot open program file. (%s)\n", *origargv, *argv); + return 0; + } + args->fname = 1; + argc--; argv++; } } args->argv = (char **)mrb_realloc(mrb, args->argv, sizeof(char*) * (argc + 1)); @@ -202,13 +208,13 @@ main(int argc, char **argv) if (args.check_syntax) c->no_exec = 1; - if (args.cmdline) { - mrbc_filename(mrb, c, "-e"); - v = mrb_load_string_cxt(mrb, (char*)args.cmdline, c); + if (args.rfp) { + mrbc_filename(mrb, c, args.cmdline ? args.cmdline : "-"); + v = mrb_load_file_cxt(mrb, args.rfp, c); } else { - mrbc_filename(mrb, c, args.argv[0]); - v = mrb_load_file_cxt(mrb, args.rfp, c); + mrbc_filename(mrb, c, "-e"); + v = mrb_load_string_cxt(mrb, args.cmdline, c); } mrbc_context_free(mrb, c); if (mrb->exc) { -- cgit v1.2.3 From cf2bd3469a08ac20cffa62fe00c54fd69844fcfa Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Fri, 5 Oct 2012 10:55:29 +0900 Subject: preserve script file name --- tools/mruby/mruby.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tools/mruby/mruby.c b/tools/mruby/mruby.c index 2ab9e845c..c1ac0d778 100644 --- a/tools/mruby/mruby.c +++ b/tools/mruby/mruby.c @@ -139,6 +139,7 @@ append_cmdline: return 0; } args->fname = 1; + args->cmdline = argv[0]; argc--; argv++; } } @@ -154,7 +155,7 @@ cleanup(mrb_state *mrb, struct _args *args) { if (args->rfp && args->rfp != stdin) fclose(args->rfp); - if (args->cmdline) + if (args->cmdline && !args->fname) mrb_free(mrb, args->cmdline); if (args->argv) mrb_free(mrb, args->argv); -- cgit v1.2.3 From 8949e3c7fb964e58d1666e9dba20c575e553b479 Mon Sep 17 00:00:00 2001 From: Beoran Date: Tue, 9 Oct 2012 21:45:41 +0200 Subject: Bugfix for crash if main was extended with a module. --- src/class.c | 2 ++ test/t/kernel.rb | 10 ++++++++++ 2 files changed, 12 insertions(+) diff --git a/src/class.c b/src/class.c index fad476929..a73f42566 100644 --- a/src/class.c +++ b/src/class.c @@ -786,6 +786,8 @@ mrb_singleton_class(mrb_state *mrb, mrb_value v) return mrb_obj_value(mrb->false_class); case MRB_TT_TRUE: return mrb_obj_value(mrb->true_class); + case MRB_TT_MAIN: + return mrb_obj_value(mrb->object_class); case MRB_TT_SYMBOL: case MRB_TT_FIXNUM: case MRB_TT_FLOAT: diff --git a/test/t/kernel.rb b/test/t/kernel.rb index fb0aee310..5caa3d7ac 100644 --- a/test/t/kernel.rb +++ b/test/t/kernel.rb @@ -204,6 +204,16 @@ assert('Kernel#extend', '15.3.1.3.13') do a.respond_to?(:test_method) == true && b.respond_to?(:test_method) == false end +assert('Kernel#extend works on toplevel', '15.3.1.3.13') do + module Test4ExtendModule + def test_method; end + end + # This would crash... + extend(Test4ExtendModule) + + respond_to?(:test_method) == true +end + assert('Kernel#global_variables', '15.3.1.3.14') do global_variables.class == Array end -- cgit v1.2.3 From 170d5e7181cef90daa63c39b16ea66f6bd2b17b4 Mon Sep 17 00:00:00 2001 From: Masaki Muranaka Date: Mon, 15 Oct 2012 13:15:29 +0900 Subject: Avoid memcpy() on copying structure. --- src/load.c | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/src/load.c b/src/load.c index 6c7396407..a960e883a 100644 --- a/src/load.c +++ b/src/load.c @@ -111,22 +111,22 @@ load_rite_header(FILE* fp, rite_binary_header* bin_header, unsigned char* hcrc) if (fread(&file_header, 1, sizeof(file_header), fp) < sizeof(file_header)) { return MRB_DUMP_READ_FAULT; } - memcpy(bin_header->rbfi, file_header.rbfi, sizeof(file_header.rbfi)); + *bin_header->rbfi = *file_header.rbfi; if (memcmp(bin_header->rbfi, RITE_FILE_IDENFIFIER, sizeof(bin_header->rbfi)) != 0) { return MRB_DUMP_INVALID_FILE_HEADER; //File identifier error } - memcpy(bin_header->rbfv, file_header.rbfv, sizeof(file_header.rbfv)); + *bin_header->rbfv = *file_header.rbfv; if (memcmp(bin_header->rbfv, RITE_FILE_FORMAT_VER, sizeof(bin_header->rbfv)) != 0) { return MRB_DUMP_INVALID_FILE_HEADER; //File format version error } - memcpy(bin_header->risv, file_header.risv, sizeof(file_header.risv)); - memcpy(bin_header->rct, file_header.rct, sizeof(file_header.rct)); - memcpy(bin_header->rcv, file_header.rcv, sizeof(file_header.rcv)); + *bin_header->risv = *file_header.risv; + *bin_header->rct = *file_header.rct; + *bin_header->rcv = *file_header.rcv; hex_to_bin32(bin_header->rbds, file_header.rbds); hex_to_bin16(bin_header->nirep, file_header.nirep); hex_to_bin16(bin_header->sirep, file_header.sirep); - memcpy(bin_header->rsv, file_header.rsv, sizeof(file_header.rsv)); - memcpy(hcrc, file_header.hcrc, sizeof(file_header.hcrc)); + *bin_header->rsv = *file_header.rsv; + *hcrc = *file_header.hcrc; return MRB_DUMP_OK; } @@ -267,7 +267,7 @@ mrb_load_irep(mrb_state *mrb, FILE* fp) dst = rite_dst; memset(dst, 0x00, len); - memcpy(dst, &bin_header, sizeof(rite_binary_header)); + *(rite_binary_header *)dst = bin_header; dst += sizeof(rite_binary_header); dst += hex_to_bin16(dst, hcrc); @@ -302,7 +302,7 @@ read_rite_header(mrb_state *mrb, unsigned char *bin, rite_binary_header* bin_he { uint16_t crc; - memcpy(bin_header, bin, sizeof(rite_binary_header)); + *bin_header = *(rite_binary_header *)bin; bin += sizeof(rite_binary_header); if (memcmp(bin_header->rbfi, RITE_FILE_IDENFIFIER, sizeof(bin_header->rbfi)) != 0) { return MRB_DUMP_INVALID_FILE_HEADER; //File identifier error -- cgit v1.2.3 From 5444c3bbb3d3f6274c08c58c266421ed594d9f6b Mon Sep 17 00:00:00 2001 From: Masaki Muranaka Date: Mon, 15 Oct 2012 13:23:49 +0900 Subject: Add more strict warning checks --- cmake/modules/IntrospectSystem.cmake | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cmake/modules/IntrospectSystem.cmake b/cmake/modules/IntrospectSystem.cmake index e148563fa..722f4c3d7 100644 --- a/cmake/modules/IntrospectSystem.cmake +++ b/cmake/modules/IntrospectSystem.cmake @@ -2,7 +2,7 @@ # initial system defaults if(CMAKE_COMPILER_IS_GNUCC) - set(MRUBY_DEFAULT_CFLAGS "-Wall -Werror-implicit-function-declaration") + set(MRUBY_DEFAULT_CFLAGS "-std=gnu99 -Wall -Werror-implicit-function-declaration -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-pointer-sign -Wno-missing-field-initializers -Wformat=2 -Wstrict-aliasing=2 -Wdisabled-optimization -Wpointer-arith -Wdeclaration-after-statement -Wbad-function-cast -Wcast-align -Wredundant-decls") set(CMAKE_C_FLAGS "${MRUBY_DEFAULT_CFLAGS}") set(CMAKE_C_FLAGS_DEBUG "-O3 -ggdb") set(CMAKE_C_FLAGS_MINSIZEREL "-Os -DNDEBUG") -- cgit v1.2.3 From e8abf03ae59b72bbc9c3af26eee33a9f4d17cc56 Mon Sep 17 00:00:00 2001 From: Masaki Muranaka Date: Mon, 15 Oct 2012 13:53:44 +0900 Subject: Avoid memcpy() on copying structure. --- src/time.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/time.c b/src/time.c index ea8205c7b..09ebea78a 100644 --- a/src/time.c +++ b/src/time.c @@ -559,7 +559,7 @@ mrb_time_initialize_copy(mrb_state *mrb, mrb_value copy) DATA_PTR(copy) = mrb_malloc(mrb, sizeof(struct mrb_time)); DATA_TYPE(copy) = &mrb_time_type; } - memcpy(DATA_PTR(copy), DATA_PTR(src), sizeof(struct mrb_time)); + *(struct mrb_time *)DATA_PTR(copy) = *(struct mrb_time *)DATA_PTR(src); return copy; } -- cgit v1.2.3 From 93b56e70ee26428e2f56dd82d3318622628aa62d Mon Sep 17 00:00:00 2001 From: Masaki Muranaka Date: Mon, 15 Oct 2012 13:56:45 +0900 Subject: Avoid memcpy() on copying structure. --- src/range.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/range.c b/src/range.c index 98b9093ef..cdcfcca53 100644 --- a/src/range.c +++ b/src/range.c @@ -415,7 +415,7 @@ range_initialize_copy(mrb_state *mrb, mrb_value copy) if (!mrb_obj_is_instance_of(mrb, src, mrb_obj_class(mrb, copy))) { mrb_raise(mrb, E_TYPE_ERROR, "wrong argument class"); } - memcpy(mrb_range_ptr(copy), mrb_range_ptr(src), sizeof(struct RRange)); + *mrb_range_ptr(copy) = *mrb_range_ptr(src); return copy; } -- cgit v1.2.3 From 76f28241f1a6eb76070d470779fc17d43ca838e3 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Tue, 16 Oct 2012 20:54:06 +0900 Subject: "mrbc -" should take input from stdin; close #489 --- tools/mrbc/mrbc.c | 18 +++++++++++++----- 1 file changed, 13 insertions(+), 5 deletions(-) diff --git a/tools/mrbc/mrbc.c b/tools/mrbc/mrbc.c index 5382b90a8..3c6352f80 100644 --- a/tools/mrbc/mrbc.c +++ b/tools/mrbc/mrbc.c @@ -77,8 +77,11 @@ parse_args(mrb_state *mrb, int argc, char **argv, struct _args *args) for (argc--,argv++; argc > 0; argc--,argv++) { if (**argv == '-') { - if (strlen(*argv) <= 1) - return -1; + if (strlen(*argv) == 1) { + args->filename = infile = "-"; + args->rfp = stdin; + break; + } switch ((*argv)[1]) { case 'o': @@ -134,9 +137,14 @@ parse_args(mrb_state *mrb, int argc, char **argv, struct _args *args) if (args->check_syntax) return 0; - if (outfile == NULL) - outfile = get_outfilename(infile, args->ext); - + if (outfile == NULL) { + if (strcmp("-", infile) == 0) { + outfile = infile; + } + else { + outfile = get_outfilename(infile, args->ext); + } + } if (strcmp("-", outfile) == 0) { args->wfp = stdout; } -- cgit v1.2.3 From 1bf70ea255a36fc6ff0991c1ac05cb0f44df8ce1 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Tue, 16 Oct 2012 21:18:28 +0900 Subject: 1.divmod(0) should not crash, but return [Inf,NaN] (CRuby incompat); close #492 --- src/numeric.c | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/src/numeric.c b/src/numeric.c index acc658e5c..6970869df 100644 --- a/src/numeric.c +++ b/src/numeric.c @@ -245,6 +245,11 @@ flodivmod(mrb_state *mrb, mrb_float x, mrb_float y, mrb_float *divp, mrb_float * { mrb_float div, mod; + if (y == 0.0) { + *divp = strtod("inf", NULL); + *modp = strtod("nan", NULL); + return; + } mod = fmod(x, y); if (isinf(x) && !isinf(y) && !isnan(y)) div = x; @@ -772,6 +777,9 @@ fix_mod(mrb_state *mrb, mrb_value x) if (FIXNUM_P(y) && (b=mrb_fixnum(y)) != 0) { mrb_int mod; + if (mrb_fixnum(y) == 0) { + return mrb_float_value(strtod("nan", NULL)); + } fixdivmod(mrb, a, mrb_fixnum(y), 0, &mod); return mrb_fixnum_value(mod); } @@ -798,6 +806,10 @@ fix_divmod(mrb_state *mrb, mrb_value x) if (FIXNUM_P(y)) { mrb_int div, mod; + if (mrb_fixnum(y) == 0) { + return mrb_assoc_new(mrb, mrb_float_value(strtod("inf", NULL)), + mrb_float_value(strtod("nan", NULL))); + } fixdivmod(mrb, mrb_fixnum(x), mrb_fixnum(y), &div, &mod); return mrb_assoc_new(mrb, mrb_fixnum_value(div), mrb_fixnum_value(mod)); } -- cgit v1.2.3 From f2da76b6ef3c0d96fa8b1526f96d0037a9411879 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Tue, 16 Oct 2012 22:24:40 +0900 Subject: register number adjustment for case statement was wrong; close #487 --- src/codegen.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/codegen.c b/src/codegen.c index 50d3e3d3b..0077f5593 100644 --- a/src/codegen.c +++ b/src/codegen.c @@ -1200,17 +1200,17 @@ codegen(codegen_scope *s, node *tree, int val) genop(s, MKOP_sBx(OP_JMP, 0)); dispatch_linked(s, pos2); } - pop(); + pop(); /* pop HEAD */ codegen(s, tree->car->cdr, val); - pop(); + if (val) pop(); tmp = new_label(s); genop(s, MKOP_sBx(OP_JMP, pos3)); pos3 = tmp; if (pos1) dispatch(s, pos1); tree = tree->cdr; - push(); + push(); /* push HEAD */ } - pop(); + pop(); /* pop HEAD */ genop(s, MKOP_A(OP_LOADNIL, cursp())); if (val) push(); if (pos3) dispatch_linked(s, pos3); -- cgit v1.2.3 From 27f002496f54028d04a93203f07ff5d7f6b1a037 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Tue, 16 Oct 2012 22:33:34 +0900 Subject: true/false should print proper inspect string --- src/kernel.c | 3 --- src/object.c | 11 ++++++++++- 2 files changed, 10 insertions(+), 4 deletions(-) diff --git a/src/kernel.c b/src/kernel.c index 5139762b7..cf3ee2344 100644 --- a/src/kernel.c +++ b/src/kernel.c @@ -61,9 +61,6 @@ mrb_obj_inspect(mrb_state *mrb, mrb_value obj) if ((mrb_type(obj) == MRB_TT_OBJECT) && mrb_obj_basic_to_s_p(mrb, obj)) { return mrb_obj_iv_inspect(mrb, mrb_obj_ptr(obj)); } - else if (mrb_nil_p(obj)) { - return mrb_str_new(mrb, "nil", 3); - } else if (mrb_type(obj) == MRB_TT_MAIN) { return mrb_str_new(mrb, "main", 4); } diff --git a/src/object.c b/src/object.c index 5130f3d54..093e8fd2b 100644 --- a/src/object.c +++ b/src/object.c @@ -82,7 +82,13 @@ mrb_true(mrb_state *mrb, mrb_value obj) static mrb_value nil_to_s(mrb_state *mrb, mrb_value obj) { - return mrb_str_new(mrb, 0, 0); + return mrb_str_new(mrb, 0, 0); +} + +static mrb_value +nil_inspect(mrb_state *mrb, mrb_value obj) +{ + return mrb_str_new(mrb, "nil", 3); } /*********************************************************************** @@ -272,6 +278,7 @@ mrb_init_object(mrb_state *mrb) mrb_define_method(mrb, n, "|", false_or, ARGS_REQ(1)); /* 15.2.4.3.3 */ mrb_define_method(mrb, n, "nil?", mrb_true, ARGS_NONE()); /* 15.2.4.3.4 */ mrb_define_method(mrb, n, "to_s", nil_to_s, ARGS_NONE()); /* 15.2.4.3.5 */ + mrb_define_method(mrb, n, "inspect", nil_inspect, ARGS_NONE()); t = mrb->true_class = mrb_define_class(mrb, "TrueClass", mrb->object_class); mrb_undef_class_method(mrb, t, "new"); @@ -279,6 +286,7 @@ mrb_init_object(mrb_state *mrb) mrb_define_method(mrb, t, "^", true_xor, ARGS_REQ(1)); /* 15.2.5.3.2 */ mrb_define_method(mrb, t, "to_s", true_to_s, ARGS_NONE()); /* 15.2.5.3.3 */ mrb_define_method(mrb, t, "|", true_or, ARGS_REQ(1)); /* 15.2.5.3.4 */ + mrb_define_method(mrb, t, "inspect", true_to_s, ARGS_NONE()); f = mrb->false_class = mrb_define_class(mrb, "FalseClass", mrb->object_class); mrb_undef_class_method(mrb, f, "new"); @@ -286,6 +294,7 @@ mrb_init_object(mrb_state *mrb) mrb_define_method(mrb, f, "^", false_xor, ARGS_REQ(1)); /* 15.2.6.3.2 */ mrb_define_method(mrb, f, "to_s", false_to_s, ARGS_NONE()); /* 15.2.6.3.3 */ mrb_define_method(mrb, f, "|", false_or, ARGS_REQ(1)); /* 15.2.6.3.4 */ + mrb_define_method(mrb, f, "inspect", false_to_s, ARGS_NONE()); } static mrb_value -- cgit v1.2.3 From 8271863fe5abb6d706d25f1dec87160f91bb28ff Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Tue, 16 Oct 2012 23:46:34 +0900 Subject: Kernel#block_given? always gave false --- src/kernel.c | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/kernel.c b/src/kernel.c index cf3ee2344..43820173c 100644 --- a/src/kernel.c +++ b/src/kernel.c @@ -235,6 +235,12 @@ mrb_f_block_given_p_m(mrb_state *mrb, mrb_value self) bp = mrb->stbase + ci->stackidx + 1; ci--; if (ci <= mrb->cibase) return mrb_false_value(); + /* block_given? called within block; check upper scope */ + if (ci->proc->env && ci->proc->env->stack) { + if (ci->proc->env->stack == mrb->stbase || mrb_nil_p(ci->proc->env->stack[1])) + return mrb_false_value(); + return mrb_true_value(); + } if (ci->argc > 0) { bp += ci->argc; } -- cgit v1.2.3 From 18dd60c162c2e5e9909864333cc1013df471cdd9 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Tue, 16 Oct 2012 23:47:16 +0900 Subject: remove wasting stack space --- src/codegen.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/codegen.c b/src/codegen.c index 0077f5593..f195c378a 100644 --- a/src/codegen.c +++ b/src/codegen.c @@ -2055,7 +2055,7 @@ scope_new(mrb_state *mrb, codegen_scope *prev, node *lv) p->syms = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym)*256); p->lv = lv; - p->sp += node_len(lv)+2; + p->sp += node_len(lv)+1; /* add self */ p->nlocals = p->sp; p->ai = mrb->arena_idx; -- cgit v1.2.3 From 265fa03d2c6863bf3425bfe00738ad15d62ba587 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Wed, 17 Oct 2012 00:40:23 +0900 Subject: defining mrb_int also requires MRB_INT_{MAX,MIN} to be defined --- include/mrbconf.h | 4 ++++ include/mruby/numeric.h | 4 ++-- 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/include/mrbconf.h b/include/mrbconf.h index d7ccb261d..76c1b37f9 100644 --- a/include/mrbconf.h +++ b/include/mrbconf.h @@ -62,8 +62,12 @@ typedef double mrb_float; #ifdef MRB_NAN_BOXING typedef int32_t mrb_int; +#define MRB_INT_MIN INT32_MIN +#define MRB_INT_MAX INT32_MAX #else typedef int mrb_int; +#define MRB_INT_MIN INT_MIN +#define MRB_INT_MAX INT_MAX #endif typedef short mrb_sym; diff --git a/include/mruby/numeric.h b/include/mruby/numeric.h index fed9ad39a..9a5ba449f 100644 --- a/include/mruby/numeric.h +++ b/include/mruby/numeric.h @@ -13,8 +13,8 @@ extern "C" { #include -#define POSFIXABLE(f) ((f) <= INT_MAX) -#define NEGFIXABLE(f) ((f) >= INT_MIN) +#define POSFIXABLE(f) ((f) <= MRB_INT_MAX) +#define NEGFIXABLE(f) ((f) >= MRB_INT_MIN) #define FIXABLE(f) (POSFIXABLE(f) && NEGFIXABLE(f)) mrb_value mrb_flt2big(mrb_state *mrb, mrb_float d); -- cgit v1.2.3 From 70abbb423a1b215563e6e4e58bfb76c02e59125d Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Wed, 17 Oct 2012 02:57:40 +0900 Subject: should not free() static iseq from cdump --- include/mruby/irep.h | 10 ++++++---- src/cdump.c | 19 +++++++++++++------ src/state.c | 3 ++- 3 files changed, 21 insertions(+), 11 deletions(-) diff --git a/include/mruby/irep.h b/include/mruby/irep.h index 0d8a05dbe..534590849 100644 --- a/include/mruby/irep.h +++ b/include/mruby/irep.h @@ -12,10 +12,10 @@ extern "C" { #endif typedef struct mrb_irep { - int idx; - - int nlocals; - int nregs; + int idx:16; + int nlocals:16; + int nregs:16; + int flags:8; mrb_code *iseq; mrb_value *pool; @@ -28,6 +28,8 @@ typedef struct mrb_irep { int ilen, plen, slen; } mrb_irep; +#define MRB_ISEQ_NO_FREE 1 + void mrb_add_irep(mrb_state *mrb, int n); #if defined(__cplusplus) diff --git a/src/cdump.c b/src/cdump.c index ba05a1899..c7597e12f 100644 --- a/src/cdump.c +++ b/src/cdump.c @@ -113,6 +113,7 @@ make_cdump_irep(mrb_state *mrb, int irep_no, FILE *f) SOURCE_CODE0 (" ai = mrb->arena_idx;"); SOURCE_CODE0 (" irep = mrb->irep[idx] = mrb_malloc(mrb, sizeof(mrb_irep));"); + SOURCE_CODE0 (" irep->flags = MRB_ISEQ_NO_FREE;"); SOURCE_CODE0 (" irep->idx = idx++;"); SOURCE_CODE (" irep->nlocals = %d;", irep->nlocals); SOURCE_CODE (" irep->nregs = %d;", irep->nregs); @@ -124,13 +125,19 @@ make_cdump_irep(mrb_state *mrb, int irep_no, FILE *f) SOURCE_CODE (" irep->syms = mrb_malloc(mrb, sizeof(mrb_sym)*%d);", irep->slen); for (n=0; nslen; n++) if (irep->syms[n]) { - SOURCE_CODE (" irep->syms[%d] = mrb_intern(mrb, \"%s\");", n, mrb_sym2name(mrb, irep->syms[n])); + const char *name; + int len; + + name = mrb_sym2name_len(mrb, irep->syms[n], &len); + SOURCE_CODE (" irep->syms[%d] = mrb_intern2(mrb, \"%s\", %d);", n, name, len); } } else SOURCE_CODE0 (" irep->syms = NULL;"); - SOURCE_CODE (" irep->plen = %d;", irep->plen); + SOURCE_CODE0 (" irep->pool = NULL;"); + SOURCE_CODE0 (" mrb->irep_len = idx;"); + SOURCE_CODE0 (" irep->plen = 0;"); if(irep->plen > 0) { SOURCE_CODE (" irep->pool = mrb_malloc(mrb, sizeof(mrb_value)*%d);", irep->plen); for (n=0; nplen; n++) { @@ -148,16 +155,16 @@ make_cdump_irep(mrb_state *mrb, int irep_no, FILE *f) } } memset(buf, 0, buf_len); - SOURCE_CODE(" irep->pool[%d] = mrb_str_new(mrb, \"%s\", %d);", n, str_to_format(irep->pool[n], buf), RSTRING_LEN(irep->pool[n])); break; + SOURCE_CODE(" irep->pool[%d] = mrb_str_new(mrb, \"%s\", %d);", n, str_to_format(irep->pool[n], buf), RSTRING_LEN(irep->pool[n])); + SOURCE_CODE0 (" mrb->arena_idx = ai;"); + break; /* TODO MRB_TT_REGEX */ default: break; } + SOURCE_CODE0(" irep->plen++;"); } } else - SOURCE_CODE0 (" irep->pool = NULL;"); - SOURCE_CODE0 (" mrb->irep_len = idx;"); - SOURCE_CODE0 (" mrb->arena_idx = ai;"); SOURCE_CODE0(""); return MRB_CDUMP_OK; } diff --git a/src/state.c b/src/state.c index 40d9bfc45..991be310e 100644 --- a/src/state.c +++ b/src/state.c @@ -92,7 +92,8 @@ mrb_close(mrb_state *mrb) mrb_free(mrb, mrb->stbase); mrb_free(mrb, mrb->cibase); for (i=0; iirep_len; i++) { - mrb_free(mrb, mrb->irep[i]->iseq); + if (!(mrb->irep[i]->flags & MRB_ISEQ_NO_FREE)) + mrb_free(mrb, mrb->irep[i]->iseq); mrb_free(mrb, mrb->irep[i]->pool); mrb_free(mrb, mrb->irep[i]->syms); mrb_free(mrb, mrb->irep[i]->lines); -- cgit v1.2.3 From 8d977981b7d111989928f568463ea67599356f41 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Wed, 17 Oct 2012 05:59:29 +0900 Subject: no memory copy for call_iseq --- src/proc.c | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/src/proc.c b/src/proc.c index 0efc8d286..3321c2a91 100644 --- a/src/proc.c +++ b/src/proc.c @@ -9,6 +9,10 @@ #include "mruby/class.h" #include "opcode.h" +static mrb_code call_iseq[] = { + MKOP_A(OP_CALL, 0), +}; + struct RProc * mrb_proc_new(mrb_state *mrb, mrb_irep *irep) { @@ -144,14 +148,13 @@ void mrb_init_proc(mrb_state *mrb) { struct RProc *m; - mrb_code *call_iseq = (mrb_code *)mrb_alloca(mrb, sizeof(mrb_code)); mrb_irep *call_irep = (mrb_irep *)mrb_alloca(mrb, sizeof(mrb_irep)); if ( call_iseq == NULL || call_irep == NULL ) return; memset(call_irep, 0, sizeof(mrb_irep)); - *call_iseq = MKOP_A(OP_CALL, 0); + call_irep->flags = MRB_ISEQ_NO_FREE; call_irep->idx = -1; call_irep->iseq = call_iseq; call_irep->ilen = 1; -- cgit v1.2.3 From 8d6f1b04a1f326e3668fd1b2aa0978c2bb38b3ff Mon Sep 17 00:00:00 2001 From: Takashi Sogabe Date: Wed, 17 Oct 2012 12:55:50 +0900 Subject: Fix disappearance of a local variable when return statement is called Commit of #18dd60c causes disappearance of a local variable if return statement is called without arguments. This patch fixes incorrect value of stack pointer. test program: def test_return_cond return if nil obj = 123 p obj p obj.class end test_return_cond output(commit #18dd60c): main Object output(includes this patch): 123 Fixnum --- src/codegen.c | 1 + 1 file changed, 1 insertion(+) diff --git a/src/codegen.c b/src/codegen.c index f195c378a..27f217ebe 100644 --- a/src/codegen.c +++ b/src/codegen.c @@ -1490,6 +1490,7 @@ codegen(codegen_scope *s, node *tree, int val) else { genop_peep(s, MKOP_AB(OP_RETURN, cursp(), OP_R_NORMAL), NOVAL); } + push(); break; case NODE_YIELD: -- cgit v1.2.3 From e84dfd43375f1b144ae7dd1b054e9944bdf2552f Mon Sep 17 00:00:00 2001 From: Masaki Muranaka Date: Wed, 17 Oct 2012 21:23:42 +0900 Subject: Fix degrades by #490. (Some changes are reverted.) --- src/load.c | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/src/load.c b/src/load.c index a960e883a..a2ae4100b 100644 --- a/src/load.c +++ b/src/load.c @@ -111,22 +111,22 @@ load_rite_header(FILE* fp, rite_binary_header* bin_header, unsigned char* hcrc) if (fread(&file_header, 1, sizeof(file_header), fp) < sizeof(file_header)) { return MRB_DUMP_READ_FAULT; } - *bin_header->rbfi = *file_header.rbfi; + memcpy(bin_header->rbfi, file_header.rbfi, sizeof(file_header.rbfi)); if (memcmp(bin_header->rbfi, RITE_FILE_IDENFIFIER, sizeof(bin_header->rbfi)) != 0) { return MRB_DUMP_INVALID_FILE_HEADER; //File identifier error } - *bin_header->rbfv = *file_header.rbfv; + memcpy(bin_header->rbfv, file_header.rbfv, sizeof(file_header.rbfv)); if (memcmp(bin_header->rbfv, RITE_FILE_FORMAT_VER, sizeof(bin_header->rbfv)) != 0) { return MRB_DUMP_INVALID_FILE_HEADER; //File format version error } - *bin_header->risv = *file_header.risv; - *bin_header->rct = *file_header.rct; - *bin_header->rcv = *file_header.rcv; + memcpy(bin_header->risv, file_header.risv, sizeof(file_header.risv)); + memcpy(bin_header->rct, file_header.rct, sizeof(file_header.rct)); + memcpy(bin_header->rcv, file_header.rcv, sizeof(file_header.rcv)); hex_to_bin32(bin_header->rbds, file_header.rbds); hex_to_bin16(bin_header->nirep, file_header.nirep); hex_to_bin16(bin_header->sirep, file_header.sirep); - *bin_header->rsv = *file_header.rsv; - *hcrc = *file_header.hcrc; + memcpy(bin_header->rsv, file_header.rsv, sizeof(file_header.rsv)); + memcpy(hcrc, file_header.hcrc, sizeof(file_header.hcrc)); return MRB_DUMP_OK; } -- cgit v1.2.3 From 19cd9c6e2eaa4849f37228babdbc2868d6750bad Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Thu, 18 Oct 2012 06:05:59 +0900 Subject: print error message on mrb load error --- tools/mruby/mruby.c | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/tools/mruby/mruby.c b/tools/mruby/mruby.c index c1ac0d778..cbe170e7f 100644 --- a/tools/mruby/mruby.c +++ b/tools/mruby/mruby.c @@ -172,7 +172,7 @@ main(int argc, char **argv) mrb_value ARGV; if (mrb == NULL) { - fprintf(stderr, "Invalid mrb_state, exiting mruby"); + fprintf(stderr, "Invalid mrb_state, exiting mruby\n"); return EXIT_FAILURE; } @@ -191,12 +191,13 @@ main(int argc, char **argv) if (args.mrbfile) { n = mrb_load_irep(mrb, args.rfp); - if (n >= 0) { - if (!args.check_syntax) { - mrb_run(mrb, mrb_proc_new(mrb, mrb->irep[n]), mrb_top_self(mrb)); - if (mrb->exc) { - p(mrb, mrb_obj_value(mrb->exc)); - } + if (n < 0) { + fprintf(stderr, "failed to load mrb file: %s\n", args.cmdline); + } + else if (!args.check_syntax) { + mrb_run(mrb, mrb_proc_new(mrb, mrb->irep[n]), mrb_top_self(mrb)); + if (mrb->exc) { + p(mrb, mrb_obj_value(mrb->exc)); } } } -- cgit v1.2.3 From c2a6ff7af8a49609fb3126271cf4ebbfa3c2403e Mon Sep 17 00:00:00 2001 From: Takashi Sogabe Date: Thu, 18 Oct 2012 17:35:56 +0900 Subject: Fix wrong storage of data when hex-style string is loaded This patch fixes corruption of data when hex-style string is loaded. I saw following phenomenon in an ubuntu/amd64 environment. Test code: str = "\x0\x1\x2\x03\x04\x05\x06\a\b\t\n\v\f\r\x0E\x0F\x10" p str[-1] == "\0x10" Output(binary program with mrbc -B): false Output(script with mruby): true --- src/parse.y | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/parse.y b/src/parse.y index af12112c7..b903ac840 100644 --- a/src/parse.y +++ b/src/parse.y @@ -3329,7 +3329,7 @@ read_escape(parser_state *p) break; } } - c = scan_hex(buf, i+1, &i); + c = scan_hex(buf, i, &i); if (i == 0) { yyerror(p, "Invalid escape character syntax"); return 0; -- cgit v1.2.3 From ac3b1c4c5a024301af54460e7846b880ed9de099 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Fri, 19 Oct 2012 01:50:40 +0900 Subject: lshift must not assume sizeof(long) >= sizeof(mrb_int) --- src/numeric.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/numeric.c b/src/numeric.c index 6970869df..284d0a82e 100644 --- a/src/numeric.c +++ b/src/numeric.c @@ -949,8 +949,7 @@ fix_xor(mrb_state *mrb, mrb_value x) static mrb_value lshift(mrb_state *mrb, mrb_int val, unsigned long width) { - if (width > (sizeof(mrb_int)*CHAR_BIT-1) - || ((unsigned long)abs(val))>>(sizeof(mrb_int)*CHAR_BIT-1-width) > 0) { + if (width > (sizeof(mrb_int)*CHAR_BIT-1)) { mrb_raise(mrb, E_RANGE_ERROR, "width(%d) > (%d:sizeof(mrb_int)*CHAR_BIT-1)", width, sizeof(mrb_int)*CHAR_BIT-1); } -- cgit v1.2.3 From fd949663d2229419a1e53e69351205cd27157653 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Fri, 19 Oct 2012 21:09:34 +0900 Subject: Enumerable#inject should handle empty enumerable; http://www.tbn.co.jp/blog/?p=813 --- mrblib/enum.rb | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/mrblib/enum.rb b/mrblib/enum.rb index 2699a18af..666ada294 100644 --- a/mrblib/enum.rb +++ b/mrblib/enum.rb @@ -200,13 +200,18 @@ module Enumerable # ISO 15.3.2.2.11 def inject(*args, &block) raise ArgumentError, "too many arguments" if args.size > 2 - flag = true # 1st element? - result = nil + if args.empty? + flag = true # no initial argument + result = nil + else + flag = false + result = args[0] + end self.each{|val| if flag - # 1st element - result = (args.empty?)? val: block.call(args[0], val) + # push first element as initial flag = false + result = val else result = block.call(result, val) end -- cgit v1.2.3 From 17278e8ca69d79f4d37e65830c95cc6004c2d8f5 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Fri, 19 Oct 2012 21:16:18 +0900 Subject: add symbol style to Enumerable#inject --- mrblib/enum.rb | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/mrblib/enum.rb b/mrblib/enum.rb index 666ada294..29422716c 100644 --- a/mrblib/enum.rb +++ b/mrblib/enum.rb @@ -199,7 +199,12 @@ module Enumerable # # ISO 15.3.2.2.11 def inject(*args, &block) - raise ArgumentError, "too many arguments" if args.size > 2 + raise ArgumentError, "too many arguments" if args.size > 3 + if Symbol === args[-1] + sym = args[-1] + block = ->(x,y){x.send(sym,y)} + args.pop + end if args.empty? flag = true # no initial argument result = nil @@ -218,6 +223,7 @@ module Enumerable } result end + alias reduce inject ## # Alias for collect -- cgit v1.2.3 From 3efbea3fab1fedf1f6b783204fd226653e908f6e Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Fri, 19 Oct 2012 21:44:58 +0900 Subject: wrong check of argument numbers --- mrblib/enum.rb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mrblib/enum.rb b/mrblib/enum.rb index 29422716c..2774bc856 100644 --- a/mrblib/enum.rb +++ b/mrblib/enum.rb @@ -199,7 +199,7 @@ module Enumerable # # ISO 15.3.2.2.11 def inject(*args, &block) - raise ArgumentError, "too many arguments" if args.size > 3 + raise ArgumentError, "too many arguments" if args.size > 2 if Symbol === args[-1] sym = args[-1] block = ->(x,y){x.send(sym,y)} -- cgit v1.2.3 From 651e8b7e9c513cda100d88216d54ceeb93234f65 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Fri, 19 Oct 2012 23:04:20 +0900 Subject: empty NODE_BEGIN should push nil; close #496 --- src/codegen.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/codegen.c b/src/codegen.c index 27f217ebe..d42a099c8 100644 --- a/src/codegen.c +++ b/src/codegen.c @@ -951,6 +951,10 @@ codegen(codegen_scope *s, node *tree, int val) tree = tree->cdr; switch (nt) { case NODE_BEGIN: + if (val && !tree) { + genop(s, MKOP_A(OP_LOADNIL, cursp())); + push(); + } while (tree) { codegen(s, tree->car, tree->cdr ? NOVAL : val); tree = tree->cdr; -- cgit v1.2.3 From 2f5f853111dd5d73cb7a85c5306aa1e41d3d7fc4 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Fri, 19 Oct 2012 23:17:49 +0900 Subject: shuld handle return in rescue; close #487 --- src/vm.c | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/vm.c b/src/vm.c index 7bf3af9d4..14efb38f8 100644 --- a/src/vm.c +++ b/src/vm.c @@ -1126,6 +1126,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self) switch (GETARG_B(i)) { case OP_R_NORMAL: + NORMAL_RETURN: if (ci == mrb->cibase) { localjump_error(mrb, "return"); goto L_RAISE; @@ -1133,6 +1134,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self) ci = mrb->ci; break; case OP_R_BREAK: + if (!proc->env) goto NORMAL_RETURN; if (proc->env->cioff < 0) { localjump_error(mrb, "break"); goto L_RAISE; @@ -1140,6 +1142,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self) ci = mrb->ci = mrb->cibase + proc->env->cioff + 1; break; case OP_R_RETURN: + if (!proc->env) goto NORMAL_RETURN; if (proc->env->cioff < 0) { localjump_error(mrb, "return"); goto L_RAISE; -- cgit v1.2.3 From 400a9d81019d987704c5890872d2599a3c60114c Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Fri, 19 Oct 2012 23:18:57 +0900 Subject: shuld handle return in rescue; close #497 --- src/vm.c | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/vm.c b/src/vm.c index 7bf3af9d4..14efb38f8 100644 --- a/src/vm.c +++ b/src/vm.c @@ -1126,6 +1126,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self) switch (GETARG_B(i)) { case OP_R_NORMAL: + NORMAL_RETURN: if (ci == mrb->cibase) { localjump_error(mrb, "return"); goto L_RAISE; @@ -1133,6 +1134,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self) ci = mrb->ci; break; case OP_R_BREAK: + if (!proc->env) goto NORMAL_RETURN; if (proc->env->cioff < 0) { localjump_error(mrb, "break"); goto L_RAISE; @@ -1140,6 +1142,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self) ci = mrb->ci = mrb->cibase + proc->env->cioff + 1; break; case OP_R_RETURN: + if (!proc->env) goto NORMAL_RETURN; if (proc->env->cioff < 0) { localjump_error(mrb, "return"); goto L_RAISE; -- cgit v1.2.3 From da637cac4a3520f7d6d9a69b392be4309f36ef5b Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Sat, 20 Oct 2012 03:30:58 +0900 Subject: should handle break in rescue --- src/codegen.c | 3 +++ src/vm.c | 1 - 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/src/codegen.c b/src/codegen.c index d42a099c8..19a5835fa 100644 --- a/src/codegen.c +++ b/src/codegen.c @@ -2146,6 +2146,9 @@ loop_break(codegen_scope *s, node *tree) genop_peep(s, MKOP_A(OP_POPERR, 1), NOVAL); loop = loop->prev; } + while (loop->type == LOOP_RESCUE) { + loop = loop->prev; + } if (loop->type == LOOP_NORMAL) { int tmp; diff --git a/src/vm.c b/src/vm.c index 14efb38f8..a779565be 100644 --- a/src/vm.c +++ b/src/vm.c @@ -1134,7 +1134,6 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self) ci = mrb->ci; break; case OP_R_BREAK: - if (!proc->env) goto NORMAL_RETURN; if (proc->env->cioff < 0) { localjump_error(mrb, "break"); goto L_RAISE; -- cgit v1.2.3 From 9bb6f0b3314d438e93ec79ae763ac57a559284bc Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Sat, 20 Oct 2012 03:32:02 +0900 Subject: pool string need not to convert --- src/dump.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/dump.c b/src/dump.c index 516374cd9..c8f92ec72 100644 --- a/src/dump.c +++ b/src/dump.c @@ -354,9 +354,9 @@ write_pool_block(mrb_state *mrb, mrb_irep *irep, char *buf, int type) break; case MRB_TT_STRING: - str = mrb_string_value( mrb, &irep->pool[pool_no]); + str = irep->pool[pool_no]; len = str_dump_len(RSTRING_PTR(str), RSTRING_LEN(str), type); - if ( len > buf_size - 1) { + if (len > buf_size - 1) { buf_size = len + 1; if ((char_buf = (char *)mrb_realloc(mrb, char_buf, buf_size)) == 0) goto error_exit; -- cgit v1.2.3 From 89a18e4f22de80b836f9d6c3167d71b7078a31bb Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Sat, 20 Oct 2012 03:59:13 +0900 Subject: unexpect break/next/redo/retry should raise LocalJumpError --- src/codegen.c | 2 +- src/vm.c | 8 +++++++- test/t/localjumperror.rb | 7 ++++++- test/t/runtimeerror.rb | 10 +--------- 4 files changed, 15 insertions(+), 12 deletions(-) diff --git a/src/codegen.c b/src/codegen.c index 19a5835fa..2482209cc 100644 --- a/src/codegen.c +++ b/src/codegen.c @@ -911,7 +911,7 @@ raise_error(codegen_scope *s, const char *msg) { int idx = new_lit(s, mrb_str_new_cstr(s->mrb, msg)); - genop(s, MKOP_ABx(OP_ERR, 0, idx)); + genop(s, MKOP_ABx(OP_ERR, 1, idx)); } static double diff --git a/src/vm.c b/src/vm.c index a779565be..a68d089cc 100644 --- a/src/vm.c +++ b/src/vm.c @@ -1817,8 +1817,14 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self) CASE(OP_ERR) { /* Bx raise RuntimeError with message Lit(Bx) */ mrb_value msg = pool[GETARG_Bx(i)]; - mrb_value exc = mrb_exc_new3(mrb, E_RUNTIME_ERROR, msg); + mrb_value exc; + if (GETARG_A(i) == 0) { + exc = mrb_exc_new3(mrb, E_RUNTIME_ERROR, msg); + } + else { + exc = mrb_exc_new3(mrb, E_LOCALJUMP_ERROR, msg); + } mrb->exc = (struct RObject*)mrb_object(exc); goto L_RAISE; } diff --git a/test/t/localjumperror.rb b/test/t/localjumperror.rb index 9d1df9594..ebcec0670 100644 --- a/test/t/localjumperror.rb +++ b/test/t/localjumperror.rb @@ -2,7 +2,12 @@ # LocalJumpError ISO Test assert('LocalJumoError', '15.2.25') do - LocalJumpError.class == Class + begin + # this will cause an exception due to the wrong location + retry + rescue => e1 + end + LocalJumpError.class == Class and e1.class == LocalJumpError end # TODO 15.2.25.2.1 LocalJumpError#exit_value diff --git a/test/t/runtimeerror.rb b/test/t/runtimeerror.rb index 9157293cd..3e0636186 100644 --- a/test/t/runtimeerror.rb +++ b/test/t/runtimeerror.rb @@ -2,13 +2,5 @@ # RuntimeError ISO Test assert('RuntimeError', '15.2.28') do - e2 = nil - begin - # this will cause an exception due to the wrong location - retry - rescue => e1 - e2 = e1 - end - - RuntimeError.class == Class and e2.class == RuntimeError + RuntimeError.class == Class end -- cgit v1.2.3 From 750b7c209c2200a602438a75206f5c3c8391f69e Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Sat, 20 Oct 2012 08:44:25 +0900 Subject: pop register stack before rescue --- src/codegen.c | 1 + 1 file changed, 1 insertion(+) diff --git a/src/codegen.c b/src/codegen.c index 2482209cc..7d10ffce8 100644 --- a/src/codegen.c +++ b/src/codegen.c @@ -972,6 +972,7 @@ codegen(codegen_scope *s, node *tree, int val) lp->pc1 = onerr; if (tree->car) { codegen(s, tree->car, val); + if (val) pop(); } lp->type = LOOP_RESCUE; noexc = new_label(s); -- cgit v1.2.3 From f166f63f452d21c55a860d26a57b2f815f5c96f2 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Sat, 20 Oct 2012 08:50:51 +0900 Subject: add test case for 750b7c2 --- test/t/exception.rb | 20 +++++++++++++++++++- 1 file changed, 19 insertions(+), 1 deletion(-) diff --git a/test/t/exception.rb b/test/t/exception.rb index 76c165e95..aa707c1b1 100644 --- a/test/t/exception.rb +++ b/test/t/exception.rb @@ -30,7 +30,7 @@ end assert('Exception#to_s', '15.2.22.5.3') do e = Exception.exception('a') - + e.to_s == 'a' end @@ -269,6 +269,24 @@ assert('Exception 14') do a == :ok end +assert('Exception 15') do + a = begin + :ok + rescue + :ng + end + a == :ok +end + +assert('Exception 16') do + begin + raise "foo" + false + rescue => e + e.message == "foo" + end +end + assert('Exception#inspect without message') do Exception.new.inspect end -- cgit v1.2.3 From 7fe6d00ff54fe5cb746ef9370b91d2251751e21f Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Sat, 20 Oct 2012 09:48:04 +0900 Subject: avoid duplicated OP_RETURN --- src/codegen.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/codegen.c b/src/codegen.c index 7d10ffce8..1f087b2cd 100644 --- a/src/codegen.c +++ b/src/codegen.c @@ -267,6 +267,8 @@ genop_peep(codegen_scope *s, mrb_code i, int val) break; case OP_RETURN: switch (c0) { + case OP_RETURN: + return; case OP_MOVE: s->iseq[s->pc-1] = MKOP_AB(OP_RETURN, GETARG_B(i0), OP_R_NORMAL); return; -- cgit v1.2.3 From d5c4439013084ea5dcd30fd44a3a3d045e2dce67 Mon Sep 17 00:00:00 2001 From: Masaki Muranaka Date: Sun, 21 Oct 2012 00:49:39 +0900 Subject: Avoid memcpy() on copying structures. --- src/array.c | 29 ++++++++++++++++++++--------- src/vm.c | 24 +++++++++++++++++------- 2 files changed, 37 insertions(+), 16 deletions(-) diff --git a/src/array.c b/src/array.c index 36f4af9c6..726271d1c 100644 --- a/src/array.c +++ b/src/array.c @@ -63,6 +63,17 @@ mrb_ary_new(mrb_state *mrb) return mrb_ary_new_capa(mrb, 0); } +static inline void +array_copy(mrb_value *dst, const mrb_value *src, size_t size) +{ + int i; + + for (i = 0; i < size; i++) { + dst[i] = src[i]; + } +} + + mrb_value mrb_ary_new_from_values(mrb_state *mrb, int size, mrb_value *vals) { @@ -71,7 +82,7 @@ mrb_ary_new_from_values(mrb_state *mrb, int size, mrb_value *vals) ary = mrb_ary_new_capa(mrb, size); a = mrb_ary_ptr(ary); - memcpy(a->ptr, vals, sizeof(mrb_value)*size); + array_copy(a->ptr, vals, size); a->len = size; return ary; @@ -115,7 +126,7 @@ ary_modify(mrb_state *mrb, struct RArray *a) len = a->len * sizeof(mrb_value); ptr = (mrb_value *)mrb_malloc(mrb, len); if (p) { - memcpy(ptr, p, len); + array_copy(ptr, p, a->len); } a->ptr = ptr; a->aux.capa = a->len; @@ -213,7 +224,7 @@ ary_concat(mrb_state *mrb, struct RArray *a, mrb_value *ptr, int blen) ary_modify(mrb, a); if (a->aux.capa < len) ary_expand_capa(mrb, a, len); - memcpy(a->ptr+a->len, ptr, sizeof(mrb_value)*blen); + array_copy(a->ptr+a->len, ptr, blen); mrb_write_barrier(mrb, (struct RBasic*)a); a->len = len; } @@ -249,8 +260,8 @@ mrb_ary_plus(mrb_state *mrb, mrb_value self) mrb_get_args(mrb, "a", &ptr, &blen); ary = mrb_ary_new_capa(mrb, a1->len + blen); a2 = mrb_ary_ptr(ary); - memcpy(a2->ptr, a1->ptr, sizeof(mrb_value)*a1->len); - memcpy(a2->ptr + a1->len, ptr, sizeof(mrb_value)*blen); + array_copy(a2->ptr, a1->ptr, a1->len); + array_copy(a2->ptr + a1->len, ptr, blen); a2->len = a1->len + blen; return ary; @@ -309,7 +320,7 @@ ary_replace(mrb_state *mrb, struct RArray *a, mrb_value *argv, int len) ary_modify(mrb, a); if (a->aux.capa < len) ary_expand_capa(mrb, a, len); - memcpy(a->ptr, argv, sizeof(mrb_value)*len); + array_copy(a->ptr, argv, len); mrb_write_barrier(mrb, (struct RBasic*)a); a->len = len; } @@ -352,7 +363,7 @@ mrb_ary_times(mrb_state *mrb, mrb_value self) a2 = mrb_ary_ptr(ary); ptr = a2->ptr; while(times--) { - memcpy(ptr, a1->ptr, sizeof(mrb_value)*(a1->len)); + array_copy(ptr, a1->ptr, a1->len); ptr += a1->len; a2->len += a1->len; } @@ -410,7 +421,7 @@ mrb_ary_new4(mrb_state *mrb, int n, const mrb_value *elts) ary = mrb_ary_new_capa(mrb, n); if (n > 0 && elts) { - memcpy(RARRAY_PTR(ary), elts, sizeof(mrb_value)*n); + array_copy(RARRAY_PTR(ary), elts, n); RARRAY_LEN(ary) = n; } @@ -540,7 +551,7 @@ mrb_ary_unshift_m(mrb_state *mrb, mrb_value self) ary_expand_capa(mrb, a, a->len + len); memmove(a->ptr + len, a->ptr, sizeof(mrb_value)*a->len); } - memcpy(a->ptr, vals, sizeof(mrb_value)*len); + array_copy(a->ptr, vals, len); a->len += len; mrb_write_barrier(mrb, (struct RBasic*)a); diff --git a/src/vm.c b/src/vm.c index a68d089cc..b580df5a5 100644 --- a/src/vm.c +++ b/src/vm.c @@ -38,6 +38,16 @@ #define STACK_INIT_SIZE 128 #define CALLINFO_INIT_SIZE 32 +static inline void +stack_copy(mrb_value *dst, const mrb_value *src, size_t size) +{ + int i; + + for (i = 0; i < size; i++) { + dst[i] = src[i]; + } +} + static void stack_init(mrb_state *mrb) { @@ -170,7 +180,7 @@ cipop(mrb_state *mrb) mrb_value *p = (mrb_value *)mrb_malloc(mrb, sizeof(mrb_value)*len); e->cioff = -1; - memcpy(p, e->stack, sizeof(mrb_value)*len); + stack_copy(p, e->stack, len); e->stack = p; } @@ -296,10 +306,10 @@ mrb_funcall_with_block(mrb_state *mrb, mrb_value self, mrb_sym mid, int argc, mr mrb->stack[0] = self; if (undef) { mrb->stack[1] = mrb_symbol_value(undef); - memcpy(mrb->stack+2, argv, sizeof(mrb_value)*(argc-1)); + stack_copy(mrb->stack+2, argv, argc-1); } else if (argc > 0) { - memcpy(mrb->stack+1, argv, sizeof(mrb_value)*argc); + stack_copy(mrb->stack+1, argv, argc); } mrb->stack[argc+1] = blk; @@ -351,7 +361,7 @@ mrb_yield_internal(mrb_state *mrb, mrb_value b, int argc, mrb_value *argv, mrb_v stack_extend(mrb, ci->nregs, 0); mrb->stack[0] = self; if (argc > 0) { - memcpy(mrb->stack+1, argv, sizeof(mrb_value)*argc); + stack_copy(mrb->stack+1, argv, argc); } mrb->stack[argc+1] = mrb_nil_value(); @@ -989,12 +999,12 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self) } regs[a] = mrb_ary_new_capa(mrb, m1+len+m2); rest = mrb_ary_ptr(regs[a]); - memcpy(rest->ptr, stack, sizeof(mrb_value)*m1); + stack_copy(rest->ptr, stack, m1); if (len > 0) { - memcpy(rest->ptr+m1, pp, sizeof(mrb_value)*len); + stack_copy(rest->ptr+m1, pp, len); } if (m2 > 0) { - memcpy(rest->ptr+m1+len, stack+m1+1, sizeof(mrb_value)*m2); + stack_copy(rest->ptr+m1+len, stack+m1+1, m2); } rest->len = m1+len+m2; } -- cgit v1.2.3 From 2cb183f1831d7949130ab8ecbca0630a08a1ba60 Mon Sep 17 00:00:00 2001 From: Masaki Muranaka Date: Mon, 22 Oct 2012 10:36:49 +0900 Subject: Avoid memcpy() on copying structures. --- src/struct.c | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/src/struct.c b/src/struct.c index a1ad2e1c0..64f0e8a4a 100644 --- a/src/struct.c +++ b/src/struct.c @@ -94,6 +94,16 @@ mrb_struct_s_members_m(mrb_state *mrb, mrb_value klass) return ary; } +static inline void +struct_copy(mrb_value *dst, const mrb_value *src, size_t size) +{ + size_t i; + + for (i = 0; i < size; i++) { + dst[i] = src[i]; + } +} + /* 15.2.18.4.6 */ /* * call-seq: @@ -431,7 +441,7 @@ mrb_struct_initialize_withArg(mrb_state *mrb, int argc, mrb_value *argv, mrb_val st = RSTRUCT(self); st->ptr = (mrb_value *)mrb_calloc(mrb, sizeof(mrb_value), n); st->len = n; - memcpy(st->ptr, argv, sizeof(mrb_value)*argc); + struct_copy(st->ptr, argv, argc); return self; } @@ -530,7 +540,7 @@ mrb_struct_init_copy(mrb_state *mrb, mrb_value copy) if (RSTRUCT_LEN(copy) != RSTRUCT_LEN(s)) { mrb_raise(mrb, E_TYPE_ERROR, "struct size mismatch"); } - memcpy(RSTRUCT_PTR(copy), RSTRUCT_PTR(s), sizeof(mrb_value)*RSTRUCT_LEN(copy)); + struct_copy(RSTRUCT_PTR(copy), RSTRUCT_PTR(s), RSTRUCT_LEN(copy)); return copy; } -- cgit v1.2.3 From 2ab40b4dccb0be468d1ee7e5e8e1b0e294e3826d Mon Sep 17 00:00:00 2001 From: Masaki Muranaka Date: Mon, 22 Oct 2012 10:52:24 +0900 Subject: Fix prototype/declaration mismatch in uint8_dump(). --- src/dump.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/dump.c b/src/dump.c index c8f92ec72..4f672e188 100644 --- a/src/dump.c +++ b/src/dump.c @@ -76,7 +76,7 @@ static int mrb_write_irep(mrb_state*,int,char*); static inline int -uint8_dump(unsigned char bin, char *hex, int type) +uint8_dump(uint8_t bin, char *hex, int type) { if (type == DUMP_TYPE_BIN) { *hex = bin; -- cgit v1.2.3 From fed285d1945d1fa3104b441cf51db2d7118a5d01 Mon Sep 17 00:00:00 2001 From: Masaki Muranaka Date: Mon, 22 Oct 2012 11:17:31 +0900 Subject: Use MRB_DUMP_SIZE_OF_CHAR instead of sizeof(char). --- include/mruby/dump.h | 1 + src/dump.c | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/include/mruby/dump.h b/include/mruby/dump.h index 0826606e9..cad797275 100644 --- a/include/mruby/dump.h +++ b/include/mruby/dump.h @@ -41,6 +41,7 @@ int mrb_bdump_irep(mrb_state *mrb, int n, FILE *f,const char *initname); #define MRB_DUMP_SIZE_OF_LONG 4 #define MRB_DUMP_SIZE_OF_INT 4 #define MRB_DUMP_SIZE_OF_SHORT 2 +#define MRB_DUMP_SIZE_OF_CHAR 1 /* null symbol length */ #define MRB_DUMP_NULL_SYM_LEN 0xFFFF diff --git a/src/dump.c b/src/dump.c index c8f92ec72..e7e1a4807 100644 --- a/src/dump.c +++ b/src/dump.c @@ -84,7 +84,7 @@ uint8_dump(unsigned char bin, char *hex, int type) *hex++ = bin2hex[(bin >> 4) & 0x0f]; *hex = bin2hex[bin & 0x0f]; } - return DUMP_SIZE(sizeof(char), type); + return DUMP_SIZE(MRB_DUMP_SIZE_OF_CHAR, type); } static inline int -- cgit v1.2.3 From dd10048094b3fa9a53b1385bd16ffcc07d35e1a6 Mon Sep 17 00:00:00 2001 From: Masaki Muranaka Date: Mon, 22 Oct 2012 11:21:04 +0900 Subject: Remove redundant sizeof(char). "Always sizeof(char) == 1" is described in ISO C specs. --- src/dump.c | 4 ++-- src/string.c | 6 +++--- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/dump.c b/src/dump.c index e7e1a4807..c18362233 100644 --- a/src/dump.c +++ b/src/dump.c @@ -188,7 +188,7 @@ get_irep_header_size(mrb_state *mrb, mrb_irep *irep, int type) { uint32_t size = 0; - size += sizeof(char) * 2; + size += 2; size += DUMP_SIZE(MRB_DUMP_SIZE_OF_SHORT, type) * 4; return size; @@ -215,7 +215,7 @@ get_pool_block_size(mrb_state *mrb, mrb_irep *irep, int type) char buf[32]; size += MRB_DUMP_SIZE_OF_LONG; /* plen */ - size += irep->plen * sizeof(char); /* tt(n) */ + size += irep->plen; /* tt(n) */ size += irep->plen * MRB_DUMP_SIZE_OF_SHORT; /* len(n) */ size += MRB_DUMP_SIZE_OF_SHORT; /* crc */ size = DUMP_SIZE(size, type); diff --git a/src/string.c b/src/string.c index 57bbbc831..11e760ca1 100644 --- a/src/string.c +++ b/src/string.c @@ -2494,7 +2494,7 @@ mrb_cstr_to_inum(mrb_state *mrb, const char *str, int base, int badcheck) if (badcheck) goto bad; return mrb_fixnum_value(0); } - len *= strlen(str)*sizeof(char); + len *= strlen(str); val = strtoul((char*)str, &end, base); @@ -2546,7 +2546,7 @@ mrb_str_to_inum(mrb_state *mrb, mrb_value str, int base, int badcheck) char *p = (char *)mrb_malloc(mrb, len+1); //MEMCPY(p, s, char, len); - memcpy(p, s, sizeof(char)*len); + memcpy(p, s, len); p[len] = '\0'; s = p; } @@ -2682,7 +2682,7 @@ mrb_str_to_dbl(mrb_state *mrb, mrb_value str, int badcheck) if (s[len]) { /* no sentinel somehow */ char *p = (char *)mrb_malloc(mrb, len+1); - memcpy(p, s, sizeof(char)*len); + memcpy(p, s, len); p[len] = '\0'; s = p; } -- cgit v1.2.3 From 6069a33089916d7059c2bd2aeddc02a3eb440520 Mon Sep 17 00:00:00 2001 From: Masaki Muranaka Date: Tue, 23 Oct 2012 09:42:22 +0900 Subject: mrb_raisef(): new function. Same as previou version of mrb_raise(). mrb_raise(): API modified. It cannot treat variable arguments. --- include/mruby.h | 4 ++-- src/array.c | 2 +- src/class.c | 20 ++++++++++---------- src/error.c | 14 +++++++++++--- src/etc.c | 4 ++-- src/kernel.c | 4 ++-- src/numeric.c | 4 ++-- src/object.c | 10 +++++----- src/range.c | 2 +- src/sprintf.c | 30 +++++++++++++++--------------- src/string.c | 14 +++++++------- src/struct.c | 12 ++++++------ src/variable.c | 2 +- src/vm.c | 4 ++-- 14 files changed, 67 insertions(+), 59 deletions(-) diff --git a/include/mruby.h b/include/mruby.h index b741e6444..94fa393ea 100644 --- a/include/mruby.h +++ b/include/mruby.h @@ -282,8 +282,8 @@ mrb_value mrb_exc_new(mrb_state *mrb, struct RClass *c, const char *ptr, long le void mrb_exc_raise(mrb_state *mrb, mrb_value exc); int mrb_block_given_p(void); -void mrb_raise(mrb_state *mrb, struct RClass *c, const char *fmt, ...); -void rb_raise(struct RClass *c, const char *fmt, ...); +void mrb_raise(mrb_state *mrb, struct RClass *c, const char *msg); +void mrb_raisef(mrb_state *mrb, struct RClass *c, const char *fmt, ...); void mrb_warn(const char *fmt, ...); void mrb_bug(const char *fmt, ...); diff --git a/src/array.c b/src/array.c index 726271d1c..2e2536368 100644 --- a/src/array.c +++ b/src/array.c @@ -580,7 +580,7 @@ mrb_ary_set(mrb_state *mrb, mrb_value ary, mrb_int n, mrb_value val) /* rb_ary_s if (n < 0) { n += a->len; if (n < 0) { - mrb_raise(mrb, E_INDEX_ERROR, "index %ld out of array", n - a->len); + mrb_raisef(mrb, E_INDEX_ERROR, "index %ld out of array", n - a->len); } } if (a->len <= (int)n) { diff --git a/src/class.c b/src/class.c index a73f42566..c4058ad67 100644 --- a/src/class.c +++ b/src/class.c @@ -171,11 +171,11 @@ mrb_vm_define_class(mrb_state *mrb, mrb_value outer, mrb_value super, mrb_sym id c = mrb_class_ptr(v); if (!mrb_nil_p(super)) { if (mrb_type(super) != MRB_TT_CLASS) { - mrb_raise(mrb, E_TYPE_ERROR, "superclass must be a Class (%s given)", mrb_obj_classname(mrb, super)); + mrb_raisef(mrb, E_TYPE_ERROR, "superclass must be a Class (%s given)", mrb_obj_classname(mrb, super)); } if (!c->super || mrb_class_ptr(super) != mrb_class_real(c->super)) { - mrb_raise(mrb, E_TYPE_ERROR, "superclass mismatch for class %s", mrb_sym2name(mrb, id)); + mrb_raisef(mrb, E_TYPE_ERROR, "superclass mismatch for class %s", mrb_sym2name(mrb, id)); } } @@ -184,7 +184,7 @@ mrb_vm_define_class(mrb_state *mrb, mrb_value outer, mrb_value super, mrb_sym id if (!mrb_nil_p(super)) { if (mrb_type(super) != MRB_TT_CLASS) { - mrb_raise(mrb, E_TYPE_ERROR, "superclass must be a Class (%s given)", mrb_obj_classname(mrb, super)); + mrb_raisef(mrb, E_TYPE_ERROR, "superclass must be a Class (%s given)", mrb_obj_classname(mrb, super)); } s = mrb_class_ptr(super); } @@ -205,7 +205,7 @@ class_from_sym(mrb_state *mrb, struct RClass *klass, mrb_sym id) mrb_value c = mrb_const_get(mrb, mrb_obj_value(klass), id); if (mrb_type(c) != MRB_TT_MODULE && mrb_type(c) != MRB_TT_CLASS) { - mrb_raise(mrb, E_TYPE_ERROR, "%s is not a class/module", mrb_sym2name(mrb, id)); + mrb_raisef(mrb, E_TYPE_ERROR, "%s is not a class/module", mrb_sym2name(mrb, id)); } return mrb_class_ptr(c); } @@ -318,7 +318,7 @@ check_type(mrb_state *mrb, mrb_value val, enum mrb_vtype t, const char *c, const tmp = mrb_check_convert_type(mrb, val, t, c, m); if (mrb_nil_p(tmp)) { - mrb_raise(mrb, E_TYPE_ERROR, "expected %s", c); + mrb_raisef(mrb, E_TYPE_ERROR, "expected %s", c); } return tmp; } @@ -618,7 +618,7 @@ mrb_get_args(mrb_state *mrb, const char *format, ...) } break; default: - mrb_raise(mrb, E_ARGUMENT_ERROR, "invalide argument specifier %c", c); + mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalide argument specifier %c", c); break; } } @@ -852,7 +852,7 @@ mrb_method_search(mrb_state *mrb, struct RClass* c, mrb_sym mid) m = mrb_method_search_vm(mrb, &c, mid); if (!m) { - mrb_raise(mrb, E_NOMETHOD_ERROR, "no method named %s\n", mrb_sym2name(mrb, mid)); + mrb_raisef(mrb, E_NOMETHOD_ERROR, "no method named %s\n", mrb_sym2name(mrb, mid)); } return m; } @@ -1008,7 +1008,7 @@ mrb_bob_missing(mrb_state *mrb, mrb_value mod) if (!SYMBOL_P(name)) { mrb_raise(mrb, E_TYPE_ERROR, "name should be a symbol"); } - mrb_raise(mrb, E_NOMETHOD_ERROR, "no method named %s", mrb_sym2name(mrb, mrb_symbol(name))); + mrb_raisef(mrb, E_NOMETHOD_ERROR, "no method named %s", mrb_sym2name(mrb, mrb_symbol(name))); /* not reached */ return mrb_nil_value(); } @@ -1105,7 +1105,7 @@ void mrb_check_inheritable(mrb_state *mrb, struct RClass *super) { if (super->tt != MRB_TT_CLASS) { - mrb_raise(mrb, E_TYPE_ERROR, "superclass must be a Class (%s given)", + mrb_raisef(mrb, E_TYPE_ERROR, "superclass must be a Class (%s given)", mrb_obj_classname(mrb, mrb_obj_value(super))); } if (super->tt == MRB_TT_SCLASS) { @@ -1323,7 +1323,7 @@ mrb_sym_value(mrb_state *mrb, mrb_value val) } else if(mrb_type(val) != MRB_TT_SYMBOL) { mrb_value obj = mrb_funcall(mrb, val, "inspect", 0); - mrb_raise(mrb, E_TYPE_ERROR, "%s is not a symbol", + mrb_raisef(mrb, E_TYPE_ERROR, "%s is not a symbol", mrb_string_value_ptr(mrb, obj)); } return mrb_symbol(val); diff --git a/src/error.c b/src/error.c index 5570d35f9..858c70820 100644 --- a/src/error.c +++ b/src/error.c @@ -217,7 +217,15 @@ mrb_exc_raise(mrb_state *mrb, mrb_value exc) } void -mrb_raise(mrb_state *mrb, struct RClass *c, const char *fmt, ...) +mrb_raise(mrb_state *mrb, struct RClass *c, const char *msg) +{ + mrb_value mesg; + mesg = mrb_str_new2(mrb, msg); + mrb_exc_raise(mrb, mrb_exc_new3(mrb, c, mesg)); +} + +void +mrb_raisef(mrb_state *mrb, struct RClass *c, const char *fmt, ...) { va_list args; char buf[256]; @@ -369,7 +377,7 @@ exception_call: break; default: - mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong number of arguments (%d for 0..3)", argc); + mrb_raisef(mrb, E_ARGUMENT_ERROR, "wrong number of arguments (%d for 0..3)", argc); break; } if (argc > 0) { @@ -391,7 +399,7 @@ mrb_make_exception(mrb_state *mrb, int argc, mrb_value *argv) void mrb_sys_fail(mrb_state *mrb, const char *mesg) { - mrb_raise(mrb, E_RUNTIME_ERROR, "%s", mesg); + mrb_raise(mrb, E_RUNTIME_ERROR, mesg); } void diff --git a/src/etc.c b/src/etc.c index 7dfa044f6..c38f2a0bc 100644 --- a/src/etc.c +++ b/src/etc.c @@ -44,7 +44,7 @@ mrb_check_datatype(mrb_state *mrb, mrb_value obj, const struct mrb_data_type *ty } if (DATA_TYPE(obj) != type) { const char *etype = DATA_TYPE(obj)->struct_name; - mrb_raise(mrb, E_TYPE_ERROR, mesg, etype, type->struct_name); + mrb_raisef(mrb, E_TYPE_ERROR, mesg, etype, type->struct_name); } return DATA_PTR(obj); } @@ -94,7 +94,7 @@ mrb_to_id(mrb_state *mrb, mrb_value name) tmp = mrb_check_string_type(mrb, name); if (mrb_nil_p(tmp)) { tmp = mrb_inspect(mrb, name); - mrb_raise(mrb, E_TYPE_ERROR, "%s is not a symbol", + mrb_raisef(mrb, E_TYPE_ERROR, "%s is not a symbol", RSTRING_PTR(tmp)); } name = tmp; diff --git a/src/kernel.c b/src/kernel.c index 43820173c..050dd73bc 100644 --- a/src/kernel.c +++ b/src/kernel.c @@ -348,7 +348,7 @@ mrb_obj_clone(mrb_state *mrb, mrb_value self) struct RObject *clone; if (mrb_special_const_p(self)) { - mrb_raise(mrb, E_TYPE_ERROR, "can't clone %s", mrb_obj_classname(mrb, self)); + mrb_raisef(mrb, E_TYPE_ERROR, "can't clone %s", mrb_obj_classname(mrb, self)); } clone = (struct RObject*)mrb_obj_alloc(mrb, mrb_type(self), mrb_obj_class(mrb, self)); clone->c = mrb_singleton_class_clone(mrb, self); @@ -383,7 +383,7 @@ mrb_obj_dup(mrb_state *mrb, mrb_value obj) mrb_value dup; if (mrb_special_const_p(obj)) { - mrb_raise(mrb, E_TYPE_ERROR, "can't dup %s", mrb_obj_classname(mrb, obj)); + mrb_raisef(mrb, E_TYPE_ERROR, "can't dup %s", mrb_obj_classname(mrb, obj)); } p = mrb_obj_alloc(mrb, mrb_type(obj), mrb_obj_class(mrb, obj)); dup = mrb_obj_value(p); diff --git a/src/numeric.c b/src/numeric.c index 284d0a82e..102e52827 100644 --- a/src/numeric.c +++ b/src/numeric.c @@ -950,7 +950,7 @@ static mrb_value lshift(mrb_state *mrb, mrb_int val, unsigned long width) { if (width > (sizeof(mrb_int)*CHAR_BIT-1)) { - mrb_raise(mrb, E_RANGE_ERROR, "width(%d) > (%d:sizeof(mrb_int)*CHAR_BIT-1)", width, + mrb_raisef(mrb, E_RANGE_ERROR, "width(%d) > (%d:sizeof(mrb_int)*CHAR_BIT-1)", width, sizeof(mrb_int)*CHAR_BIT-1); } val = val << width; @@ -1164,7 +1164,7 @@ mrb_fix2str(mrb_state *mrb, mrb_value x, int base) int neg = 0; if (base < 2 || 36 < base) { - mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid radix %d", base); + mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid radix %d", base); } if (val == 0) { return mrb_str_new(mrb, "0", 1); diff --git a/src/object.c b/src/object.c index 093e8fd2b..a23e397f6 100644 --- a/src/object.c +++ b/src/object.c @@ -305,7 +305,7 @@ convert_type(mrb_state *mrb, mrb_value val, const char *tname, const char *metho m = mrb_intern(mrb, method); if (!mrb_respond_to(mrb, val, m)) { if (raise) { - mrb_raise(mrb, E_TYPE_ERROR, "can't convert %s into %s", + mrb_raisef(mrb, E_TYPE_ERROR, "can't convert %s into %s", mrb_nil_p(val) ? "nil" : (mrb_type(val) == MRB_TT_TRUE) ? "true" : (mrb_type(val) == MRB_TT_FALSE) ? "false" : @@ -341,7 +341,7 @@ mrb_convert_type(mrb_state *mrb, mrb_value val, mrb_int type, const char *tname, if (mrb_type(val) == type) return val; v = convert_type(mrb, val, tname, method, 1/*Qtrue*/); if (mrb_type(v) != type) { - mrb_raise(mrb, E_TYPE_ERROR, "%s cannot be converted to %s by #%s", + mrb_raisef(mrb, E_TYPE_ERROR, "%s cannot be converted to %s by #%s", mrb_obj_classname(mrb, val), tname, method); } return v; @@ -419,12 +419,12 @@ mrb_check_type(mrb_state *mrb, mrb_value x, enum mrb_vtype t) else { etype = mrb_obj_classname(mrb, x); } - mrb_raise(mrb, E_TYPE_ERROR, "wrong argument type %s (expected %s)", + mrb_raisef(mrb, E_TYPE_ERROR, "wrong argument type %s (expected %s)", etype, type->name); } type++; } - mrb_raise(mrb, E_TYPE_ERROR, "unknown type 0x%x (0x%x given)", t, mrb_type(x)); + mrb_raisef(mrb, E_TYPE_ERROR, "unknown type 0x%x (0x%x given)", t, mrb_type(x)); } } @@ -513,7 +513,7 @@ mrb_to_integer(mrb_state *mrb, mrb_value val, const char *method) v = convert_type(mrb, val, "Integer", method, TRUE); if (!mrb_obj_is_kind_of(mrb, v, mrb->fixnum_class)) { const char *cname = mrb_obj_classname(mrb, val); - mrb_raise(mrb, E_TYPE_ERROR, "can't convert %s to Integer (%s#%s gives %s)", + mrb_raisef(mrb, E_TYPE_ERROR, "can't convert %s to Integer (%s#%s gives %s)", cname, cname, method, mrb_obj_classname(mrb, v)); } return v; diff --git a/src/range.c b/src/range.c index cdcfcca53..6fe7964fe 100644 --- a/src/range.c +++ b/src/range.c @@ -296,7 +296,7 @@ mrb_range_beg_len(mrb_state *mrb, mrb_value range, mrb_int *begp, mrb_int *lenp, out_of_range: if (err) { - mrb_raise(mrb, E_RANGE_ERROR, "%ld..%s%ld out of range", + mrb_raisef(mrb, E_RANGE_ERROR, "%ld..%s%ld out of range", b, r->excl? "." : "", e); } return OTHER; diff --git a/src/sprintf.c b/src/sprintf.c index eccbff04d..2bd72ffc6 100644 --- a/src/sprintf.c +++ b/src/sprintf.c @@ -81,7 +81,7 @@ mrb_fix2binstr(mrb_state *mrb, mrb_value x, int base) char d; if (base != 2) { - mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid radix %d", base); + mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid radix %d", base); } if (val >= (1 << 10)) @@ -146,17 +146,17 @@ mrb_fix2binstr(mrb_state *mrb, mrb_value x, int base) #define GETARG() (!mrb_undef_p(nextvalue) ? nextvalue : \ posarg == -1 ? \ - (mrb_raise(mrb, E_ARGUMENT_ERROR, "unnumbered(%d) mixed with numbered", nextarg), mrb_undef_value()) : \ + (mrb_raisef(mrb, E_ARGUMENT_ERROR, "unnumbered(%d) mixed with numbered", nextarg), mrb_undef_value()) : \ posarg == -2 ? \ - (mrb_raise(mrb, E_ARGUMENT_ERROR, "unnumbered(%d) mixed with named", nextarg), mrb_undef_value()) : \ + (mrb_raisef(mrb, E_ARGUMENT_ERROR, "unnumbered(%d) mixed with named", nextarg), mrb_undef_value()) : \ (posarg = nextarg++, GETNTHARG(posarg))) #define GETPOSARG(n) (posarg > 0 ? \ - (mrb_raise(mrb, E_ARGUMENT_ERROR, "numbered(%d) after unnumbered(%d)", n, posarg), mrb_undef_value()) : \ + (mrb_raisef(mrb, E_ARGUMENT_ERROR, "numbered(%d) after unnumbered(%d)", n, posarg), mrb_undef_value()) : \ posarg == -2 ? \ - (mrb_raise(mrb, E_ARGUMENT_ERROR, "numbered(%d) after named", n), mrb_undef_value()) : \ + (mrb_raisef(mrb, E_ARGUMENT_ERROR, "numbered(%d) after named", n), mrb_undef_value()) : \ ((n < 1) ? \ - (mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid index - %d$", n), mrb_undef_value()) : \ + (mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid index - %d$", n), mrb_undef_value()) : \ (posarg = -1, GETNTHARG(n)))) #define GETNTHARG(nth) \ @@ -164,9 +164,9 @@ mrb_fix2binstr(mrb_state *mrb, mrb_value x, int base) #define GETNAMEARG(id, name, len) ( \ posarg > 0 ? \ - (mrb_raise(mrb, E_ARGUMENT_ERROR, "named%.*s after unnumbered(%d)", (len), (name), posarg), mrb_undef_value()) : \ + (mrb_raisef(mrb, E_ARGUMENT_ERROR, "named%.*s after unnumbered(%d)", (len), (name), posarg), mrb_undef_value()) : \ posarg == -1 ? \ - (mrb_raise(mrb, E_ARGUMENT_ERROR, "named%.*s after numbered", (len), (name)), mrb_undef_value()) : \ + (mrb_raisef(mrb, E_ARGUMENT_ERROR, "named%.*s after numbered", (len), (name)), mrb_undef_value()) : \ (posarg = -2, mrb_hash_fetch(mrb, get_hash(mrb, &hash, argc, argv), id, mrb_undef_value()))) #define GETNUM(n, val) \ @@ -178,7 +178,7 @@ mrb_fix2binstr(mrb_state *mrb, mrb_value x, int base) n = next_n; \ } \ if (p >= end) { \ - mrb_raise(mrb, E_ARGUMENT_ERROR, "malformed format string - %%*[0-9]"); \ + mrb_raise(mrb, E_ARGUMENT_ERROR, "malformed format string - %*[0-9]"); \ } #define GETASTER(num) do { \ @@ -548,7 +548,7 @@ mrb_str_format(mrb_state *mrb, int argc, const mrb_value *argv, mrb_value fmt) retry: switch (*p) { default: - mrb_raise(mrb, E_ARGUMENT_ERROR, "malformed format string - %%%c", *p); + mrb_raisef(mrb, E_ARGUMENT_ERROR, "malformed format string - %%%c", *p); break; case ' ': @@ -587,7 +587,7 @@ retry: GETNUM(n, width); if (*p == '$') { if (!mrb_undef_p(nextvalue)) { - mrb_raise(mrb, E_ARGUMENT_ERROR, "value given twice - %d$", n); + mrb_raisef(mrb, E_ARGUMENT_ERROR, "value given twice - %d$", n); } nextvalue = GETPOSARG(n); p++; @@ -607,14 +607,14 @@ retry: for (; p < end && *p != term; ) p++; if (id) { - mrb_raise(mrb, E_ARGUMENT_ERROR, "name%.*s after <%s>", + mrb_raisef(mrb, E_ARGUMENT_ERROR, "name%.*s after <%s>", (int)(p - start + 1), start, mrb_sym2name(mrb, id)); } symname = mrb_str_new(mrb, start + 1, p - start - 1); id = mrb_intern_str(mrb, symname); nextvalue = GETNAMEARG(mrb_symbol_value(id), start, (int)(p - start + 1)); if (mrb_undef_p(nextvalue)) { - mrb_raise(mrb, E_KEY_ERROR, "key%.*s not found", (int)(p - start + 1), start); + mrb_raisef(mrb, E_KEY_ERROR, "key%.*s not found", (int)(p - start + 1), start); } if (term == '}') goto format_s; p++; @@ -658,7 +658,7 @@ retry: case '%': if (flags != FNONE) { - mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid format character - %%"); + mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid format character - %"); } PUSH("%", 1); break; @@ -1052,7 +1052,7 @@ retry: */ if (posarg >= 0 && nextarg < argc) { const char *mesg = "too many arguments for format string"; - if (RTEST(ruby_debug)) mrb_raise(mrb, E_ARGUMENT_ERROR, "%s", mesg); + if (RTEST(ruby_debug)) mrb_raise(mrb, E_ARGUMENT_ERROR, mesg); if (RTEST(ruby_verbose)) mrb_warn("%s", mesg); } mrb_str_resize(mrb, result, blen); diff --git a/src/string.c b/src/string.c index 11e760ca1..f3ceb6d96 100644 --- a/src/string.c +++ b/src/string.c @@ -840,7 +840,7 @@ mrb_str_aref_m(mrb_state *mrb, mrb_value str) return mrb_str_substr(mrb, str, mrb_fixnum(a1), mrb_fixnum(a2)); } if (argc != 1) { - mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong number of arguments (%d for 1)", argc); + mrb_raisef(mrb, E_ARGUMENT_ERROR, "wrong number of arguments (%d for 1)", argc); } return mrb_str_aref(mrb, str, a1); } @@ -1525,7 +1525,7 @@ mrb_str_index_m(mrb_state *mrb, mrb_value str) tmp = mrb_check_string_type(mrb, sub); if (mrb_nil_p(tmp)) { - mrb_raise(mrb, E_TYPE_ERROR, "type mismatch: %s given", + mrb_raisef(mrb, E_TYPE_ERROR, "type mismatch: %s given", mrb_obj_classname(mrb, sub)); } sub = tmp; @@ -1931,7 +1931,7 @@ mrb_str_rindex_m(mrb_state *mrb, mrb_value str) tmp = mrb_check_string_type(mrb, sub); if (mrb_nil_p(tmp)) { - mrb_raise(mrb, E_TYPE_ERROR, "type mismatch: %s given", + mrb_raisef(mrb, E_TYPE_ERROR, "type mismatch: %s given", mrb_obj_classname(mrb, sub)); } sub = tmp; @@ -2466,7 +2466,7 @@ mrb_cstr_to_inum(mrb_state *mrb, const char *str, int base, int badcheck) break; default: if (base < 2 || 36 < base) { - mrb_raise(mrb, E_ARGUMENT_ERROR, "illegal radix %d", base); + mrb_raisef(mrb, E_ARGUMENT_ERROR, "illegal radix %d", base); } if (base <= 32) { len = 5; @@ -2510,7 +2510,7 @@ mrb_cstr_to_inum(mrb_state *mrb, const char *str, int base, int badcheck) return mrb_fixnum_value(result); } bad: - mrb_raise(mrb, E_ARGUMENT_ERROR, "invalide string for number(%s)", str); + mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalide string for number(%s)", str); /* not reached */ return mrb_fixnum_value(0); } @@ -2589,7 +2589,7 @@ mrb_str_to_i(mrb_state *mrb, mrb_value self) base = mrb_fixnum(argv[0]); if (base < 0) { - mrb_raise(mrb, E_ARGUMENT_ERROR, "illegal radix %d", base); + mrb_raisef(mrb, E_ARGUMENT_ERROR, "illegal radix %d", base); } return mrb_str_to_inum(mrb, self, base, 0/*Qfalse*/); } @@ -2620,7 +2620,7 @@ mrb_cstr_to_dbl(mrb_state *mrb, const char * p, int badcheck) if (p == end) { if (badcheck) { bad: - mrb_raise(mrb, E_ARGUMENT_ERROR, "invalide string for float(%s)", p); + mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalide string for float(%s)", p); /* not reached */ } return d; diff --git a/src/struct.c b/src/struct.c index 64f0e8a4a..2a391d0b1 100644 --- a/src/struct.c +++ b/src/struct.c @@ -70,7 +70,7 @@ mrb_struct_members(mrb_state *mrb, mrb_value s) mrb_value members = mrb_struct_s_members(mrb, mrb_obj_value(mrb_obj_class(mrb, s))); if (mrb_type(s) == MRB_TT_STRUCT) { if (RSTRUCT_LEN(s) != RARRAY_LEN(members)) { - mrb_raise(mrb, E_TYPE_ERROR, "struct size differs (%ld required %ld given)", + mrb_raisef(mrb, E_TYPE_ERROR, "struct size differs (%ld required %ld given)", RARRAY_LEN(members), RSTRUCT_LEN(s)); } } @@ -595,10 +595,10 @@ mrb_struct_aref_n(mrb_state *mrb, mrb_value s, mrb_value idx) i = mrb_fixnum(idx); if (i < 0) i = RSTRUCT_LEN(s) + i; if (i < 0) - mrb_raise(mrb, E_INDEX_ERROR, "offset %ld too small for struct(size:%ld)", + mrb_raisef(mrb, E_INDEX_ERROR, "offset %ld too small for struct(size:%ld)", i, RSTRUCT_LEN(s)); if (RSTRUCT_LEN(s) <= i) - mrb_raise(mrb, E_INDEX_ERROR, "offset %ld too large for struct(size:%ld)", + mrb_raisef(mrb, E_INDEX_ERROR, "offset %ld too large for struct(size:%ld)", i, RSTRUCT_LEN(s)); return RSTRUCT_PTR(s)[i]; } @@ -622,7 +622,7 @@ mrb_struct_aset_id(mrb_state *mrb, mrb_value s, mrb_sym id, mrb_value val) len = RARRAY_LEN(members); mrb_struct_modify(s); if (RSTRUCT_LEN(s) != len) { - mrb_raise(mrb, E_TYPE_ERROR, "struct size differs (%ld required %ld given)", + mrb_raisef(mrb, E_TYPE_ERROR, "struct size differs (%ld required %ld given)", len, RSTRUCT_LEN(s)); } ptr = RSTRUCT_PTR(s); @@ -675,11 +675,11 @@ mrb_struct_aset(mrb_state *mrb, mrb_value s) i = mrb_fixnum(idx); if (i < 0) i = RSTRUCT_LEN(s) + i; if (i < 0) { - mrb_raise(mrb, E_INDEX_ERROR, "offset %ld too small for struct(size:%ld)", + mrb_raisef(mrb, E_INDEX_ERROR, "offset %ld too small for struct(size:%ld)", i, RSTRUCT_LEN(s)); } if (RSTRUCT_LEN(s) <= i) { - mrb_raise(mrb, E_INDEX_ERROR, "offset %ld too large for struct(size:%ld)", + mrb_raisef(mrb, E_INDEX_ERROR, "offset %ld too large for struct(size:%ld)", i, RSTRUCT_LEN(s)); } mrb_struct_modify(s); diff --git a/src/variable.c b/src/variable.c index 74dfc02c9..e3e4c4fb5 100644 --- a/src/variable.c +++ b/src/variable.c @@ -712,7 +712,7 @@ const_get(mrb_state *mrb, struct RClass *base, mrb_sym sym) } c = c->super; } - mrb_raise(mrb, E_NAME_ERROR, "uninitialized constant %s", + mrb_raisef(mrb, E_NAME_ERROR, "uninitialized constant %s", mrb_sym2name(mrb, sym)); /* not reached */ return mrb_nil_value(); diff --git a/src/vm.c b/src/vm.c index b580df5a5..693e2413a 100644 --- a/src/vm.c +++ b/src/vm.c @@ -236,7 +236,7 @@ mrb_funcall(mrb_state *mrb, mrb_value self, const char *name, int argc, ...) mrb_value argv[MRB_FUNCALL_ARGC_MAX]; if (argc > MRB_FUNCALL_ARGC_MAX) { - mrb_raise(mrb, E_ARGUMENT_ERROR, "Too long arguments. (limit=%d)", MRB_FUNCALL_ARGC_MAX); + mrb_raisef(mrb, E_ARGUMENT_ERROR, "Too long arguments. (limit=%d)", MRB_FUNCALL_ARGC_MAX); } va_start(ap, argc); @@ -277,7 +277,7 @@ mrb_funcall_with_block(mrb_state *mrb, mrb_value self, mrb_sym mid, int argc, mr } n = mrb->ci->nregs; if (argc < 0) { - mrb_raise(mrb, E_ARGUMENT_ERROR, "negative argc for funcall (%d)", argc); + mrb_raisef(mrb, E_ARGUMENT_ERROR, "negative argc for funcall (%d)", argc); } c = mrb_class(mrb, self); p = mrb_method_search_vm(mrb, &c, mid); -- cgit v1.2.3 From 413528ce803135dd63423047accaea142c283fcd Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Tue, 23 Oct 2012 11:35:26 +0900 Subject: adjust regsiter stack for NODE_OP_ASGN; close #499 --- src/codegen.c | 1 + 1 file changed, 1 insertion(+) diff --git a/src/codegen.c b/src/codegen.c index 1f087b2cd..df5bc2acf 100644 --- a/src/codegen.c +++ b/src/codegen.c @@ -1403,6 +1403,7 @@ codegen(codegen_scope *s, node *tree, int val) codegen(s, tree->cdr->cdr->car, VAL); pop(); gen_assignment(s, tree->car, cursp(), val); + if (val) pop(); dispatch(s, pos); break; } -- cgit v1.2.3 From 09376f9b2a6ce2c56f5a4fc7abb88ea4e68c59e3 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Tue, 23 Oct 2012 14:14:26 +0900 Subject: skip useless OP_MOVE in peephole optimization --- src/codegen.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/codegen.c b/src/codegen.c index df5bc2acf..b0e6f8fd1 100644 --- a/src/codegen.c +++ b/src/codegen.c @@ -170,6 +170,10 @@ genop_peep(codegen_scope *s, mrb_code i, int val) switch (c1) { case OP_MOVE: + if (GETARG_A(i) == GETARG_B(i)) { + /* skip useless OP_MOVE */ + return; + } if (val) break; switch (c0) { case OP_MOVE: -- cgit v1.2.3 From 32f9cdc97d769554f01543ede73a702e0c973346 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Tue, 23 Oct 2012 14:15:29 +0900 Subject: adjust regsiter stack for NODE_OP_ASGN that use OP_SEND --- src/codegen.c | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/src/codegen.c b/src/codegen.c index b0e6f8fd1..2d01ed701 100644 --- a/src/codegen.c +++ b/src/codegen.c @@ -853,8 +853,11 @@ gen_assignment(codegen_scope *s, node *node, int sp, int val) case NODE_CALL: push(); - gen_call(s, node, attrsym(s, sym(node->cdr->car)), sp, val); - val = NOVAL; /* push should have done in gen_call() */ + gen_call(s, node, attrsym(s, sym(node->cdr->car)), sp, NOVAL); + pop(); + if (val) { + genop_peep(s, MKOP_AB(OP_MOVE, cursp(), sp), val); + } break; default: -- cgit v1.2.3 From 18fbe4d0b74aa6e787b908a5509f834c7a1d6a18 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Tue, 23 Oct 2012 14:16:14 +0900 Subject: do not touch h from Hash when h might be NULL --- src/hash.c | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/src/hash.c b/src/hash.c index 92dfff186..51f85f4e8 100644 --- a/src/hash.c +++ b/src/hash.c @@ -970,9 +970,10 @@ mrb_hash_keys(mrb_state *mrb, mrb_value hash) { khash_t(ht) *h = RHASH_TBL(hash); khiter_t k; - mrb_value ary = mrb_ary_new_capa(mrb, kh_size(h)); + mrb_value ary; - if (!h) return ary; + if (!h) return mrb_ary_new(mrb); + ary = mrb_ary_new_capa(mrb, kh_size(h)); for (k = kh_begin(h); k != kh_end(h); k++) { if (kh_exist(h, k)) { mrb_value v = kh_key(h,k); @@ -1000,9 +1001,10 @@ mrb_hash_values(mrb_state *mrb, mrb_value hash) { khash_t(ht) *h = RHASH_TBL(hash); khiter_t k; - mrb_value ary = mrb_ary_new_capa(mrb, kh_size(h)); + mrb_value ary; - if (!h) return ary; + if (!h) return mrb_ary_new(mrb); + ary = mrb_ary_new_capa(mrb, kh_size(h)); for (k = kh_begin(h); k != kh_end(h); k++) { if (kh_exist(h, k)){ mrb_value v = kh_value(h,k); -- cgit v1.2.3 From 52d39e6224382e669b959cf020164d6bb90b9844 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Tue, 23 Oct 2012 19:01:37 +0900 Subject: prevent resource leak (outfile) --- tools/mrbc/mrbc.c | 51 ++++++++++++++++++++++++++++----------------------- 1 file changed, 28 insertions(+), 23 deletions(-) diff --git a/tools/mrbc/mrbc.c b/tools/mrbc/mrbc.c index 3c6352f80..2ecb00623 100644 --- a/tools/mrbc/mrbc.c +++ b/tools/mrbc/mrbc.c @@ -70,6 +70,7 @@ parse_args(mrb_state *mrb, int argc, char **argv, struct _args *args) char *infile = NULL; char *outfile = NULL; char **origargv = argv; + int result = 0; static const struct _args args_zero = { 0 }; *args = args_zero; @@ -93,7 +94,8 @@ parse_args(mrb_state *mrb, int argc, char **argv, struct _args *args) args->initname = (*argv) + 2; if (*args->initname == '\0') { printf("%s: Function name is not specified.\n", *origargv); - return -2; + result = -2; + goto exit; } args->dump_type = ((*argv)[1] == 'B') ? DUMP_TYPE_BIN : DUMP_TYPE_CODE; break; @@ -117,8 +119,8 @@ parse_args(mrb_state *mrb, int argc, char **argv, struct _args *args) mrb_show_copyright(mrb); exit(0); } - else return -3; - return 0; + result = -3; + goto exit; default: break; } @@ -127,33 +129,36 @@ parse_args(mrb_state *mrb, int argc, char **argv, struct _args *args) args->filename = infile = *argv; if ((args->rfp = fopen(infile, "r")) == NULL) { printf("%s: Cannot open program file. (%s)\n", *origargv, infile); - return 0; + goto exit; } } } - if (infile == NULL) - return -4; - if (args->check_syntax) - return 0; - - if (outfile == NULL) { - if (strcmp("-", infile) == 0) { - outfile = infile; + if (infile == NULL) { + result = -4; + goto exit; + } + if (!args->check_syntax) { + if (outfile == NULL) { + if (strcmp("-", infile) == 0) { + outfile = infile; + } + else { + outfile = get_outfilename(infile, args->ext); + } } - else { - outfile = get_outfilename(infile, args->ext); + if (strcmp("-", outfile) == 0) { + args->wfp = stdout; + } + else if ((args->wfp = fopen(outfile, "wb")) == NULL) { + printf("%s: Cannot open output file. (%s)\n", *origargv, outfile); + result = -1; + goto exit; } } - if (strcmp("-", outfile) == 0) { - args->wfp = stdout; - } - else if ((args->wfp = fopen(outfile, "wb")) == NULL) { - printf("%s: Cannot open output file. (%s)\n", *origargv, outfile); - return 0; - } - - return 0; + exit: + if (outfile && infile != outfile) free(outfile); + return result; } static void -- cgit v1.2.3 From 1933e2660c86c0731806993a9a212116bb454622 Mon Sep 17 00:00:00 2001 From: Masaki Muranaka Date: Wed, 24 Oct 2012 17:00:54 +0900 Subject: Use substitution instead of memset in structure initialization. --- include/mruby/data.h | 2 +- src/codegen.c | 8 ++++++-- src/gc.c | 3 ++- src/load.c | 8 ++++++-- src/parse.y | 3 ++- src/proc.c | 3 ++- src/state.c | 8 ++++++-- src/vm.c | 9 +++++---- 8 files changed, 30 insertions(+), 14 deletions(-) diff --git a/include/mruby/data.h b/include/mruby/data.h index ad91e0044..b9bedb3f9 100644 --- a/include/mruby/data.h +++ b/include/mruby/data.h @@ -30,7 +30,7 @@ struct RData *mrb_data_object_alloc(mrb_state *mrb, struct RClass* klass, void * #define Data_Make_Struct(mrb,klass,strct,type,sval) (\ sval = mrb_malloc(mrb, sizeof(strct)),\ - memset(sval, 0, sizeof(strct)),\ + { static const strct zero = { 0 }; *sval = zero},\ Data_Wrap_Struct(mrb,klass,type,sval)\ ) diff --git a/src/codegen.c b/src/codegen.c index 2d01ed701..7c3182599 100644 --- a/src/codegen.c +++ b/src/codegen.c @@ -453,7 +453,10 @@ new_sym(codegen_scope *s, mrb_sym sym) } if (s->slen > 125 && s->slen < 256) { s->syms = (mrb_sym *)codegen_realloc(s, s->syms, sizeof(mrb_sym)*65536); - memset(s->syms+s->slen, 0, sizeof(mrb_sym)*(256-s->slen)); + for (i = 0; i < 256 - s->slen; i++) { + static const mrb_sym mrb_sym_zero = { 0 }; + s->syms[i + s->slen] = mrb_sym_zero; + } s->slen = 256; } s->syms[s->slen] = sym; @@ -2049,11 +2052,12 @@ codegen(codegen_scope *s, node *tree, int val) static codegen_scope* scope_new(mrb_state *mrb, codegen_scope *prev, node *lv) { + static const codegen_scope codegen_scope_zero = { 0 }; mrb_pool *pool = mrb_pool_open(mrb); codegen_scope *p = (codegen_scope *)mrb_pool_alloc(pool, sizeof(codegen_scope)); if (!p) return 0; - memset(p, 0, sizeof(codegen_scope)); + *p = codegen_scope_zero; p->mrb = mrb; p->mpool = pool; if (!prev) return p; diff --git a/src/gc.c b/src/gc.c index 46699aea3..d92a231b8 100644 --- a/src/gc.c +++ b/src/gc.c @@ -326,6 +326,7 @@ struct RBasic* mrb_obj_alloc(mrb_state *mrb, enum mrb_vtype ttype, struct RClass *cls) { struct RBasic *p; + static const RVALUE RVALUE_zero = { 0 }; #ifdef MRB_GC_STRESS mrb_garbage_collect(mrb); @@ -345,7 +346,7 @@ mrb_obj_alloc(mrb_state *mrb, enum mrb_vtype ttype, struct RClass *cls) mrb->live++; gc_protect(mrb, p); - memset(p, 0, sizeof(RVALUE)); + *(RVALUE *)p = RVALUE_zero; p->tt = ttype; p->c = cls; paint_partial_white(mrb, p); diff --git a/src/load.c b/src/load.c index a2ae4100b..751c2619b 100644 --- a/src/load.c +++ b/src/load.c @@ -448,7 +448,10 @@ read_rite_irep_record(mrb_state *mrb, unsigned char *src, mrb_irep *irep, uint32 goto error_exit; } - memset(irep->syms, 0, sizeof(mrb_sym)*(irep->slen)); + for (i = 0; i < irep->slen; i++) { + static const mrb_sym mrb_sym_zero = { 0 }; + *irep->syms = mrb_sym_zero; + } for (i=0; islen; i++) { snl = bin_to_uint16(src); //symbol name length src += MRB_DUMP_SIZE_OF_SHORT; @@ -509,11 +512,12 @@ mrb_read_irep(mrb_state *mrb, const char *bin) mrb_add_irep(mrb, sirep + nirep); for (n=0,i=sirep; nirep[i] = (mrb_irep *)mrb_malloc(mrb, sizeof(mrb_irep))) == NULL) { ret = MRB_DUMP_GENERAL_FAILURE; goto error_exit; } - memset(mrb->irep[i], 0, sizeof(mrb_irep)); + *mrb->irep[i] = mrb_irep_zero; } src += sizeof(bin_header) + MRB_DUMP_SIZE_OF_SHORT; //header + crc diff --git a/src/parse.y b/src/parse.y index b903ac840..cffb6ba09 100644 --- a/src/parse.y +++ b/src/parse.y @@ -4747,13 +4747,14 @@ mrb_parser_new(mrb_state *mrb) { mrb_pool *pool; parser_state *p; + static const parser_state parser_state_zero = { 0 }; pool = mrb_pool_open(mrb); if (!pool) return 0; p = (parser_state *)mrb_pool_alloc(pool, sizeof(parser_state)); if (!p) return 0; - memset(p, 0, sizeof(parser_state)); + *p = parser_state_zero; p->mrb = mrb; p->pool = pool; p->in_def = p->in_single = 0; diff --git a/src/proc.c b/src/proc.c index 3321c2a91..07834e86d 100644 --- a/src/proc.c +++ b/src/proc.c @@ -149,11 +149,12 @@ mrb_init_proc(mrb_state *mrb) { struct RProc *m; mrb_irep *call_irep = (mrb_irep *)mrb_alloca(mrb, sizeof(mrb_irep)); + static const mrb_irep mrb_irep_zero = { 0 }; if ( call_iseq == NULL || call_irep == NULL ) return; - memset(call_irep, 0, sizeof(mrb_irep)); + *call_irep = mrb_irep_zero; call_irep->flags = MRB_ISEQ_NO_FREE; call_irep->idx = -1; call_irep->iseq = call_iseq; diff --git a/src/state.c b/src/state.c index 991be310e..8bd222fb5 100644 --- a/src/state.c +++ b/src/state.c @@ -16,10 +16,11 @@ void mrb_init_ext(mrb_state*); mrb_state* mrb_open_allocf(mrb_allocf f, void *ud) { + static const mrb_state mrb_state_zero = { 0 }; mrb_state *mrb = (mrb_state *)(f)(NULL, NULL, sizeof(mrb_state), ud); if (mrb == NULL) return NULL; - memset(mrb, 0, sizeof(mrb_state)); + *mrb = mrb_state_zero; mrb->ud = ud; mrb->allocf = f; mrb->current_white_part = MRB_GC_WHITE_A; @@ -119,12 +120,15 @@ mrb_add_irep(mrb_state *mrb, int idx) mrb->irep_capa = max; } else if (mrb->irep_capa <= idx) { + int i; size_t old_capa = mrb->irep_capa; while (mrb->irep_capa <= idx) { mrb->irep_capa *= 2; } mrb->irep = (mrb_irep **)mrb_realloc(mrb, mrb->irep, sizeof(mrb_irep*)*mrb->irep_capa); - memset(mrb->irep + old_capa, 0, sizeof(mrb_irep*) * (mrb->irep_capa - old_capa)); + for (i = old_capa; i < mrb->irep_capa - old_capa; i++) { + mrb->irep[i] = NULL; + } } } diff --git a/src/vm.c b/src/vm.c index 693e2413a..120e0d4c0 100644 --- a/src/vm.c +++ b/src/vm.c @@ -100,15 +100,16 @@ stack_extend(mrb_state *mrb, int room, int keep) envadjust(mrb, oldbase, mrb->stbase); } if (room > keep) { -#ifndef MRB_NAN_BOXING - memset(mrb->stack+keep, 0, sizeof(mrb_value) * (room-keep)); -#else int i; for (i=keep; istack[i] = mrb_value_zero; +#else SET_NIL_VALUE(mrb->stack[i]); - } #endif + } } } -- cgit v1.2.3 From 559933f577d5073464aa06facc1b754de6225d8a Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Fri, 26 Oct 2012 20:46:02 +0900 Subject: singleton classes should be able to have instance variables; close #509 --- src/variable.c | 1 + 1 file changed, 1 insertion(+) diff --git a/src/variable.c b/src/variable.c index e3e4c4fb5..7f9274ee4 100644 --- a/src/variable.c +++ b/src/variable.c @@ -420,6 +420,7 @@ obj_iv_p(mrb_value obj) case MRB_TT_OBJECT: case MRB_TT_CLASS: case MRB_TT_MODULE: + case MRB_TT_SCLASS: case MRB_TT_HASH: case MRB_TT_DATA: return TRUE; -- cgit v1.2.3 From 15f46a1feba74cba4f25ec99df79a3f1e07b0b09 Mon Sep 17 00:00:00 2001 From: Yuichiro MASUI Date: Sat, 27 Oct 2012 14:26:50 +0900 Subject: define convert method mrb_int/mrb_float with C string --- include/mrbconf.h | 9 ++++++++- src/codegen.c | 4 ++-- src/dump.c | 8 ++++---- src/load.c | 4 ++-- src/numeric.c | 10 +++++----- 5 files changed, 21 insertions(+), 14 deletions(-) diff --git a/include/mrbconf.h b/include/mrbconf.h index 76c1b37f9..841ef1823 100644 --- a/include/mrbconf.h +++ b/include/mrbconf.h @@ -55,19 +55,26 @@ #ifdef MRB_USE_FLOAT typedef float mrb_float; +#define mrb_float_to_str(buf, i) sprintf((buf), "%.7e", (i)) +#define str_to_mrb_float(buf) (mrb_float)strtof((buf),NULL) #else typedef double mrb_float; +#define mrb_float_to_str(buf, i) sprintf((buf), "%.16e", (i)) +#define str_to_mrb_float(buf) (mrb_float)strtod((buf),NULL) #endif -#define readfloat(p) (mrb_float)strtod((p),NULL) #ifdef MRB_NAN_BOXING typedef int32_t mrb_int; #define MRB_INT_MIN INT32_MIN #define MRB_INT_MAX INT32_MAX +#define mrb_int_to_str(buf, i) sprintf((buf), "%d", (i)) +#define str_to_mrb_int(buf) (mrb_int)strtol((buf), NULL, 10); #else typedef int mrb_int; #define MRB_INT_MIN INT_MIN #define MRB_INT_MAX INT_MAX +#define mrb_int_to_str(buf, i) sprintf((buf), "%d", (i)) +#define str_to_mrb_int(buf) (mrb_int)strtol((buf), NULL, 10); #endif typedef short mrb_sym; diff --git a/src/codegen.c b/src/codegen.c index 2d01ed701..9bba9de71 100644 --- a/src/codegen.c +++ b/src/codegen.c @@ -1738,7 +1738,7 @@ codegen(codegen_scope *s, node *tree, int val) case NODE_FLOAT: if (val) { char *p = (char*)tree; - mrb_float f = readfloat(p); + mrb_float f = str_to_mrb_float(p); int off = new_lit(s, mrb_float_value(f)); genop(s, MKOP_ABx(OP_LOADL, cursp(), off)); @@ -1754,7 +1754,7 @@ codegen(codegen_scope *s, node *tree, int val) case NODE_FLOAT: { char *p = (char*)tree; - mrb_float f = readfloat(p); + mrb_float f = str_to_mrb_float(p); int off = new_lit(s, mrb_float_value(-f)); genop(s, MKOP_ABx(OP_LOADL, cursp(), off)); diff --git a/src/dump.c b/src/dump.c index 15e11153e..5100014d9 100644 --- a/src/dump.c +++ b/src/dump.c @@ -226,11 +226,11 @@ get_pool_block_size(mrb_state *mrb, mrb_irep *irep, int type) switch (mrb_type(irep->pool[pool_no])) { case MRB_TT_FIXNUM: - len = sprintf( buf, "%d", mrb_fixnum(irep->pool[pool_no])); + len = mrb_int_to_str( buf, mrb_fixnum(irep->pool[pool_no])); size += (uint32_t)len; break; case MRB_TT_FLOAT: - len = sprintf( buf, "%.16e", mrb_float(irep->pool[pool_no])); + len = mrb_float_to_str( buf, mrb_float(irep->pool[pool_no])); size += (uint32_t)len; break; case MRB_TT_STRING: @@ -346,11 +346,11 @@ write_pool_block(mrb_state *mrb, mrb_irep *irep, char *buf, int type) switch (mrb_type(irep->pool[pool_no])) { case MRB_TT_FIXNUM: - len = sprintf(char_buf, "%d", mrb_fixnum(irep->pool[pool_no])); + len = mrb_int_to_str(char_buf, mrb_fixnum(irep->pool[pool_no])); break; case MRB_TT_FLOAT: - len = sprintf(char_buf, "%.16e", mrb_float(irep->pool[pool_no])); + len = mrb_float_to_str(char_buf, mrb_float(irep->pool[pool_no])); break; case MRB_TT_STRING: diff --git a/src/load.c b/src/load.c index a2ae4100b..1575ffb4d 100644 --- a/src/load.c +++ b/src/load.c @@ -405,12 +405,12 @@ read_rite_irep_record(mrb_state *mrb, unsigned char *src, mrb_irep *irep, uint32 switch (tt) { //pool data case MRB_TT_FIXNUM: - fix_num = strtol(buf, NULL, 10); + fix_num = str_to_mrb_int(buf); irep->pool[i] = mrb_fixnum_value(fix_num); break; case MRB_TT_FLOAT: - f = readfloat(buf); + f = str_to_mrb_float(buf); irep->pool[i] = mrb_float_value(f); break; diff --git a/src/numeric.c b/src/numeric.c index 102e52827..c1491ac51 100644 --- a/src/numeric.c +++ b/src/numeric.c @@ -246,8 +246,8 @@ flodivmod(mrb_state *mrb, mrb_float x, mrb_float y, mrb_float *divp, mrb_float * mrb_float div, mod; if (y == 0.0) { - *divp = strtod("inf", NULL); - *modp = strtod("nan", NULL); + *divp = str_to_mrb_float("inf"); + *modp = str_to_mrb_float("nan"); return; } mod = fmod(x, y); @@ -778,7 +778,7 @@ fix_mod(mrb_state *mrb, mrb_value x) mrb_int mod; if (mrb_fixnum(y) == 0) { - return mrb_float_value(strtod("nan", NULL)); + return mrb_float_value(str_to_mrb_float("nan")); } fixdivmod(mrb, a, mrb_fixnum(y), 0, &mod); return mrb_fixnum_value(mod); @@ -807,8 +807,8 @@ fix_divmod(mrb_state *mrb, mrb_value x) mrb_int div, mod; if (mrb_fixnum(y) == 0) { - return mrb_assoc_new(mrb, mrb_float_value(strtod("inf", NULL)), - mrb_float_value(strtod("nan", NULL))); + return mrb_assoc_new(mrb, mrb_float_value(str_to_mrb_float("inf")), + mrb_float_value(str_to_mrb_float("nan"))); } fixdivmod(mrb, mrb_fixnum(x), mrb_fixnum(y), &div, &mod); return mrb_assoc_new(mrb, mrb_fixnum_value(div), mrb_fixnum_value(mod)); -- cgit v1.2.3 From e407022b10505dd01da5829cfe9b2d978d266e64 Mon Sep 17 00:00:00 2001 From: Akira Yumiyama Date: Sun, 28 Oct 2012 20:20:13 +0900 Subject: change the error message (NoMethodError, NameError) --- src/class.c | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/src/class.c b/src/class.c index c4058ad67..3e54afede 100644 --- a/src/class.c +++ b/src/class.c @@ -852,7 +852,9 @@ mrb_method_search(mrb_state *mrb, struct RClass* c, mrb_sym mid) m = mrb_method_search_vm(mrb, &c, mid); if (!m) { - mrb_raisef(mrb, E_NOMETHOD_ERROR, "no method named %s\n", mrb_sym2name(mrb, mid)); + mrb_raisef(mrb, E_NAME_ERROR, "undefined method '%s' for class %s", + mrb_sym2name(mrb, mid), + RSTRING_PTR(mrb_funcall(mrb, mrb_obj_value(c), "inspect", 0))); } return m; } @@ -1008,7 +1010,9 @@ mrb_bob_missing(mrb_state *mrb, mrb_value mod) if (!SYMBOL_P(name)) { mrb_raise(mrb, E_TYPE_ERROR, "name should be a symbol"); } - mrb_raisef(mrb, E_NOMETHOD_ERROR, "no method named %s", mrb_sym2name(mrb, mrb_symbol(name))); + mrb_raisef(mrb, E_NOMETHOD_ERROR, "undefined method '%s' for %s", + mrb_sym2name(mrb, mrb_symbol(name)), + RSTRING_PTR(mrb_funcall(mrb, mod, "inspect", 0))); /* not reached */ return mrb_nil_value(); } -- cgit v1.2.3 From cfc1269d334a04a5dfb8a9b397c5716fe2ccffc1 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Mon, 29 Oct 2012 03:29:32 +0900 Subject: revert part of #507 for warning --- src/gc.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/gc.c b/src/gc.c index d92a231b8..46699aea3 100644 --- a/src/gc.c +++ b/src/gc.c @@ -326,7 +326,6 @@ struct RBasic* mrb_obj_alloc(mrb_state *mrb, enum mrb_vtype ttype, struct RClass *cls) { struct RBasic *p; - static const RVALUE RVALUE_zero = { 0 }; #ifdef MRB_GC_STRESS mrb_garbage_collect(mrb); @@ -346,7 +345,7 @@ mrb_obj_alloc(mrb_state *mrb, enum mrb_vtype ttype, struct RClass *cls) mrb->live++; gc_protect(mrb, p); - *(RVALUE *)p = RVALUE_zero; + memset(p, 0, sizeof(RVALUE)); p->tt = ttype; p->c = cls; paint_partial_white(mrb, p); -- cgit v1.2.3 From 83a31f71854dafb02127096e3910d4b08c1e83e8 Mon Sep 17 00:00:00 2001 From: Tomoyuki Sahara Date: Mon, 29 Oct 2012 11:08:02 +0900 Subject: IO.printf returns nil on CRuby --- mrblib/print.rb | 1 + 1 file changed, 1 insertion(+) diff --git a/mrblib/print.rb b/mrblib/print.rb index 9183f6bb2..68c7837f3 100644 --- a/mrblib/print.rb +++ b/mrblib/print.rb @@ -74,6 +74,7 @@ module Kernel def printf(*args) __printstr__(sprintf(*args)) + nil end end end -- cgit v1.2.3 From f3090c3000a469475385f2bb861a6ad7e7f635ae Mon Sep 17 00:00:00 2001 From: Masaki Muranaka Date: Wed, 24 Oct 2012 17:00:54 +0900 Subject: Use substitution instead of memset in structure initialization. --- include/mruby/data.h | 2 +- src/codegen.c | 8 ++++++-- src/gc.c | 3 ++- src/load.c | 8 ++++++-- src/parse.y | 3 ++- src/proc.c | 3 ++- src/state.c | 8 ++++++-- src/vm.c | 9 +++++---- 8 files changed, 30 insertions(+), 14 deletions(-) diff --git a/include/mruby/data.h b/include/mruby/data.h index ad91e0044..b9bedb3f9 100644 --- a/include/mruby/data.h +++ b/include/mruby/data.h @@ -30,7 +30,7 @@ struct RData *mrb_data_object_alloc(mrb_state *mrb, struct RClass* klass, void * #define Data_Make_Struct(mrb,klass,strct,type,sval) (\ sval = mrb_malloc(mrb, sizeof(strct)),\ - memset(sval, 0, sizeof(strct)),\ + { static const strct zero = { 0 }; *sval = zero},\ Data_Wrap_Struct(mrb,klass,type,sval)\ ) diff --git a/src/codegen.c b/src/codegen.c index 2d01ed701..7c3182599 100644 --- a/src/codegen.c +++ b/src/codegen.c @@ -453,7 +453,10 @@ new_sym(codegen_scope *s, mrb_sym sym) } if (s->slen > 125 && s->slen < 256) { s->syms = (mrb_sym *)codegen_realloc(s, s->syms, sizeof(mrb_sym)*65536); - memset(s->syms+s->slen, 0, sizeof(mrb_sym)*(256-s->slen)); + for (i = 0; i < 256 - s->slen; i++) { + static const mrb_sym mrb_sym_zero = { 0 }; + s->syms[i + s->slen] = mrb_sym_zero; + } s->slen = 256; } s->syms[s->slen] = sym; @@ -2049,11 +2052,12 @@ codegen(codegen_scope *s, node *tree, int val) static codegen_scope* scope_new(mrb_state *mrb, codegen_scope *prev, node *lv) { + static const codegen_scope codegen_scope_zero = { 0 }; mrb_pool *pool = mrb_pool_open(mrb); codegen_scope *p = (codegen_scope *)mrb_pool_alloc(pool, sizeof(codegen_scope)); if (!p) return 0; - memset(p, 0, sizeof(codegen_scope)); + *p = codegen_scope_zero; p->mrb = mrb; p->mpool = pool; if (!prev) return p; diff --git a/src/gc.c b/src/gc.c index 46699aea3..37e4a363b 100644 --- a/src/gc.c +++ b/src/gc.c @@ -326,6 +326,7 @@ struct RBasic* mrb_obj_alloc(mrb_state *mrb, enum mrb_vtype ttype, struct RClass *cls) { struct RBasic *p; + static const RVALUE RVALUE_zero = { { { 0 } } }; #ifdef MRB_GC_STRESS mrb_garbage_collect(mrb); @@ -345,7 +346,7 @@ mrb_obj_alloc(mrb_state *mrb, enum mrb_vtype ttype, struct RClass *cls) mrb->live++; gc_protect(mrb, p); - memset(p, 0, sizeof(RVALUE)); + *(RVALUE *)p = RVALUE_zero; p->tt = ttype; p->c = cls; paint_partial_white(mrb, p); diff --git a/src/load.c b/src/load.c index a2ae4100b..751c2619b 100644 --- a/src/load.c +++ b/src/load.c @@ -448,7 +448,10 @@ read_rite_irep_record(mrb_state *mrb, unsigned char *src, mrb_irep *irep, uint32 goto error_exit; } - memset(irep->syms, 0, sizeof(mrb_sym)*(irep->slen)); + for (i = 0; i < irep->slen; i++) { + static const mrb_sym mrb_sym_zero = { 0 }; + *irep->syms = mrb_sym_zero; + } for (i=0; islen; i++) { snl = bin_to_uint16(src); //symbol name length src += MRB_DUMP_SIZE_OF_SHORT; @@ -509,11 +512,12 @@ mrb_read_irep(mrb_state *mrb, const char *bin) mrb_add_irep(mrb, sirep + nirep); for (n=0,i=sirep; nirep[i] = (mrb_irep *)mrb_malloc(mrb, sizeof(mrb_irep))) == NULL) { ret = MRB_DUMP_GENERAL_FAILURE; goto error_exit; } - memset(mrb->irep[i], 0, sizeof(mrb_irep)); + *mrb->irep[i] = mrb_irep_zero; } src += sizeof(bin_header) + MRB_DUMP_SIZE_OF_SHORT; //header + crc diff --git a/src/parse.y b/src/parse.y index b903ac840..cffb6ba09 100644 --- a/src/parse.y +++ b/src/parse.y @@ -4747,13 +4747,14 @@ mrb_parser_new(mrb_state *mrb) { mrb_pool *pool; parser_state *p; + static const parser_state parser_state_zero = { 0 }; pool = mrb_pool_open(mrb); if (!pool) return 0; p = (parser_state *)mrb_pool_alloc(pool, sizeof(parser_state)); if (!p) return 0; - memset(p, 0, sizeof(parser_state)); + *p = parser_state_zero; p->mrb = mrb; p->pool = pool; p->in_def = p->in_single = 0; diff --git a/src/proc.c b/src/proc.c index 3321c2a91..07834e86d 100644 --- a/src/proc.c +++ b/src/proc.c @@ -149,11 +149,12 @@ mrb_init_proc(mrb_state *mrb) { struct RProc *m; mrb_irep *call_irep = (mrb_irep *)mrb_alloca(mrb, sizeof(mrb_irep)); + static const mrb_irep mrb_irep_zero = { 0 }; if ( call_iseq == NULL || call_irep == NULL ) return; - memset(call_irep, 0, sizeof(mrb_irep)); + *call_irep = mrb_irep_zero; call_irep->flags = MRB_ISEQ_NO_FREE; call_irep->idx = -1; call_irep->iseq = call_iseq; diff --git a/src/state.c b/src/state.c index 991be310e..8bd222fb5 100644 --- a/src/state.c +++ b/src/state.c @@ -16,10 +16,11 @@ void mrb_init_ext(mrb_state*); mrb_state* mrb_open_allocf(mrb_allocf f, void *ud) { + static const mrb_state mrb_state_zero = { 0 }; mrb_state *mrb = (mrb_state *)(f)(NULL, NULL, sizeof(mrb_state), ud); if (mrb == NULL) return NULL; - memset(mrb, 0, sizeof(mrb_state)); + *mrb = mrb_state_zero; mrb->ud = ud; mrb->allocf = f; mrb->current_white_part = MRB_GC_WHITE_A; @@ -119,12 +120,15 @@ mrb_add_irep(mrb_state *mrb, int idx) mrb->irep_capa = max; } else if (mrb->irep_capa <= idx) { + int i; size_t old_capa = mrb->irep_capa; while (mrb->irep_capa <= idx) { mrb->irep_capa *= 2; } mrb->irep = (mrb_irep **)mrb_realloc(mrb, mrb->irep, sizeof(mrb_irep*)*mrb->irep_capa); - memset(mrb->irep + old_capa, 0, sizeof(mrb_irep*) * (mrb->irep_capa - old_capa)); + for (i = old_capa; i < mrb->irep_capa - old_capa; i++) { + mrb->irep[i] = NULL; + } } } diff --git a/src/vm.c b/src/vm.c index 693e2413a..120e0d4c0 100644 --- a/src/vm.c +++ b/src/vm.c @@ -100,15 +100,16 @@ stack_extend(mrb_state *mrb, int room, int keep) envadjust(mrb, oldbase, mrb->stbase); } if (room > keep) { -#ifndef MRB_NAN_BOXING - memset(mrb->stack+keep, 0, sizeof(mrb_value) * (room-keep)); -#else int i; for (i=keep; istack[i] = mrb_value_zero; +#else SET_NIL_VALUE(mrb->stack[i]); - } #endif + } } } -- cgit v1.2.3 From 94d16805a53487a45e30cb275a9f55f9f8054669 Mon Sep 17 00:00:00 2001 From: Akira Yumiyama Date: Sat, 27 Oct 2012 17:12:32 +0900 Subject: fixes *.mrb dump/load format with escaped character. - hex-style string support - mrb format changes like: - "\n" (before: \n -> after: \n) - '\n' (before: \n -> after: \\n) --- src/dump.c | 28 +++++++++++++++++++++++----- src/load.c | 19 ++++++++++++++++--- 2 files changed, 39 insertions(+), 8 deletions(-) diff --git a/src/dump.c b/src/dump.c index 5100014d9..628550df6 100644 --- a/src/dump.c +++ b/src/dump.c @@ -6,6 +6,7 @@ #include #include "mruby/dump.h" +#include #include "mruby/string.h" #ifdef ENABLE_REGEXP @@ -119,13 +120,16 @@ uint32_dump(uint32_t bin, char *hex, int type) } } +#define CHAR_ESC_LEN 13 /* sizeof(\x{ hex of 32bit unsigned int } \0) */ + static char* str_dump(char *str, char *hex, uint16_t len, int type) { if (type == DUMP_TYPE_BIN) memcpy(hex, str, len); else { - char *src, *dst; + char *src, *dst, buf[CHAR_ESC_LEN + 1]; + int n; for (src = str, dst = hex; len > 0; src++, dst++, len--) { switch (*src) { @@ -136,11 +140,19 @@ str_dump(char *str, char *hex, uint16_t len, int type) case 0x0B:/* VT */ *dst++ = '\\'; *dst = 'v'; break; case 0x0C:/* FF */ *dst++ = '\\'; *dst = 'f'; break; case 0x0D:/* CR */ *dst++ = '\\'; *dst = 'r'; break; + case 0x5C:/* \ */ *dst++ = '\\'; *dst = '\\'; break; case 0x22:/* " */ /* fall through */ case 0x27:/* ' */ /* fall through */ // case 0x3F:/* ? */ /* fall through */ - case 0x5C:/* \ */ /* fall through */ - default: *dst = *src; break; + default: + if (*src >= ' ' && *src <= '~') { + *dst = *src; + } else { + n = sprintf(buf, "\\%03o", *src & 0377); + memcpy(dst, buf, n); + dst += (n-1); + } + break; } } } @@ -167,15 +179,21 @@ str_dump_len(char *str, uint16_t len, int type) case 0x0B:/* VT */ /* fall through */ case 0x0C:/* FF */ /* fall through */ case 0x0D:/* CR */ /* fall through */ + case 0x5C:/* \ */ /* fall through */ dump_len += 2; break; case 0x22:/* " */ /* fall through */ case 0x27:/* ' */ /* fall through */ // case 0x3F:/* ? */ /* fall through */ - case 0x5C:/* \ */ /* fall through */ default: - dump_len++; break; + if (*src >= ' ' && *src <= '~') { + dump_len++; + } else { + // dump_len += sprintf(buf, "\\%03o", *src & 0377); + dump_len += 4; + } + break; } } } diff --git a/src/load.c b/src/load.c index 4d26b02ca..61fdeed8a 100644 --- a/src/load.c +++ b/src/load.c @@ -611,8 +611,8 @@ hex_to_uint32(unsigned char *hex) static char* hex_to_str(char *hex, char *str, uint16_t *str_len) { - char *src, *dst; - int escape = 0; + char *src, *dst, buf[4]; + int escape = 0, base = 0; *str_len = 0; for (src = hex, dst = str; *src != '\0'; src++) { @@ -629,7 +629,20 @@ hex_to_str(char *hex, char *str, uint16_t *str_len) case '\'': /* fall through */ case '\?': /* fall through */ case '\\': *dst++ = *src; break; - default:break; + default: + if (*src >= '0' && *src <= '7') { + base = 8; + strncpy(buf, src, 3); + } else if (*src == 'x' || *src == 'X') { + base = 16; + src++; + strncpy(buf, src, 2); + } + + char *err_ptr; + *dst++ = (unsigned char) strtol(buf, &err_ptr, base) & 0xff; + src += (err_ptr - buf - 1); + break; } escape = 0; } else { -- cgit v1.2.3 From 30f7a93d415722ec070447d573355b2c67d71310 Mon Sep 17 00:00:00 2001 From: Masaki Muranaka Date: Tue, 30 Oct 2012 14:25:00 +0900 Subject: Use NULL instead of 0. (It is not a bug fix but a cosmetic change.) --- src/cdump.c | 10 +++++----- src/dump.c | 26 +++++++++++++------------- src/load.c | 6 +++--- 3 files changed, 21 insertions(+), 21 deletions(-) diff --git a/src/cdump.c b/src/cdump.c index c7597e12f..b43c86ee7 100644 --- a/src/cdump.c +++ b/src/cdump.c @@ -22,7 +22,7 @@ make_cdump_isec(mrb_state *mrb, int irep_no, FILE *f) int i; mrb_irep *irep = mrb->irep[irep_no]; - if (irep == 0) + if (irep == NULL) return -1; /* dump isec struct*/ @@ -103,11 +103,11 @@ make_cdump_irep(mrb_state *mrb, int irep_no, FILE *f) char *buf = 0; size_t buf_len, str_len; - if (irep == 0) + if (irep == NULL) return -1; buf_len = MRB_CDUMP_LINE_LEN; - if ((buf = (char *)mrb_malloc(mrb, buf_len)) == 0 ) { + if ((buf = (char *)mrb_malloc(mrb, buf_len)) == NULL) { return MRB_CDUMP_GENERAL_FAILURE; } @@ -150,7 +150,7 @@ make_cdump_irep(mrb_state *mrb, int irep_no, FILE *f) str_len = str_format_len(irep->pool[n]) + 1; if ( str_len > buf_len ) { buf_len = str_len; - if ((buf = (char *)mrb_realloc(mrb, buf, buf_len)) == 0 ) { + if ((buf = (char *)mrb_realloc(mrb, buf, buf_len)) == NULL) { return MRB_CDUMP_GENERAL_FAILURE; } } @@ -174,7 +174,7 @@ mrb_cdump_irep(mrb_state *mrb, int n, FILE *f,const char *initname) { int irep_no, irep_num; - if (mrb == 0 || n < 0 || n >= mrb->irep_len || f == 0 || initname == 0) + if (mrb == NULL || n < 0 || n >= mrb->irep_len || f == NULL || initname == NULL) return -1; irep_num = mrb->irep_len - n; diff --git a/src/dump.c b/src/dump.c index 5100014d9..bdcb739b4 100644 --- a/src/dump.c +++ b/src/dump.c @@ -335,7 +335,7 @@ write_pool_block(mrb_state *mrb, mrb_irep *irep, char *buf, int type) uint16_t len =0; buf_size = MRB_DUMP_DEFAULT_STR_LEN; - if ((char_buf = (char *)mrb_malloc(mrb, buf_size)) == 0) + if ((char_buf = (char *)mrb_malloc(mrb, buf_size)) == NULL) goto error_exit; buf += uint32_dump((uint32_t)irep->plen, buf, type); /* number of pool */ @@ -358,7 +358,7 @@ write_pool_block(mrb_state *mrb, mrb_irep *irep, char *buf, int type) len = str_dump_len(RSTRING_PTR(str), RSTRING_LEN(str), type); if (len > buf_size - 1) { buf_size = len + 1; - if ((char_buf = (char *)mrb_realloc(mrb, char_buf, buf_size)) == 0) + if ((char_buf = (char *)mrb_realloc(mrb, char_buf, buf_size)) == NULL) goto error_exit; memset(char_buf, 0, buf_size); } @@ -371,7 +371,7 @@ write_pool_block(mrb_state *mrb, mrb_irep *irep, char *buf, int type) len = str_dump_len(RSTRING_PTR(str), RSTRING_LEN(str), type); if ( len > buf_size - 1) { buf_size = len + 1; - if ((char_buf = mrb_realloc(mrb, char_buf, buf_size)) == 0) + if ((char_buf = mrb_realloc(mrb, char_buf, buf_size)) == NULL) goto error_exit; memset(char_buf, 0, buf_size); } @@ -405,7 +405,7 @@ write_syms_block(mrb_state *mrb, mrb_irep *irep, char *buf, int type) uint16_t buf_size =0; buf_size = MRB_DUMP_DEFAULT_STR_LEN; - if ((char_buf = (char *)mrb_malloc(mrb, buf_size)) == 0) + if ((char_buf = (char *)mrb_malloc(mrb, buf_size)) == NULL) goto error_exit; buf += uint32_dump((uint32_t)irep->slen, buf, type); /* number of symbol */ @@ -421,7 +421,7 @@ write_syms_block(mrb_state *mrb, mrb_irep *irep, char *buf, int type) nlen = str_dump_len((char*)name, len, type); if ( nlen > buf_size - 1) { buf_size = nlen + 1; - if ((char_buf = (char *)mrb_realloc(mrb, char_buf, buf_size)) == 0) + if ((char_buf = (char *)mrb_realloc(mrb, char_buf, buf_size)) == NULL) goto error_exit; } memset(char_buf, 0, buf_size); @@ -457,7 +457,7 @@ calc_crc_section(mrb_state *mrb, mrb_irep *irep, uint16_t *crc, int section) default: return MRB_DUMP_GENERAL_FAILURE; } - if ((buf = (char *)mrb_calloc(mrb, 1, buf_size)) == 0) + if ((buf = (char *)mrb_calloc(mrb, 1, buf_size)) == NULL) return MRB_DUMP_GENERAL_FAILURE; buf_top = buf; @@ -542,7 +542,7 @@ write_irep_record(mrb_state *mrb, int irep_no, char* bin, uint32_t *rlen, int ty mrb_irep *irep = mrb->irep[irep_no]; int section; - if (irep == 0) + if (irep == NULL) return MRB_DUMP_INVALID_IREP; /* buf alloc */ @@ -586,7 +586,7 @@ dump_irep_record(mrb_state *mrb, int irep_no, FILE* fp, uint32_t *rlen) char *buf; mrb_irep *irep = mrb->irep[irep_no]; - if (irep == 0) + if (irep == NULL) return MRB_DUMP_INVALID_IREP; /* buf alloc */ @@ -594,7 +594,7 @@ dump_irep_record(mrb_state *mrb, int irep_no, FILE* fp, uint32_t *rlen) if (irep_record_size == 0) return MRB_DUMP_GENERAL_FAILURE; - if ((buf = (char *)mrb_calloc(mrb, 1, irep_record_size)) == 0) + if ((buf = (char *)mrb_calloc(mrb, 1, irep_record_size)) == NULL) return MRB_DUMP_GENERAL_FAILURE; if ((rc = write_irep_record(mrb, irep_no, buf, rlen, DUMP_TYPE_HEX)) != MRB_DUMP_OK) { @@ -620,7 +620,7 @@ mrb_write_irep(mrb_state *mrb, int top, char *bin) int irep_no; char *bin_top; - if (mrb == 0 || top < 0 || top >= mrb->irep_len || bin == 0) + if (mrb == NULL || top < 0 || top >= mrb->irep_len || bin == NULL) return MRB_DUMP_INVALID_ARGUMENT; bin_top = bin; @@ -648,7 +648,7 @@ mrb_dump_irep(mrb_state *mrb, int top, FILE* fp) uint32_t rlen=0; /* size of irep record */ int irep_no; - if (mrb == 0 || top < 0 || top >= mrb->irep_len || fp == 0) + if (mrb == NULL || top < 0 || top >= mrb->irep_len || fp == NULL) return MRB_DUMP_INVALID_ARGUMENT; if (fwrite(&def_rite_file_header, sizeof(rite_file_header), 1, fp) != 1) /* dummy write */ @@ -678,7 +678,7 @@ mrb_bdump_irep(mrb_state *mrb, int n, FILE *f,const char *initname) int buf_size = 0; int buf_idx = 0; - if (mrb == 0 || n < 0 || n >= mrb->irep_len || f == 0 || initname == 0) + if (mrb == NULL || n < 0 || n >= mrb->irep_len || f == NULL || initname == NULL) return -1; buf_size = sizeof(rite_binary_header) + MRB_DUMP_SIZE_OF_SHORT/* crc */; @@ -686,7 +686,7 @@ mrb_bdump_irep(mrb_state *mrb, int n, FILE *f,const char *initname) buf_size += get_irep_record_size(mrb, irep_no, DUMP_TYPE_BIN); buf_size += MRB_DUMP_SIZE_OF_LONG; /* end of file */ - if ((buf = (char *)mrb_malloc(mrb, buf_size)) == 0) + if ((buf = (char *)mrb_malloc(mrb, buf_size)) == NULL) return MRB_DUMP_GENERAL_FAILURE; rc = mrb_write_irep(mrb, n, buf); diff --git a/src/load.c b/src/load.c index 4d26b02ca..a31ef98a8 100644 --- a/src/load.c +++ b/src/load.c @@ -143,7 +143,7 @@ load_rite_irep_record(mrb_state *mrb, RiteFILE* rfp, unsigned char* dst, uint32_ uint16_t buf_size =0; buf_size = MRB_DUMP_DEFAULT_STR_LEN; - if ((char_buf = (char *)mrb_malloc(mrb, buf_size)) == 0) + if ((char_buf = (char *)mrb_malloc(mrb, buf_size)) == NULL) goto error_exit; pStart = dst; @@ -192,7 +192,7 @@ load_rite_irep_record(mrb_state *mrb, RiteFILE* rfp, unsigned char* dst, uint32_ if ( pdl > buf_size - 1) { buf_size = pdl + 1; - if ((char_buf = (char *)mrb_realloc(mrb, char_buf, buf_size)) == 0) + if ((char_buf = (char *)mrb_realloc(mrb, char_buf, buf_size)) == NULL) goto error_exit; } memset(char_buf, '\0', buf_size); @@ -219,7 +219,7 @@ load_rite_irep_record(mrb_state *mrb, RiteFILE* rfp, unsigned char* dst, uint32_ if ( snl > buf_size - 1) { buf_size = snl + 1; - if ((char_buf = (char *)mrb_realloc(mrb, char_buf, buf_size)) == 0) + if ((char_buf = (char *)mrb_realloc(mrb, char_buf, buf_size)) == NULL) goto error_exit; } memset(char_buf, '\0', buf_size); -- cgit v1.2.3 From ec343a64217a4825a97d4ef469699445f86a30e7 Mon Sep 17 00:00:00 2001 From: skandhas Date: Tue, 30 Oct 2012 14:00:58 +0800 Subject: fix cannot get/set const variable form singleton class --- src/variable.c | 1 + 1 file changed, 1 insertion(+) diff --git a/src/variable.c b/src/variable.c index 7f9274ee4..af75f5169 100644 --- a/src/variable.c +++ b/src/variable.c @@ -674,6 +674,7 @@ mod_const_check(mrb_state *mrb, mrb_value mod) switch (mrb_type(mod)) { case MRB_TT_CLASS: case MRB_TT_MODULE: + case MRB_TT_SCLASS: break; default: mrb_raise(mrb, E_TYPE_ERROR, "constant look-up for non class/module"); -- cgit v1.2.3 From 38fb8b07c6c39f42898b4e1c14a8cd524cc022b8 Mon Sep 17 00:00:00 2001 From: Akira Yumiyama Date: Tue, 30 Oct 2012 23:43:19 +0900 Subject: fix mruby exit status with mrb file. --- tools/mruby/mruby.c | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/tools/mruby/mruby.c b/tools/mruby/mruby.c index cbe170e7f..db26d23a1 100644 --- a/tools/mruby/mruby.c +++ b/tools/mruby/mruby.c @@ -113,7 +113,7 @@ append_cmdline: case '-': if (strcmp((*argv) + 2, "version") == 0) { mrb_show_version(mrb); - exit(0); + exit(0); } else if (strcmp((*argv) + 2, "verbose") == 0) { args->verbose = 1; @@ -121,7 +121,7 @@ append_cmdline: } else if (strcmp((*argv) + 2, "copyright") == 0) { mrb_show_copyright(mrb); - exit(0); + exit(0); } else return -3; return 0; @@ -135,8 +135,8 @@ append_cmdline: else { args->rfp = fopen(argv[0], args->mrbfile ? "rb" : "r"); if (args->rfp == NULL) { - printf("%s: Cannot open program file. (%s)\n", *origargv, *argv); - return 0; + printf("%s: Cannot open program file. (%s)\n", *origargv, *argv); + return 0; } args->fname = 1; args->cmdline = argv[0]; @@ -196,8 +196,10 @@ main(int argc, char **argv) } else if (!args.check_syntax) { mrb_run(mrb, mrb_proc_new(mrb, mrb->irep[n]), mrb_top_self(mrb)); + n = 0; if (mrb->exc) { - p(mrb, mrb_obj_value(mrb->exc)); + p(mrb, mrb_obj_value(mrb->exc)); + n = -1; } } } @@ -221,7 +223,7 @@ main(int argc, char **argv) mrbc_context_free(mrb, c); if (mrb->exc) { if (!mrb_undef_p(v)) { - p(mrb, mrb_obj_value(mrb->exc)); + p(mrb, mrb_obj_value(mrb->exc)); } n = -1; } -- cgit v1.2.3 From 35699424a9e2d286fcbf3ac040f4e2a2b1027f0b Mon Sep 17 00:00:00 2001 From: Kouki Ooyatsu Date: Wed, 31 Oct 2012 20:15:39 +0900 Subject: fix: broken variable reference, use 'next' statement Because the tree is gone pop() even if it is empty. --- src/codegen.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/codegen.c b/src/codegen.c index ebc9b32de..ca2269d85 100644 --- a/src/codegen.c +++ b/src/codegen.c @@ -1556,8 +1556,10 @@ codegen(codegen_scope *s, node *tree, int val) genop(s, MKOP_sBx(OP_JMP, s->loop->pc1 - s->pc)); } else { - codegen(s, tree, VAL); - pop(); + if (tree) { + codegen(s, tree, VAL); + pop(); + } genop_peep(s, MKOP_AB(OP_RETURN, cursp(), OP_R_NORMAL), NOVAL); } if (val) push(); -- cgit v1.2.3 From 8cf42709d1933ad450120dff145723acba1fbc68 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Thu, 1 Nov 2012 04:21:39 +0900 Subject: constant access should refer outer class/module; close #514 --- src/variable.c | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/variable.c b/src/variable.c index af75f5169..eebe81575 100644 --- a/src/variable.c +++ b/src/variable.c @@ -700,7 +700,7 @@ const_get(mrb_state *mrb, struct RClass *base, mrb_sym sym) } c = c->super; } - if (!retry && base->tt == MRB_TT_MODULE) { + if (!retry && base && base->tt == MRB_TT_MODULE) { c = mrb->object_class; retry = 1; goto L_RETRY; @@ -733,6 +733,22 @@ mrb_vm_const_get(mrb_state *mrb, mrb_sym sym) struct RClass *c = mrb->ci->proc->target_class; if (!c) c = mrb->ci->target_class; + if (c) { + struct RClass *c2 = c; + mrb_value v; + + if (c->iv && iv_get(mrb, c->iv, sym, &v)) { + return v; + } + c2 = c; + for (;;) { + c2 = mrb_class_outer_module(mrb, c2); + if (!c2) break; + if (c2->iv && iv_get(mrb, c2->iv, sym, &v)) { + return v; + } + } + } return const_get(mrb, c, sym); } -- cgit v1.2.3 From 9b85ffa5a760e53536762bf6cdf402c90ae9ceb7 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Thu, 1 Nov 2012 05:54:53 +0900 Subject: OP_ADDI/OP_SUBI should handle integer overflow; close #518 --- src/vm.c | 26 ++++++++++++++++++++++++-- 1 file changed, 24 insertions(+), 2 deletions(-) diff --git a/src/vm.c b/src/vm.c index 120e0d4c0..953863a0b 100644 --- a/src/vm.c +++ b/src/vm.c @@ -1444,7 +1444,18 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self) /* need to check if + is overridden */ switch (mrb_type(regs[a])) { case MRB_TT_FIXNUM: - regs[a].attr_i += GETARG_C(i); + { + mrb_int x = regs[a].attr_i; + mrb_int y = GETARG_C(i); + mrb_int z = x + y; + + if (((x < 0) ^ (y < 0)) == 0 && (x < 0) != (z < 0)) { + /* integer overflow */ + SET_FLT_VALUE(regs[a], (mrb_float)x + (mrb_float)y); + break; + } + regs[a].attr_i = z; + } break; case MRB_TT_FLOAT: regs[a].attr_f += GETARG_C(i); @@ -1464,7 +1475,18 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self) /* need to check if + is overridden */ switch (mrb_type(regs[a])) { case MRB_TT_FIXNUM: - regs[a].attr_i -= GETARG_C(i); + { + mrb_int x = regs[a].attr_i; + mrb_int y = GETARG_C(i); + mrb_int z = x - y; + + if (((x < 0) ^ (y < 0)) == 0 && (x < 0) != (z < 0)) { + /* integer overflow */ + SET_FLT_VALUE(regs[a], (mrb_float)x - (mrb_float)y); + break; + } + regs[a].attr_i = z; + } break; case MRB_TT_FLOAT: regs[a].attr_f -= GETARG_C(i); -- cgit v1.2.3 From fe36bdb7f12050254f02a5f2c3a75623dfd289c0 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Thu, 1 Nov 2012 06:12:11 +0900 Subject: add String#bytes to return bytes in a string --- src/string.c | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/src/string.c b/src/string.c index f3ceb6d96..8eb08562d 100644 --- a/src/string.c +++ b/src/string.c @@ -2989,6 +2989,29 @@ mrb_str_inspect(mrb_state *mrb, mrb_value str) return result; } +/* + * call-seq: + * str.bytes -> array of fixnums + * + * Returns an array of bytes in _str_. + * + * str = "hello" + * str.bytes #=> [104, 101, 108, 108, 111] + */ +static mrb_value +mrb_str_bytes(mrb_state *mrb, mrb_value str) +{ + struct RString *s = mrb_str_ptr(str); + mrb_value a = mrb_ary_new_capa(mrb, s->len); + char *p = s->ptr, *pend = p + s->len; + + while (p < pend) { + mrb_ary_push(mrb, a, mrb_fixnum_value(p[0])); + p++; + } + return a; +} + /* ---------------------------*/ void mrb_init_string(mrb_state *mrb) @@ -3053,4 +3076,5 @@ mrb_init_string(mrb_state *mrb) mrb_define_method(mrb, s, "upcase", mrb_str_upcase, ARGS_REQ(1)); /* 15.2.10.5.42 */ mrb_define_method(mrb, s, "upcase!", mrb_str_upcase_bang, ARGS_REQ(1)); /* 15.2.10.5.43 */ mrb_define_method(mrb, s, "inspect", mrb_str_inspect, ARGS_NONE()); /* 15.2.10.5.46(x) */ + mrb_define_method(mrb, s, "bytes", mrb_str_bytes, ARGS_NONE()); } -- cgit v1.2.3 From 57910ca5353e1feba1fb069a876b84a52f33d39f Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Thu, 1 Nov 2012 06:13:02 +0900 Subject: String#each_byte to use String#bytes; close #508 --- mrblib/string.rb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mrblib/string.rb b/mrblib/string.rb index d09b787da..0b995f9ca 100644 --- a/mrblib/string.rb +++ b/mrblib/string.rb @@ -118,7 +118,7 @@ class String ## # Call the given block for each byte of +self+. def each_byte(&block) - bytes = self.unpack("C*") + bytes = self.bytes pos = 0 while(pos < bytes.size) block.call(bytes[pos]) -- cgit v1.2.3