diff options
Diffstat (limited to 'mrbgems/mruby-bin-debugger')
17 files changed, 427 insertions, 361 deletions
diff --git a/mrbgems/mruby-bin-debugger/bintest/mrdb.rb b/mrbgems/mruby-bin-debugger/bintest/mrdb.rb index ae40f0a46..bc5dc4552 100755..100644 --- a/mrbgems/mruby-bin-debugger/bintest/mrdb.rb +++ b/mrbgems/mruby-bin-debugger/bintest/mrdb.rb @@ -13,14 +13,14 @@ class BinTest_MrubyBinDebugger script.flush # compile - `./bin/mrbc -g -o "#{bin.path}" "#{script.path}"` - + `#{cmd("mrbc")} -g -o "#{bin.path}" "#{script.path}"` + # add mrdb quit testcase << {:cmd=>"quit"} stdin_data = testcase.map{|t| t[:cmd]}.join("\n") << "\n" - ["bin/mrdb #{script.path}","bin/mrdb -b #{bin.path}"].each do |cmd| + ["#{cmd('mrdb')} #{script.path}", "#{cmd('mrdb')} -b #{bin.path}"].each do |cmd| o, s = Open3.capture2(cmd, :stdin_data => stdin_data) exp_vals = testcase.map{|t| t.fetch(:exp, nil)} @@ -63,10 +63,7 @@ assert('mruby-bin-debugger(mrdb) command line') do # ruby source src = "foo = 'foo'\n" - str = "" - 103.times { - str += "1234567890" - } + str = ":#{'abcdefghij' * 103}" cmd = "p a=#{str}" # test case diff --git a/mrbgems/mruby-bin-debugger/bintest/print.rb b/mrbgems/mruby-bin-debugger/bintest/print.rb index e9d85f333..63ebded3e 100755..100644 --- a/mrbgems/mruby-bin-debugger/bintest/print.rb +++ b/mrbgems/mruby-bin-debugger/bintest/print.rb @@ -1,9 +1,10 @@ require 'open3' require 'tempfile' +require 'strscan' class BinTest_MrubyBinDebugger - @debug1=false - @debug2=true +# @debug1=false +# @debug2=true def self.test(rubysource, testcase) script, bin = Tempfile.new(['test', '.rb']), Tempfile.new(['test', '.mrb']) @@ -12,17 +13,27 @@ class BinTest_MrubyBinDebugger script.flush # compile - `./bin/mrbc -g -o "#{bin.path}" "#{script.path}"` - + `#{cmd("mrbc")} -g -o "#{bin.path}" "#{script.path}"` + # add mrdb quit testcase << {:cmd=>"quit"} stdin_data = testcase.map{|t| t[:cmd]}.join("\n") << "\n" - ["bin/mrdb #{script.path}","bin/mrdb -b #{bin.path}"].each do |cmd| + prompt = /^\(#{Regexp.escape(script.path)}:\d+\) / + ["#{cmd('mrdb')} #{script.path}", "#{cmd('mrdb')} -b #{bin.path}"].each do |cmd| o, s = Open3.capture2(cmd, :stdin_data => stdin_data) + scanner = StringScanner.new(o) + scanner.skip_until(prompt) + testcase.each do |tc| + exp = tc[:exp] + if exp + act = scanner.scan_until(/\n/) + break unless assert_operator act, :start_with?, exp + end + scanner.skip_until(prompt) + end - exp_vals = testcase.map{|t| t.fetch(:exp, nil)} =begin if @debug1 o.split("\n").each_with_index do |i,actual| @@ -41,14 +52,6 @@ end assert_true actual.include?(exp) unless exp.nil? end =end - idx = 0 - exp_vals.each do |exp| - next if exp.nil? - idx = o.index(exp, idx) - assert_false idx.nil? - break unless idx - idx += 1 - end end end end @@ -64,7 +67,7 @@ assert('mruby-bin-debugger(print) invalid arguments') do BinTest_MrubyBinDebugger.test(src, tc) end -assert('mruby-bin-debugger(print) nomal') do +assert('mruby-bin-debugger(print) normal') do # ruby source src = <<"SRC" foo = 'foo' @@ -90,13 +93,13 @@ assert('mruby-bin-debugger(print) error') do # test case tc = [] - tc << {:cmd=>"p (1+2", :exp=>'$1 = SyntaxError'} - tc << {:cmd=>"p bar", :exp=>'$2 = NoMethodError'} + tc << {:cmd=>"p (1+2", :exp=>'$1 = line 1: syntax error'} + tc << {:cmd=>"p bar", :exp=>'$2 = undefined method'} BinTest_MrubyBinDebugger.test(src, tc) end -# Kernel#instance_eval(string) does't work multiple statements. +# Kernel#instance_eval(string) doesn't work multiple statements. =begin assert('mruby-bin-debugger(print) multiple statements') do # ruby source @@ -231,7 +234,7 @@ SRC BinTest_MrubyBinDebugger.test(src, tc) end -assert('mruby-bin-debugger(print) same name:local variabe') do +assert('mruby-bin-debugger(print) same name:local variable') do # ruby source (bp is break point) src = <<"SRC" lv = 'top' @@ -261,7 +264,7 @@ SRC BinTest_MrubyBinDebugger.test(src, tc) end -assert('mruby-bin-debugger(print) same name:instance variabe') do +assert('mruby-bin-debugger(print) same name:instance variable') do # ruby source (bp is break point) src = <<"SRC" @iv = 'top' @@ -293,7 +296,7 @@ SRC BinTest_MrubyBinDebugger.test(src, tc) end -# Kernel#instance_eval(string) does't work const. +# Kernel#instance_eval(string) doesn't work const. =begin assert('mruby-bin-debugger(print) same name:const') do # ruby source (bp is break point) @@ -317,7 +320,7 @@ TestConstNameSubClass.new.m() bp = nil SRC - # todo: wait for 'break' to be implimented + # todo: wait for 'break' to be implemented tc = [] 9.times { tc << {:cmd=>"s"} } tc << {:cmd=>"p CONST", :exp=>"super class"} @@ -341,13 +344,13 @@ assert('mruby-bin-debugger(print) Literal:Numeric') do tc << {:cmd=>"p +0100", :exp=>'$3 = 64'} tc << {:cmd=>"p 0x100", :exp=>'$4 = 256'} tc << {:cmd=>"p 1_234", :exp=>'$5 = 1234'} - tc << {:cmd=>"p 0b1000_0000", :exp=>"$6 = #{0b1000_0000.to_s}"} - tc << {:cmd=>"p 0x1000_0000", :exp=>"$7 = #{0x1000_0000.to_s}"} + tc << {:cmd=>"p 0b1000_0000", :exp=>"$6 = #{0b1000_0000}"} + tc << {:cmd=>"p 0x1000_0000", :exp=>"$7 = #{0x1000_0000}"} tc << {:cmd=>"p 3.14", :exp=>'$8 = 3.14'} tc << {:cmd=>"p -12.3", :exp=>'$9 = -12.3'} - tc << {:cmd=>"p +12.000", :exp=>'$10 = 12.0'} - tc << {:cmd=>"p 1e4", :exp=>'$11 = 10000.0'} + tc << {:cmd=>"p +12.000", :exp=>'$10 = 12'} + tc << {:cmd=>"p 1e4", :exp=>'$11 = 10000'} tc << {:cmd=>"p -0.1e-2", :exp=>'$12 = -0.001'} BinTest_MrubyBinDebugger.test(src, tc) @@ -368,28 +371,28 @@ SRC tc << {:cmd=>'p "str"', :exp=>'$1 = "str"'} tc << {:cmd=>'p "s\tt\rr\n"', :exp=>'$2 = "s\\tt\\rr\\n"'} - tc << {:cmd=>'p "\C-a\C-z"', :exp=>'$3 = "\\001\\032"'} + tc << {:cmd=>'p "\C-a\C-z"', :exp=>'$3 = "\\x01\\x1a"'} tc << {:cmd=>'p "#{foo+bar}"', :exp=>'$4 = "foobar"'} tc << {:cmd=>'p \'str\'', :exp=>'$5 = "str"'} tc << {:cmd=>'p \'s\\tt\\rr\\n\'', :exp=>'$6 = "s\\\\tt\\\\rr\\\\n"'} tc << {:cmd=>'p \'\\C-a\\C-z\'', :exp=>'$7 = "\\\\C-a\\\\C-z"'} - tc << {:cmd=>'p \'#{foo+bar}\'', :exp=>'$8 = "#{foo+bar}"'} + tc << {:cmd=>'p \'#{foo+bar}\'', :exp=>'$8 = "\\#{foo+bar}"'} tc << {:cmd=>'p %!str!', :exp=>'$9 = "str"'} tc << {:cmd=>'p %!s\tt\rr\n!', :exp=>'$10 = "s\\tt\\rr\\n"'} - tc << {:cmd=>'p %!\C-a\C-z!', :exp=>'$11 = "\\001\\032"'} + tc << {:cmd=>'p %!\C-a\C-z!', :exp=>'$11 = "\\x01\\x1a"'} tc << {:cmd=>'p %!#{foo+bar}!', :exp=>'$12 = "foobar"'} tc << {:cmd=>'p %Q!str!', :exp=>'$13 = "str"'} tc << {:cmd=>'p %Q!s\tt\rr\n!', :exp=>'$14 = "s\\tt\\rr\\n"'} - tc << {:cmd=>'p %Q!\C-a\C-z!', :exp=>'$15 = "\\001\\032"'} + tc << {:cmd=>'p %Q!\C-a\C-z!', :exp=>'$15 = "\\x01\\x1a"'} tc << {:cmd=>'p %Q!#{foo+bar}!', :exp=>'$16 = "foobar"'} tc << {:cmd=>'p %q!str!', :exp=>'$17 = "str"'} tc << {:cmd=>'p %q!s\\tt\\rr\\n!', :exp=>'$18 = "s\\\\tt\\\\rr\\\\n"'} tc << {:cmd=>'p %q!\\C-a\\C-z!', :exp=>'$19 = "\\\\C-a\\\\C-z"'} - tc << {:cmd=>'p %q!#{foo+bar}!', :exp=>'$20 = "#{foo+bar}"'} + tc << {:cmd=>'p %q!#{foo+bar}!', :exp=>'$20 = "\\#{foo+bar}"'} BinTest_MrubyBinDebugger.test(src, tc) end @@ -410,7 +413,7 @@ SRC tc << {:cmd=>'p []', :exp=>'$1 = []'} tc << {:cmd=>'p [ 5, 12, 8, 10, ]', :exp=>'$2 = [5, 12, 8, 10]'} tc << {:cmd=>'p [1,2.5,"#{foo+bar}"]', :exp=>'$3 = [1, 2.5, "foobar"]'} - tc << {:cmd=>'p %w[3.14 A\ &\ B #{foo}]', :exp=>'$4 = ["3.14", "A & B", "#{foo}"]'} + tc << {:cmd=>'p %w[3.14 A\ &\ B #{foo}]', :exp=>'$4 = ["3.14", "A & B", "\#{foo}"]'} tc << {:cmd=>'p %W[3.14 A\ &\ B #{foo}]', :exp=>'$5 = ["3.14", "A & B", "foo"]'} BinTest_MrubyBinDebugger.test(src, tc) @@ -513,7 +516,7 @@ SRC tc << {:cmd=>'p a+1', :exp=>'$1 = 2'} tc << {:cmd=>'p 2-b', :exp=>'$2 = -3'} tc << {:cmd=>'p c * 3', :exp=>'$3 = 24'} - tc << {:cmd=>'p a/b', :exp=>'$4 = 0.2'} + tc << {:cmd=>'p a/b', :exp=>'$4 = 0'} tc << {:cmd=>'p c%b', :exp=>'$5 = 3'} tc << {:cmd=>'p 2**10', :exp=>'$6 = 1024'} tc << {:cmd=>'p ~3', :exp=>'$7 = -4'} @@ -588,7 +591,7 @@ SRC tc << {:cmd=>'p foo=[foo,bar,baz]', :exp=>'$2 = ["foo", "bar", "baz"]'} tc << {:cmd=>'p undefined=-1', :exp=>'$3 = -1'} - tc << {:cmd=>'p "#{undefined}"', :exp=>'$4 = NoMethodError'} + tc << {:cmd=>'p "#{undefined}"', :exp=>'$4 = undefined method'} BinTest_MrubyBinDebugger.test(src, tc) end @@ -611,13 +614,13 @@ SRC tc << {:cmd=>'p a+=9', :exp=>'$1 = 10'} tc << {:cmd=>'p b-=c', :exp=>'$2 = 15'} tc << {:cmd=>'p bar*=2', :exp=>'$3 = "barbar"'} - tc << {:cmd=>'p a/=4', :exp=>'$4 = 2.5'} + tc << {:cmd=>'p a/=4', :exp=>'$4 = 2'} tc << {:cmd=>'p c%=4', :exp=>'$5 = 2'} tc << {:cmd=>'p b&=0b0101', :exp=>'$6 = 5'} tc << {:cmd=>'p c|=0x10', :exp=>'$7 = 18'} - tc << {:cmd=>'p "#{a} #{b} #{c}"', :exp=>'$8 = "2.5 5 18"'} + tc << {:cmd=>'p "#{a} #{b} #{c}"', :exp=>'$8 = "2 5 18"'} tc << {:cmd=>'p "#{foo}#{bar}#{baz}"', :exp=>'$9 = "foobarbarbaz"'} tc << {:cmd=>'p a,b,c=[10,20,30]',:exp=>'$10 = [10, 20, 30]'} @@ -626,7 +629,7 @@ SRC tc << {:cmd=>'p [a,b]', :exp=>'$13 = [20, 10]'} tc << {:cmd=>'p undefined=-1', :exp=>'$14 = -1'} - tc << {:cmd=>'p "#{undefined}"', :exp=>'$15 = NoMethodError'} + tc << {:cmd=>'p "#{undefined}"', :exp=>'$15 = undefined method'} BinTest_MrubyBinDebugger.test(src, tc) end @@ -679,13 +682,13 @@ SRC tc << {:cmd=>'p a+=9', :exp=>'$1 = 10'} tc << {:cmd=>'p b-=c', :exp=>'$2 = 15'} tc << {:cmd=>'p bar*=2', :exp=>'$3 = "barbar"'} - tc << {:cmd=>'p a/=4', :exp=>'$4 = 2.5'} + tc << {:cmd=>'p a/=4', :exp=>'$4 = 2'} tc << {:cmd=>'p c%=4', :exp=>'$5 = 2'} tc << {:cmd=>'p b&=0b0101', :exp=>'$6 = 5'} tc << {:cmd=>'p c|=0x10', :exp=>'$7 = 18'} - tc << {:cmd=>'p "#{a} #{b} #{c}"', :exp=>'$8 = "2.5 5 18"'} + tc << {:cmd=>'p "#{a} #{b} #{c}"', :exp=>'$8 = "2 5 18"'} tc << {:cmd=>'p "#{foo}#{bar}#{baz}"', :exp=>'$9 = "foobarbarbaz"'} tc << {:cmd=>'p a,b,c=[10,20,30]',:exp=>'$10 = [10, 20, 30]'} @@ -694,8 +697,7 @@ SRC tc << {:cmd=>'p [a,b]', :exp=>'$13 = [20, 10]'} tc << {:cmd=>'p undefined=-1', :exp=>'$14 = -1'} - tc << {:cmd=>'p "#{undefined}"', :exp=>'$15 = NoMethodError'} + tc << {:cmd=>'p "#{undefined}"', :exp=>'$15 = undefined method'} BinTest_MrubyBinDebugger.test(src, tc) end - diff --git a/mrbgems/mruby-bin-debugger/mrbgem.rake b/mrbgems/mruby-bin-debugger/mrbgem.rake index b9d664779..091851dd4 100755..100644 --- a/mrbgems/mruby-bin-debugger/mrbgem.rake +++ b/mrbgems/mruby-bin-debugger/mrbgem.rake @@ -1,8 +1,8 @@ MRuby::Gem::Specification.new('mruby-bin-debugger') do |spec| spec.license = 'MIT' spec.author = 'mruby developers' - spec.summary = 'mruby debuggeer command' - + spec.summary = 'mruby debugger command' + spec.build.defines |= %w(MRB_USE_DEBUG_HOOK) spec.add_dependency('mruby-eval', :core => 'mruby-eval') spec.bins = %w(mrdb) diff --git a/mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.c b/mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.c index 9515e8be4..137f52431 100755..100644 --- a/mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.c +++ b/mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.c @@ -4,14 +4,14 @@ */ #include <string.h> -#include "mruby.h" -#include "mruby/irep.h" +#include <mruby.h> +#include <mruby/irep.h> #include "mrdb.h" -#include "mruby/debug.h" -#include "mruby/opcode.h" -#include "mruby/class.h" -#include "mruby/proc.h" -#include "mruby/variable.h" +#include <mruby/debug.h> +#include <mruby/opcode.h> +#include <mruby/class.h> +#include <mruby/proc.h> +#include <mruby/variable.h> #include "mrdberror.h" #include "apibreak.h" #include "apistring.h" @@ -21,20 +21,21 @@ #define MRB_DEBUG_BP_LINENO_OK (0x0002) static uint16_t -check_lineno( mrb_irep_debug_info_file *info_file, uint16_t lineno ) +check_lineno(mrb_irep_debug_info_file *info_file, uint16_t lineno) { uint32_t count = info_file->line_entry_count; uint16_t l_idx; - if( info_file->line_type == mrb_debug_line_ary ) { + if (info_file->line_type == mrb_debug_line_ary) { for (l_idx = 0; l_idx < count; ++l_idx) { - if(lineno == info_file->lines.ary[l_idx]) { + if (lineno == info_file->lines.ary[l_idx]) { return lineno; } } - } else { + } + else { for (l_idx = 0; l_idx < count; ++l_idx) { - if(lineno == info_file->lines.flat_map[l_idx].line) { + if (lineno == info_file->lines.flat_map[l_idx].line) { return lineno; } } @@ -44,21 +45,21 @@ check_lineno( mrb_irep_debug_info_file *info_file, uint16_t lineno ) } static int32_t -get_break_index( mrb_debug_context *dbg, int32_t bpno ) +get_break_index(mrb_debug_context *dbg, uint32_t bpno) { uint32_t i; int32_t index; char hit = FALSE; for(i = 0 ; i < dbg->bpnum; i++) { - if(dbg->bp[i].bpno == bpno) { + if (dbg->bp[i].bpno == bpno) { hit = TRUE; index = i; break; } } - if(hit == FALSE) { + if (hit == FALSE) { return MRB_DEBUG_BREAK_INVALID_NO; } @@ -66,7 +67,7 @@ get_break_index( mrb_debug_context *dbg, int32_t bpno ) } static void -free_breakpoint( mrb_state *mrb, mrb_debug_breakpoint *bp ) +free_breakpoint(mrb_state *mrb, mrb_debug_breakpoint *bp) { switch(bp->type) { case MRB_DEBUG_BPTYPE_LINE: @@ -74,7 +75,7 @@ free_breakpoint( mrb_state *mrb, mrb_debug_breakpoint *bp ) break; case MRB_DEBUG_BPTYPE_METHOD: mrb_free(mrb, (void*)bp->point.methodpoint.method_name); - if(bp->point.methodpoint.class_name != NULL) { + if (bp->point.methodpoint.class_name != NULL) { mrb_free(mrb, (void*)bp->point.methodpoint.class_name); } break; @@ -84,7 +85,7 @@ free_breakpoint( mrb_state *mrb, mrb_debug_breakpoint *bp ) } static uint16_t -check_file_lineno( struct mrb_irep *irep, const char *file, uint16_t lineno ) +check_file_lineno(mrb_state *mrb, const struct mrb_irep *irep, const char *file, uint16_t lineno) { mrb_irep_debug_info_file *info_file; uint16_t result = 0; @@ -93,18 +94,20 @@ check_file_lineno( struct mrb_irep *irep, const char *file, uint16_t lineno ) uint16_t i; for (f_idx = 0; f_idx < irep->debug_info->flen; ++f_idx) { + const char *filename; info_file = irep->debug_info->files[f_idx]; - if(!strcmp(info_file->filename, file)) { + filename = mrb_sym_name_len(mrb, info_file->filename_sym, NULL); + if (!strcmp(filename, file)) { result = MRB_DEBUG_BP_FILE_OK; - fix_lineno = check_lineno( info_file, lineno ); - if(fix_lineno != 0) { + fix_lineno = check_lineno(info_file, lineno); + if (fix_lineno != 0) { return result | MRB_DEBUG_BP_LINENO_OK; } } - for ( i=0; i < irep->rlen; ++i ) { - result |= check_file_lineno(irep->reps[i], file, lineno); - if(result == (MRB_DEBUG_BP_FILE_OK | MRB_DEBUG_BP_LINENO_OK)) { + for (i=0; i < irep->rlen; ++i) { + result |= check_file_lineno(mrb, irep->reps[i], file, lineno); + if (result == (MRB_DEBUG_BP_FILE_OK | MRB_DEBUG_BP_LINENO_OK)) { return result; } } @@ -112,63 +115,52 @@ check_file_lineno( struct mrb_irep *irep, const char *file, uint16_t lineno ) return result; } -static const char* -get_class_name( mrb_state *mrb, struct RClass *class_obj ) -{ - struct RClass *outer; - mrb_sym class_sym; - - outer = mrb_class_outer_module(mrb, class_obj); - class_sym = mrb_class_sym(mrb, class_obj, outer); - return mrb_sym2name(mrb, class_sym); -} - static int32_t -compare_break_method( mrb_state *mrb, mrb_debug_breakpoint *bp, struct RClass *class_obj, mrb_sym method_sym, mrb_bool* isCfunc ) +compare_break_method(mrb_state *mrb, mrb_debug_breakpoint *bp, struct RClass *class_obj, mrb_sym method_sym, mrb_bool* isCfunc) { const char* class_name; const char* method_name; - struct RProc* m; + mrb_method_t m; struct RClass* sc; const char* sn; mrb_sym ssym; mrb_debug_methodpoint *method_p; mrb_bool is_defined; - method_name = mrb_sym2name(mrb, method_sym); + method_name = mrb_sym_name(mrb, method_sym); method_p = &bp->point.methodpoint; - if(strcmp(method_p->method_name, method_name) == 0) { - class_name = get_class_name(mrb, class_obj); - if(class_name == NULL) { - if(method_p->class_name == NULL) { + if (strcmp(method_p->method_name, method_name) == 0) { + class_name = mrb_class_name(mrb, class_obj); + if (class_name == NULL) { + if (method_p->class_name == NULL) { return bp->bpno; } } - else if(method_p->class_name != NULL) { + else if (method_p->class_name != NULL) { m = mrb_method_search_vm(mrb, &class_obj, method_sym); - if(m == NULL) { + if (MRB_METHOD_UNDEF_P(m)) { return MRB_DEBUG_OK; } - if(MRB_PROC_CFUNC_P(m)) { + if (MRB_METHOD_CFUNC_P(m)) { *isCfunc = TRUE; } is_defined = mrb_class_defined(mrb, method_p->class_name); - if(is_defined == FALSE) { + if (is_defined == FALSE) { return MRB_DEBUG_OK; } sc = mrb_class_get(mrb, method_p->class_name); - ssym = mrb_symbol(mrb_check_intern_cstr(mrb, method_p->method_name)); + ssym = mrb_intern_check_cstr(mrb, method_p->method_name); m = mrb_method_search_vm(mrb, &sc, ssym); - if(m == NULL) { + if (MRB_METHOD_UNDEF_P(m)) { return MRB_DEBUG_OK; } - class_name = get_class_name(mrb, class_obj); - sn = get_class_name(mrb, sc); - if(strcmp(sn, class_name) == 0) { + class_name = mrb_class_name(mrb, class_obj); + sn = mrb_class_name(mrb, sc); + if (strcmp(sn, class_name) == 0) { return bp->bpno; } } @@ -177,36 +169,36 @@ compare_break_method( mrb_state *mrb, mrb_debug_breakpoint *bp, struct RClass *c } int32_t -mrb_debug_set_break_line( mrb_state *mrb, mrb_debug_context *dbg, const char *file, uint16_t lineno) +mrb_debug_set_break_line(mrb_state *mrb, mrb_debug_context *dbg, const char *file, uint16_t lineno) { int32_t index; char* set_file; uint16_t result; + size_t len; - if((mrb == NULL)||(dbg == NULL)||(file == NULL)) { + if ((mrb == NULL)||(dbg == NULL)||(file == NULL)) { return MRB_DEBUG_INVALID_ARGUMENT; } - if(dbg->bpnum >= MAX_BREAKPOINT) { + if (dbg->bpnum >= MAX_BREAKPOINT) { return MRB_DEBUG_BREAK_NUM_OVER; } - if(dbg->next_bpno > MAX_BREAKPOINTNO) { + if (dbg->next_bpno > MAX_BREAKPOINTNO) { return MRB_DEBUG_BREAK_NO_OVER; } /* file and lineno check (line type mrb_debug_line_ary only.) */ - result = check_file_lineno( dbg->root_irep, file, lineno ); - if(result == 0) { + result = check_file_lineno(mrb, dbg->root_irep, file, lineno); + if (result == 0) { return MRB_DEBUG_BREAK_INVALID_FILE; - }else if(result == MRB_DEBUG_BP_FILE_OK) { + } + else if (result == MRB_DEBUG_BP_FILE_OK) { return MRB_DEBUG_BREAK_INVALID_LINENO; - } + } + len = strlen(file) + 1; set_file = mrb_debug_strdup(mrb, file); - if(set_file == NULL) { - return MRB_DEBUG_NOBUF; - } index = dbg->bpnum; dbg->bp[index].bpno = dbg->next_bpno; @@ -222,40 +214,34 @@ mrb_debug_set_break_line( mrb_state *mrb, mrb_debug_context *dbg, const char *fi } int32_t -mrb_debug_set_break_method( mrb_state *mrb, mrb_debug_context *dbg, const char *class_name, const char *method_name ) +mrb_debug_set_break_method(mrb_state *mrb, mrb_debug_context *dbg, const char *class_name, const char *method_name) { int32_t index; char* set_class; char* set_method; - if((mrb == NULL) || (dbg == NULL) || (method_name == NULL)) { + if ((mrb == NULL) || (dbg == NULL) || (method_name == NULL)) { return MRB_DEBUG_INVALID_ARGUMENT; } - if(dbg->bpnum >= MAX_BREAKPOINT) { + if (dbg->bpnum >= MAX_BREAKPOINT) { return MRB_DEBUG_BREAK_NUM_OVER; } - if(dbg->next_bpno > MAX_BREAKPOINTNO) { + if (dbg->next_bpno > MAX_BREAKPOINTNO) { return MRB_DEBUG_BREAK_NO_OVER; } - if(class_name != NULL) { + if (class_name != NULL) { set_class = mrb_debug_strdup(mrb, class_name); - if(set_class == NULL) { - return MRB_DEBUG_NOBUF; - } } else { set_class = NULL; } set_method = mrb_debug_strdup(mrb, method_name); - if(set_method == NULL) { - if(set_class != NULL) { - mrb_free(mrb, (void*)set_class); - } - return MRB_DEBUG_NOBUF; + if (set_method == NULL) { + mrb_free(mrb, set_class); } index = dbg->bpnum; @@ -271,25 +257,25 @@ mrb_debug_set_break_method( mrb_state *mrb, mrb_debug_context *dbg, const char * } int32_t -mrb_debug_get_breaknum( mrb_state *mrb, mrb_debug_context *dbg ) +mrb_debug_get_breaknum(mrb_state *mrb, mrb_debug_context *dbg) { - if((mrb == NULL) || (dbg == NULL)) { + if ((mrb == NULL) || (dbg == NULL)) { return MRB_DEBUG_INVALID_ARGUMENT; } return dbg->bpnum; } -int32_t -mrb_debug_get_break_all( mrb_state *mrb, mrb_debug_context *dbg, uint32_t size, mrb_debug_breakpoint *bp ) +int32_t +mrb_debug_get_break_all(mrb_state *mrb, mrb_debug_context *dbg, uint32_t size, mrb_debug_breakpoint *bp) { uint32_t get_size = 0; - if((mrb == NULL) || (dbg == NULL) || (bp == NULL)) { + if ((mrb == NULL) || (dbg == NULL) || (bp == NULL)) { return MRB_DEBUG_INVALID_ARGUMENT; } - if(dbg->bpnum >= size) { + if (dbg->bpnum >= size) { get_size = size; } else { @@ -302,16 +288,16 @@ mrb_debug_get_break_all( mrb_state *mrb, mrb_debug_context *dbg, uint32_t size, } int32_t -mrb_debug_get_break( mrb_state *mrb, mrb_debug_context *dbg, uint32_t bpno, mrb_debug_breakpoint *bp ) +mrb_debug_get_break(mrb_state *mrb, mrb_debug_context *dbg, uint32_t bpno, mrb_debug_breakpoint *bp) { - uint32_t index; + int32_t index; - if((mrb == NULL) || (dbg == NULL) || (bp == NULL)) { + if ((mrb == NULL) || (dbg == NULL) || (bp == NULL)) { return MRB_DEBUG_INVALID_ARGUMENT; } index = get_break_index(dbg, bpno); - if(index == MRB_DEBUG_BREAK_INVALID_NO) { + if (index == MRB_DEBUG_BREAK_INVALID_NO) { return MRB_DEBUG_BREAK_INVALID_NO; } @@ -323,25 +309,25 @@ mrb_debug_get_break( mrb_state *mrb, mrb_debug_context *dbg, uint32_t bpno, mrb_ return 0; } -int32_t -mrb_debug_delete_break( mrb_state *mrb, mrb_debug_context *dbg, uint32_t bpno ) +int32_t +mrb_debug_delete_break(mrb_state *mrb, mrb_debug_context *dbg, uint32_t bpno) { uint32_t i; int32_t index; - if((mrb == NULL) ||(dbg == NULL)) { + if ((mrb == NULL) ||(dbg == NULL)) { return MRB_DEBUG_INVALID_ARGUMENT; } index = get_break_index(dbg, bpno); - if(index == MRB_DEBUG_BREAK_INVALID_NO) { + if (index == MRB_DEBUG_BREAK_INVALID_NO) { return MRB_DEBUG_BREAK_INVALID_NO; } free_breakpoint(mrb, &dbg->bp[index]); for(i = index ; i < dbg->bpnum; i++) { - if(dbg->bp[i + 1].type == MRB_DEBUG_BPTYPE_NONE) { + if ((i + 1) == dbg->bpnum) { memset(&dbg->bp[i], 0, sizeof(mrb_debug_breakpoint)); } else { @@ -354,12 +340,12 @@ mrb_debug_delete_break( mrb_state *mrb, mrb_debug_context *dbg, uint32_t bpno ) return MRB_DEBUG_OK; } -int32_t -mrb_debug_delete_break_all( mrb_state *mrb, mrb_debug_context *dbg ) +int32_t +mrb_debug_delete_break_all(mrb_state *mrb, mrb_debug_context *dbg) { uint32_t i; - if((mrb == NULL) || (dbg == NULL)) { + if ((mrb == NULL) || (dbg == NULL)) { return MRB_DEBUG_INVALID_ARGUMENT; } @@ -372,17 +358,17 @@ mrb_debug_delete_break_all( mrb_state *mrb, mrb_debug_context *dbg ) return MRB_DEBUG_OK; } -int32_t -mrb_debug_enable_break( mrb_state *mrb, mrb_debug_context *dbg, uint32_t bpno ) +int32_t +mrb_debug_enable_break(mrb_state *mrb, mrb_debug_context *dbg, uint32_t bpno) { int32_t index = 0; - if((mrb == NULL) || (dbg == NULL)) { + if ((mrb == NULL) || (dbg == NULL)) { return MRB_DEBUG_INVALID_ARGUMENT; } index = get_break_index(dbg, bpno); - if(index == MRB_DEBUG_BREAK_INVALID_NO) { + if (index == MRB_DEBUG_BREAK_INVALID_NO) { return MRB_DEBUG_BREAK_INVALID_NO; } @@ -392,11 +378,11 @@ mrb_debug_enable_break( mrb_state *mrb, mrb_debug_context *dbg, uint32_t bpno ) } int32_t -mrb_debug_enable_break_all( mrb_state *mrb, mrb_debug_context *dbg ) +mrb_debug_enable_break_all(mrb_state *mrb, mrb_debug_context *dbg) { uint32_t i; - if((mrb == NULL) || (dbg == NULL)) { + if ((mrb == NULL) || (dbg == NULL)) { return MRB_DEBUG_INVALID_ARGUMENT; } @@ -407,17 +393,17 @@ mrb_debug_enable_break_all( mrb_state *mrb, mrb_debug_context *dbg ) return MRB_DEBUG_OK; } -int32_t -mrb_debug_disable_break( mrb_state *mrb, mrb_debug_context *dbg, uint32_t bpno ) +int32_t +mrb_debug_disable_break(mrb_state *mrb, mrb_debug_context *dbg, uint32_t bpno) { int32_t index = 0; - if((mrb == NULL) || (dbg == NULL)) { + if ((mrb == NULL) || (dbg == NULL)) { return MRB_DEBUG_INVALID_ARGUMENT; } index = get_break_index(dbg, bpno); - if(index == MRB_DEBUG_BREAK_INVALID_NO) { + if (index == MRB_DEBUG_BREAK_INVALID_NO) { return MRB_DEBUG_BREAK_INVALID_NO; } @@ -426,12 +412,12 @@ mrb_debug_disable_break( mrb_state *mrb, mrb_debug_context *dbg, uint32_t bpno ) return MRB_DEBUG_OK; } -int32_t -mrb_debug_disable_break_all( mrb_state *mrb, mrb_debug_context *dbg ) +int32_t +mrb_debug_disable_break_all(mrb_state *mrb, mrb_debug_context *dbg) { uint32_t i; - if((mrb == NULL) || (dbg == NULL)) { + if ((mrb == NULL) || (dbg == NULL)) { return MRB_DEBUG_INVALID_ARGUMENT; } @@ -443,10 +429,10 @@ mrb_debug_disable_break_all( mrb_state *mrb, mrb_debug_context *dbg ) } static mrb_bool -check_start_pc_for_line( mrb_irep *irep, mrb_code *pc, uint16_t line ) +check_start_pc_for_line(mrb_state *mrb, const mrb_irep *irep, const mrb_code *pc, uint16_t line) { - if( pc > irep->iseq ) { - if( line == mrb_debug_get_line(irep, (uint32_t)(pc - irep->iseq - 1))) { + if (pc > irep->iseq) { + if (line == mrb_debug_get_line(mrb, irep, pc - irep->iseq - 1)) { return FALSE; } } @@ -454,27 +440,27 @@ check_start_pc_for_line( mrb_irep *irep, mrb_code *pc, uint16_t line ) } int32_t -mrb_debug_check_breakpoint_line( mrb_state *mrb, mrb_debug_context *dbg, const char *file, uint16_t line ) +mrb_debug_check_breakpoint_line(mrb_state *mrb, mrb_debug_context *dbg, const char *file, uint16_t line) { mrb_debug_breakpoint *bp; mrb_debug_linepoint *line_p; - int i; + uint32_t i; - if((mrb == NULL) || (dbg == NULL) || (file == NULL) || (line <= 0)) { + if ((mrb == NULL) || (dbg == NULL) || (file == NULL) || (line <= 0)) { return MRB_DEBUG_INVALID_ARGUMENT; } - if(!check_start_pc_for_line(dbg->irep, dbg->pc, line)) { + if (!check_start_pc_for_line(mrb, dbg->irep, dbg->pc, line)) { return MRB_DEBUG_OK; } bp = dbg->bp; - for(i=0; i<MAX_BREAKPOINT; i++) { + for(i=0; i<dbg->bpnum; i++) { switch (bp->type) { case MRB_DEBUG_BPTYPE_LINE: - if(bp->enable == TRUE) { + if (bp->enable == TRUE) { line_p = &bp->point.linepoint; - if((strcmp(line_p->file, file) == 0) && (line_p->lineno == line)) { + if ((strcmp(line_p->file, file) == 0) && (line_p->lineno == line)) { return bp->bpno; } } @@ -491,28 +477,28 @@ mrb_debug_check_breakpoint_line( mrb_state *mrb, mrb_debug_context *dbg, const c } -int32_t -mrb_debug_check_breakpoint_method( mrb_state *mrb, mrb_debug_context *dbg, struct RClass *class_obj, mrb_sym method_sym, mrb_bool* isCfunc ) +int32_t +mrb_debug_check_breakpoint_method(mrb_state *mrb, mrb_debug_context *dbg, struct RClass *class_obj, mrb_sym method_sym, mrb_bool* isCfunc) { mrb_debug_breakpoint *bp; int32_t bpno; - int i; + uint32_t i; - if((mrb == NULL) || (dbg == NULL) || (class_obj == NULL)) { + if ((mrb == NULL) || (dbg == NULL) || (class_obj == NULL)) { return MRB_DEBUG_INVALID_ARGUMENT; } bp = dbg->bp; - for(i=0; i<MAX_BREAKPOINT; i++) { - if(bp->type == MRB_DEBUG_BPTYPE_METHOD) { - if(bp->enable == TRUE) { + for(i=0; i<dbg->bpnum; i++) { + if (bp->type == MRB_DEBUG_BPTYPE_METHOD) { + if (bp->enable == TRUE) { bpno = compare_break_method(mrb, bp, class_obj, method_sym, isCfunc); - if(bpno > 0) { + if (bpno > 0) { return bpno; } } } - else if(bp->type == MRB_DEBUG_BPTYPE_NONE) { + else if (bp->type == MRB_DEBUG_BPTYPE_NONE) { break; } bp++; @@ -520,5 +506,3 @@ mrb_debug_check_breakpoint_method( mrb_state *mrb, mrb_debug_context *dbg, struc return 0; } - - diff --git a/mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.h b/mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.h index 8bb39cb50..08f1d8080 100755..100644 --- a/mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.h +++ b/mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.h @@ -6,21 +6,21 @@ #ifndef APIBREAK_H_ #define APIBREAK_H_ -#include "mruby.h" +#include <mruby.h> #include "mrdb.h" -int32_t mrb_debug_set_break_line( mrb_state *, mrb_debug_context *, const char *, uint16_t ); -int32_t mrb_debug_set_break_method( mrb_state *, mrb_debug_context *, const char *, const char * ); -int32_t mrb_debug_get_breaknum( mrb_state *, mrb_debug_context * ); -int32_t mrb_debug_get_break_all( mrb_state *, mrb_debug_context *, uint32_t, mrb_debug_breakpoint bp[]); -int32_t mrb_debug_get_break( mrb_state *, mrb_debug_context *, uint32_t, mrb_debug_breakpoint * ); -int32_t mrb_debug_delete_break( mrb_state *, mrb_debug_context *, uint32_t ); -int32_t mrb_debug_delete_break_all( mrb_state *, mrb_debug_context * ); -int32_t mrb_debug_enable_break( mrb_state *, mrb_debug_context *, uint32_t ); -int32_t mrb_debug_enable_break_all( mrb_state *, mrb_debug_context * ); -int32_t mrb_debug_disable_break( mrb_state *, mrb_debug_context *, uint32_t ); -int32_t mrb_debug_disable_break_all( mrb_state *, mrb_debug_context * ); -int32_t mrb_debug_check_breakpoint_line( mrb_state *, mrb_debug_context *, const char *, uint16_t ); -int32_t mrb_debug_check_breakpoint_method( mrb_state *, mrb_debug_context *, struct RClass *, mrb_sym, mrb_bool* ); +int32_t mrb_debug_set_break_line(mrb_state *, mrb_debug_context *, const char *, uint16_t); +int32_t mrb_debug_set_break_method(mrb_state *, mrb_debug_context *, const char *, const char *); +int32_t mrb_debug_get_breaknum(mrb_state *, mrb_debug_context *); +int32_t mrb_debug_get_break_all(mrb_state *, mrb_debug_context *, uint32_t, mrb_debug_breakpoint bp[]); +int32_t mrb_debug_get_break(mrb_state *, mrb_debug_context *, uint32_t, mrb_debug_breakpoint *); +int32_t mrb_debug_delete_break(mrb_state *, mrb_debug_context *, uint32_t); +int32_t mrb_debug_delete_break_all(mrb_state *, mrb_debug_context *); +int32_t mrb_debug_enable_break(mrb_state *, mrb_debug_context *, uint32_t); +int32_t mrb_debug_enable_break_all(mrb_state *, mrb_debug_context *); +int32_t mrb_debug_disable_break(mrb_state *, mrb_debug_context *, uint32_t); +int32_t mrb_debug_disable_break_all(mrb_state *, mrb_debug_context *); +int32_t mrb_debug_check_breakpoint_line(mrb_state *, mrb_debug_context *, const char *, uint16_t); +int32_t mrb_debug_check_breakpoint_method(mrb_state *, mrb_debug_context *, struct RClass *, mrb_sym, mrb_bool*); #endif /* APIBREAK_H_ */ diff --git a/mrbgems/mruby-bin-debugger/tools/mrdb/apilist.c b/mrbgems/mruby-bin-debugger/tools/mrdb/apilist.c index 8eddc7b78..ef80872e5 100755..100644 --- a/mrbgems/mruby-bin-debugger/tools/mrdb/apilist.c +++ b/mrbgems/mruby-bin-debugger/tools/mrdb/apilist.c @@ -10,9 +10,9 @@ #include "mrdberror.h" #include "apilist.h" #include "apistring.h" -#include "mruby/compile.h" -#include "mruby/irep.h" -#include "mruby/debug.h" +#include <mruby/compile.h> +#include <mruby/irep.h> +#include <mruby/debug.h> #define LINE_BUF_SIZE MAX_COMMAND_LINE @@ -46,18 +46,18 @@ build_path(mrb_state *mrb, const char *dir, const char *base) len = strlen(base) + 1; if (strcmp(dir, ".")) { - len += strlen(dir) + strlen("/"); + len += strlen(dir) + sizeof("/") - 1; } - if ((path = mrb_malloc(mrb, len)) != NULL) { - memset(path, 0, len); + path = (char*)mrb_malloc(mrb, len); + memset(path, 0, len); - if (strcmp(dir, ".")) { - strcat(path, dir); - strcat(path, "/"); - } - strcat(path, base); + if (strcmp(dir, ".")) { + strcat(path, dir); + strcat(path, "/"); } + strcat(path, base); + return path; } @@ -65,14 +65,15 @@ static char* dirname(mrb_state *mrb, const char *path) { size_t len; - char *p; + const char *p; + char *dir; if (path == NULL) { return NULL; } p = strrchr(path, '/'); - len = p != NULL ? p - path : strlen(path); + len = p != NULL ? (size_t)(p - path) : strlen(path); return mrb_debug_strndup(mrb, path, len); } @@ -80,11 +81,9 @@ dirname(mrb_state *mrb, const char *path) static source_file* source_file_new(mrb_state *mrb, mrb_debug_context *dbg, char *filename) { - source_file *file = NULL; + source_file *file; - if ((file = mrb_malloc(mrb, sizeof(source_file))) == NULL) { - return NULL; - } + file = (source_file*)mrb_malloc(mrb, sizeof(source_file)); memset(file, '\0', sizeof(source_file)); file->fp = fopen(filename, "rb"); @@ -95,7 +94,8 @@ source_file_new(mrb_state *mrb, mrb_debug_context *dbg, char *filename) } file->lineno = 1; - if ((file->path = mrb_debug_strdup(mrb, filename)) == NULL) { + file->path = mrb_debug_strdup(mrb, filename); + if (file->path == NULL) { source_file_free(mrb, file); return NULL; } @@ -175,9 +175,13 @@ mrb_debug_get_source(mrb_state *mrb, mrdb_state *mrdb, const char *srcpath, cons FILE *fp; const char *search_path[3]; char *path = NULL; + const char *srcname = strrchr(filename, '/'); + + if (srcname) srcname++; + else srcname = filename; search_path[0] = srcpath; - search_path[1] = dirname(mrb, mrb_debug_get_filename(mrdb->dbg->root_irep, 0)); + search_path[1] = dirname(mrb, mrb_debug_get_filename(mrb, mrdb->dbg->irep, 0)); search_path[2] = "."; for (i = 0; i < 3; i++) { @@ -185,7 +189,7 @@ mrb_debug_get_source(mrb_state *mrb, mrdb_state *mrdb, const char *srcpath, cons continue; } - if ((path = build_path(mrb, search_path[i], filename)) == NULL) { + if ((path = build_path(mrb, search_path[i], srcname)) == NULL) { continue; } diff --git a/mrbgems/mruby-bin-debugger/tools/mrdb/apilist.h b/mrbgems/mruby-bin-debugger/tools/mrdb/apilist.h index 4580b2350..6c4107885 100755..100644 --- a/mrbgems/mruby-bin-debugger/tools/mrdb/apilist.h +++ b/mrbgems/mruby-bin-debugger/tools/mrdb/apilist.h @@ -5,7 +5,7 @@ #ifndef APILIST_H_ #define APILIST_H_ -#include "mruby.h" +#include <mruby.h> #include "mrdb.h" int32_t mrb_debug_list(mrb_state *, mrb_debug_context *, char *, uint16_t, uint16_t); diff --git a/mrbgems/mruby-bin-debugger/tools/mrdb/apiprint.c b/mrbgems/mruby-bin-debugger/tools/mrdb/apiprint.c index 2c93eb4ee..9093a4f0e 100755..100644 --- a/mrbgems/mruby-bin-debugger/tools/mrdb/apiprint.c +++ b/mrbgems/mruby-bin-debugger/tools/mrdb/apiprint.c @@ -5,12 +5,13 @@ #include <string.h> #include "mrdb.h" -#include "mruby/value.h" -#include "mruby/class.h" -#include "mruby/compile.h" -#include "mruby/error.h" -#include "mruby/numeric.h" -#include "mruby/string.h" +#include <mruby/value.h> +#include <mruby/class.h> +#include <mruby/compile.h> +#include <mruby/error.h> +#include <mruby/numeric.h> +#include <mruby/string.h> +#include <mruby/presym.h> #include "apiprint.h" static void @@ -21,7 +22,7 @@ mrdb_check_syntax(mrb_state *mrb, mrb_debug_context *dbg, const char *expr, size c = mrbc_context_new(mrb); c->no_exec = TRUE; c->capture_errors = TRUE; - c->filename = (char*)dbg->prvfile; + mrbc_filename(mrb, c, (const char*)dbg->prvfile); c->lineno = dbg->prvline; /* Load program */ @@ -31,9 +32,9 @@ mrdb_check_syntax(mrb_state *mrb, mrb_debug_context *dbg, const char *expr, size } mrb_value -mrb_debug_eval(mrb_state *mrb, mrb_debug_context *dbg, const char *expr, size_t len, mrb_bool *exc) +mrb_debug_eval(mrb_state *mrb, mrb_debug_context *dbg, const char *expr, size_t len, mrb_bool *exc, int direct_eval) { - void (*tmp)(struct mrb_state *, struct mrb_irep *, mrb_code *, mrb_value *); + void (*tmp)(struct mrb_state *, const struct mrb_irep *, const mrb_code *, mrb_value *); mrb_value ruby_code; mrb_value s; mrb_value v; @@ -48,6 +49,11 @@ mrb_debug_eval(mrb_state *mrb, mrb_debug_context *dbg, const char *expr, size_t v = mrb_obj_value(mrb->exc); mrb->exc = 0; } + else if (direct_eval) { + recv = dbg->regs[0]; + + v = mrb_funcall(mrb, recv, expr, 0); + } else { /* * begin @@ -62,14 +68,14 @@ mrb_debug_eval(mrb_state *mrb, mrb_debug_context *dbg, const char *expr, size_t recv = dbg->regs[0]; - v = mrb_funcall(mrb, recv, "instance_eval", 1, ruby_code); + v = mrb_funcall_id(mrb, recv, MRB_SYM(instance_eval), 1, ruby_code); } if (exc) { *exc = mrb_obj_is_kind_of(mrb, v, mrb->eException_class); } - s = mrb_funcall(mrb, v, "inspect", 0); + s = mrb_inspect(mrb, v); /* enable code_fetch_hook */ mrb->code_fetch_hook = tmp; diff --git a/mrbgems/mruby-bin-debugger/tools/mrdb/apiprint.h b/mrbgems/mruby-bin-debugger/tools/mrdb/apiprint.h index 81d685e0c..ab8c08869 100755..100644 --- a/mrbgems/mruby-bin-debugger/tools/mrdb/apiprint.h +++ b/mrbgems/mruby-bin-debugger/tools/mrdb/apiprint.h @@ -5,9 +5,9 @@ #ifndef APIPRINT_H_ #define APIPRINT_H_ -#include "mruby.h" +#include <mruby.h> #include "mrdb.h" -mrb_value mrb_debug_eval(mrb_state*, mrb_debug_context*, const char*, size_t, mrb_bool*); +mrb_value mrb_debug_eval(mrb_state*, mrb_debug_context*, const char*, size_t, mrb_bool*, int); #endif /* APIPRINT_H_ */ diff --git a/mrbgems/mruby-bin-debugger/tools/mrdb/cmdbreak.c b/mrbgems/mruby-bin-debugger/tools/mrdb/cmdbreak.c index 9764d4e07..bc9937e94 100755..100644 --- a/mrbgems/mruby-bin-debugger/tools/mrdb/cmdbreak.c +++ b/mrbgems/mruby-bin-debugger/tools/mrdb/cmdbreak.c @@ -5,10 +5,10 @@ #include <ctype.h> #include <string.h> -#include "mruby.h" -#include "mruby/dump.h" -#include "mruby/debug.h" -#include "mruby/string.h" +#include <mruby.h> +#include <mruby/dump.h> +#include <mruby/debug.h> +#include <mruby/string.h> #include "mrdb.h" #include "mrdberror.h" #include "apibreak.h" @@ -58,9 +58,11 @@ print_api_common_error(int32_t error) } #undef STRTOUL -#define STRTOUL(ul,s) \ +#define STRTOUL(ul,s) { \ + int i; \ ul = 0; \ - for(int i=0; ISDIGIT(s[i]); i++) ul = 10*ul + (s[i] -'0'); + for(i=0; ISDIGIT(s[i]); i++) ul = 10*ul + (s[i] -'0'); \ +} static int32_t parse_breakpoint_no(char* args) @@ -68,12 +70,12 @@ parse_breakpoint_no(char* args) char* ps = args; uint32_t l; - if((*ps == '0')||(strlen(ps) >= BPNO_LETTER_NUM)) { + if ((*ps == '0')||(strlen(ps) >= BPNO_LETTER_NUM)) { return 0; } - while( !(ISBLANK(*ps)||ISCNTRL(*ps)) ) { - if(!ISDIGIT(*ps)) { + while (!(ISBLANK(*ps)||ISCNTRL(*ps))) { + if (!ISDIGIT(*ps)) { return 0; } ps++; @@ -88,7 +90,7 @@ exe_set_command_all(mrb_state *mrb, mrdb_state *mrdb, all_command_func func) { int32_t ret = MRB_DEBUG_OK; - if(mrdb->wcnt == 1) { + if (mrdb->wcnt == 1) { ret = func(mrb, mrdb->dbg); print_api_common_error(ret); return TRUE; @@ -107,15 +109,15 @@ exe_set_command_select(mrb_state *mrb, mrdb_state *mrdb, select_command_func fun for(i=1; i<mrdb->wcnt; i++) { ps = mrdb->words[i]; bpno = parse_breakpoint_no(ps); - if(bpno == 0) { + if (bpno == 0) { printf(BREAK_ERR_MSG_INVALIDBPNO, ps); break; } ret = func(mrb, mrdb->dbg, (uint32_t)bpno); - if(ret == MRB_DEBUG_BREAK_INVALID_NO) { + if (ret == MRB_DEBUG_BREAK_INVALID_NO) { printf(BREAK_ERR_MSG_NOBPNO, bpno); } - else if(ret != MRB_DEBUG_OK) { + else if (ret != MRB_DEBUG_OK) { print_api_common_error(ret); } } @@ -126,24 +128,24 @@ check_bptype(char* args) { char* ps = args; - if(ISBLANK(*ps)||ISCNTRL(*ps)) { + if (ISBLANK(*ps)||ISCNTRL(*ps)) { puts(BREAK_ERR_MSG_BLANK); return MRB_DEBUG_BPTYPE_NONE; } - if(!ISDIGIT(*ps)) { + if (!ISDIGIT(*ps)) { return MRB_DEBUG_BPTYPE_METHOD; } - while( !(ISBLANK(*ps)||ISCNTRL(*ps)) ) { - if(!ISDIGIT(*ps)) { + while (!(ISBLANK(*ps)||ISCNTRL(*ps))) { + if (!ISDIGIT(*ps)) { printf(BREAK_ERR_MSG_INVALIDSTR, args); return MRB_DEBUG_BPTYPE_NONE; } ps++; } - if((*args == '0')||(strlen(args) >= LINENO_MAX_DIGIT)) { + if ((*args == '0')||(strlen(args) >= LINENO_MAX_DIGIT)) { puts(BREAK_ERR_MSG_RANGEOVER); return MRB_DEBUG_BPTYPE_NONE; } @@ -154,14 +156,14 @@ check_bptype(char* args) static void print_breakpoint(mrb_debug_breakpoint *bp) { - char* enable_letter[] = {BREAK_INFO_MSG_DISABLE, BREAK_INFO_MSG_ENABLE}; + const char* enable_letter[] = {BREAK_INFO_MSG_DISABLE, BREAK_INFO_MSG_ENABLE}; - if(bp->type == MRB_DEBUG_BPTYPE_LINE) { + if (bp->type == MRB_DEBUG_BPTYPE_LINE) { printf(BREAK_INFO_MSG_LINEBREAK, bp->bpno, enable_letter[bp->enable], bp->point.linepoint.file, bp->point.linepoint.lineno); } else { - if(bp->point.methodpoint.class_name == NULL) { + if (bp->point.methodpoint.class_name == NULL) { printf(BREAK_INFO_MSG_METHODBREAK_NOCLASS, bp->bpno, enable_letter[bp->enable], bp->point.methodpoint.method_name); } @@ -181,18 +183,18 @@ info_break_all(mrb_state *mrb, mrdb_state *mrdb) mrb_debug_breakpoint *bp_list; bpnum = mrb_debug_get_breaknum(mrb, mrdb->dbg); - if(bpnum < 0) { + if (bpnum < 0) { print_api_common_error(bpnum); return; } - else if(bpnum == 0) { + else if (bpnum == 0) { puts(BREAK_ERR_MSG_NOBPNO_INFOALL); return; } bp_list = (mrb_debug_breakpoint*)mrb_malloc(mrb, bpnum * sizeof(mrb_debug_breakpoint)); ret = mrb_debug_get_break_all(mrb, mrdb->dbg, (uint32_t)bpnum, bp_list); - if(ret < 0) { + if (ret < 0) { print_api_common_error(ret); return; } @@ -217,21 +219,21 @@ info_break_select(mrb_state *mrb, mrdb_state *mrdb) for(i=2; i<mrdb->wcnt; i++) { ps = mrdb->words[i]; bpno = parse_breakpoint_no(ps); - if(bpno == 0) { + if (bpno == 0) { puts(BREAK_ERR_MSG_INVALIDBPNO_INFO); break; } ret = mrb_debug_get_break(mrb, mrdb->dbg, bpno, &bp); - if(ret == MRB_DEBUG_BREAK_INVALID_NO) { + if (ret == MRB_DEBUG_BREAK_INVALID_NO) { printf(BREAK_ERR_MSG_NOBPNO_INFO, bpno); break; } - else if(ret != MRB_DEBUG_OK) { + else if (ret != MRB_DEBUG_OK) { print_api_common_error(ret); break; } - else if(isFirst == TRUE) { + else if (isFirst == TRUE) { isFirst = FALSE; puts(BREAK_INFO_MSG_HEADER); } @@ -240,7 +242,7 @@ info_break_select(mrb_state *mrb, mrdb_state *mrdb) } mrb_debug_bptype -parse_breakcommand(mrdb_state *mrdb, const char **file, uint32_t *line, char **cname, char **method) +parse_breakcommand(mrb_state *mrb, mrdb_state *mrdb, const char **file, uint32_t *line, char **cname, char **method) { mrb_debug_context *dbg = mrdb->dbg; char *args; @@ -248,17 +250,18 @@ parse_breakcommand(mrdb_state *mrdb, const char **file, uint32_t *line, char **c mrb_debug_bptype type; uint32_t l; - if(mrdb->wcnt <= 1) { + if (mrdb->wcnt <= 1) { puts(BREAK_ERR_MSG_BLANK); return MRB_DEBUG_BPTYPE_NONE; } args = mrdb->words[1]; - if((body = strchr(args, ':')) == NULL) { + if ((body = strrchr(args, ':')) == NULL) { body = args; type = check_bptype(body); - } else { - if(body == args) { + } + else { + if (body == args) { printf(BREAK_ERR_MSG_INVALIDSTR, args); return MRB_DEBUG_BPTYPE_NONE; } @@ -269,26 +272,29 @@ parse_breakcommand(mrdb_state *mrdb, const char **file, uint32_t *line, char **c switch(type) { case MRB_DEBUG_BPTYPE_LINE: STRTOUL(l, body); - if( l <= 65535 ) { + if (l <= 65535) { *line = l; - *file = (body == args)? mrb_debug_get_filename(dbg->irep, (uint32_t)(dbg->pc - dbg->irep->iseq)): args; - } else { + *file = (body == args)? mrb_debug_get_filename(mrb, dbg->irep, dbg->pc - dbg->irep->iseq): args; + } + else { puts(BREAK_ERR_MSG_RANGEOVER); type = MRB_DEBUG_BPTYPE_NONE; } break; case MRB_DEBUG_BPTYPE_METHOD: - if(body == args) { + if (body == args) { /* method only */ - if( ISUPPER(*body)||ISLOWER(*body)||(*body == '_') ) { + if (ISUPPER(*body)||ISLOWER(*body)||(*body == '_')) { *method = body; *cname = NULL; - } else { + } + else { printf(BREAK_ERR_MSG_INVALIDMETHOD, args); type = MRB_DEBUG_BPTYPE_NONE; } - } else { - if( ISUPPER(*args) ) { + } + else { + if (ISUPPER(*args)) { switch(*body) { case '@': case '$': case '?': case '.': case ',': case ':': case ';': case '#': case '\\': case '\'': case '\"': @@ -300,7 +306,8 @@ parse_breakcommand(mrdb_state *mrdb, const char **file, uint32_t *line, char **c *cname = args; break; } - } else { + } + else { printf(BREAK_ERR_MSG_INVALIDCLASS, args); type = MRB_DEBUG_BPTYPE_NONE; } @@ -325,7 +332,7 @@ dbgcmd_break(mrb_state *mrb, mrdb_state *mrdb) char *method = NULL; int32_t ret; - type = parse_breakcommand(mrdb, &file, &line, &cname, &method); + type = parse_breakcommand(mrb, mrdb, &file, &line, &cname, &method); switch (type) { case MRB_DEBUG_BPTYPE_LINE: ret = mrb_debug_set_break_line(mrb, dbg, file, line); @@ -341,12 +348,15 @@ dbgcmd_break(mrb_state *mrb, mrdb_state *mrdb) if (ret >= 0) { if (type == MRB_DEBUG_BPTYPE_LINE) { printf(BREAK_SET_MSG_LINE, ret, file, line); - } else if ((type == MRB_DEBUG_BPTYPE_METHOD)&&(cname == NULL)) { + } + else if ((type == MRB_DEBUG_BPTYPE_METHOD)&&(cname == NULL)) { printf(BREAK_SET_MSG_METHOD, ret, method); - } else { + } + else { printf(BREAK_SET_MSG_CLASS_METHOD, ret, cname, method); } - } else { + } + else { switch (ret) { case MRB_DEBUG_BREAK_INVALID_LINENO: printf(BREAK_ERR_MSG_INVALIDLINENO, line, file); @@ -377,7 +387,7 @@ dbgcmd_break(mrb_state *mrb, mrdb_state *mrdb) dbgcmd_state dbgcmd_info_break(mrb_state *mrb, mrdb_state *mrdb) { - if(mrdb->wcnt == 2) { + if (mrdb->wcnt == 2) { info_break_all(mrb, mrdb); } else { @@ -393,7 +403,7 @@ dbgcmd_delete(mrb_state *mrb, mrdb_state *mrdb) mrb_bool ret = FALSE; ret = exe_set_command_all(mrb, mrdb, mrb_debug_delete_break_all); - if(ret != TRUE) { + if (ret != TRUE) { exe_set_command_select(mrb, mrdb, mrb_debug_delete_break); } @@ -406,7 +416,7 @@ dbgcmd_enable(mrb_state *mrb, mrdb_state *mrdb) mrb_bool ret = FALSE; ret = exe_set_command_all(mrb, mrdb, mrb_debug_enable_break_all); - if(ret != TRUE) { + if (ret != TRUE) { exe_set_command_select(mrb, mrdb, mrb_debug_enable_break); } @@ -419,7 +429,7 @@ dbgcmd_disable(mrb_state *mrb, mrdb_state *mrdb) mrb_bool ret = FALSE; ret = exe_set_command_all(mrb, mrdb, mrb_debug_disable_break_all); - if(ret != TRUE) { + if (ret != TRUE) { exe_set_command_select(mrb, mrdb, mrb_debug_disable_break); } return DBGST_PROMPT; diff --git a/mrbgems/mruby-bin-debugger/tools/mrdb/cmdmisc.c b/mrbgems/mruby-bin-debugger/tools/mrdb/cmdmisc.c index 7b0806eff..fde65fbef 100755..100644 --- a/mrbgems/mruby-bin-debugger/tools/mrdb/cmdmisc.c +++ b/mrbgems/mruby-bin-debugger/tools/mrdb/cmdmisc.c @@ -9,7 +9,7 @@ #include "apilist.h" #include "apistring.h" -#include "mruby/compile.h" +#include <mruby/compile.h> typedef struct help_msg { const char *cmd1; @@ -34,7 +34,7 @@ static help_msg help_msg_list[] = { "\n" "Continue program stopped by a breakpoint.\n" "If N, which is non negative value, is passed,\n" - "proceed program until the N-th breakpoint is comming.\n" + "proceed program until the N-th breakpoint is coming.\n" "If N is not passed, N is assumed 1.\n" }, { @@ -83,6 +83,12 @@ static help_msg help_msg_list[] = { "Arguments are breakpoint numbers with spaces in between.\n" }, { + "i[nfo]", "l[ocals]", "Print name of local variables", + "Usage: info locals\n" + "\n" + "Print name of local variables.\n" + }, + { "l[ist]", NULL, "List specified line", "Usage: list\n" " list first[,last]\n" @@ -134,7 +140,7 @@ typedef struct listcmd_parser_state { static listcmd_parser_state* listcmd_parser_state_new(mrb_state *mrb) { - listcmd_parser_state *st = mrb_malloc(mrb, sizeof(listcmd_parser_state)); + listcmd_parser_state *st = (listcmd_parser_state*)mrb_malloc(mrb, sizeof(listcmd_parser_state)); memset(st, 0, sizeof(listcmd_parser_state)); return st; } @@ -240,7 +246,8 @@ char* replace_ext(mrb_state *mrb, const char *filename, const char *ext) { size_t len; - char *p, *s; + const char *p; + char *s; if (filename == NULL) { return NULL; @@ -253,11 +260,11 @@ replace_ext(mrb_state *mrb, const char *filename, const char *ext) len = strlen(filename); } - if ((s = mrb_malloc(mrb, len + strlen(ext) + 1)) != NULL) { - memset(s, '\0', len + strlen(ext) + 1); - strncpy(s, filename, len); - strcat(s, ext); - } + s = (char*)mrb_malloc(mrb, len + strlen(ext) + 1); + memset(s, '\0', len + strlen(ext) + 1); + strncpy(s, filename, len); + strcat(s, ext); + return s; } @@ -323,7 +330,7 @@ parse_listcmd_args(mrb_state *mrb, mrdb_state *mrdb, listcmd_parser_state *st) static mrb_bool check_cmd_pattern(const char *pattern, const char *cmd) { - char *lbracket, *rbracket, *p, *q; + const char *lbracket, *rbracket, *p, *q; if (pattern == NULL && cmd == NULL) { return TRUE; @@ -331,7 +338,7 @@ check_cmd_pattern(const char *pattern, const char *cmd) if (pattern == NULL || cmd == NULL) { return FALSE; } - if((lbracket = strchr(pattern, '[')) == NULL) { + if ((lbracket = strchr(pattern, '[')) == NULL) { return !strcmp(pattern, cmd); } if ((rbracket = strchr(pattern, ']')) == NULL) { @@ -464,6 +471,7 @@ dbgcmd_quit(mrb_state *mrb, mrdb_state *mrdb) int buf; printf("The program is running. Exit anyway? (y or n) "); + fflush(stdout); if ((buf = getchar()) == EOF) { mrdb->dbg->xm = DBG_QUIT; @@ -491,8 +499,8 @@ dbgcmd_quit(mrb_state *mrb, mrdb_state *mrdb) if (mrdb->dbg->xm == DBG_QUIT) { struct RClass *exc; - exc = mrb_define_class(mrb, "DebuggerExit", mrb_class_get(mrb, "Exception")); - mrb_raise(mrb, exc, "Exit mrdb."); + exc = mrb_define_class(mrb, "DebuggerExit", mrb->eException_class); + mrb_raise(mrb, exc, "Exit mrdb"); } return DBGST_PROMPT; } diff --git a/mrbgems/mruby-bin-debugger/tools/mrdb/cmdprint.c b/mrbgems/mruby-bin-debugger/tools/mrdb/cmdprint.c index a617aff13..f78c1e1fc 100755..100644 --- a/mrbgems/mruby-bin-debugger/tools/mrdb/cmdprint.c +++ b/mrbgems/mruby-bin-debugger/tools/mrdb/cmdprint.c @@ -5,12 +5,12 @@ #include <string.h> #include "mrdb.h" -#include "mruby/value.h" -#include "mruby/class.h" -#include "mruby/compile.h" -#include "mruby/error.h" -#include "mruby/numeric.h" -#include "mruby/string.h" +#include <mruby/value.h> +#include <mruby/class.h> +#include <mruby/compile.h> +#include <mruby/error.h> +#include <mruby/numeric.h> +#include <mruby/string.h> #include "apiprint.h" dbgcmd_state @@ -18,7 +18,6 @@ dbgcmd_print(mrb_state *mrb, mrdb_state *mrdb) { mrb_value expr; mrb_value result; - mrb_value s; uint8_t wcnt; int ai; @@ -36,11 +35,12 @@ dbgcmd_print(mrb_state *mrb, mrdb_state *mrdb) expr = mrb_str_cat_cstr(mrb, expr, mrdb->words[wcnt]); } - result = mrb_debug_eval(mrb, mrdb->dbg, RSTRING_PTR(expr), RSTRING_LEN(expr), NULL); + result = mrb_debug_eval(mrb, mrdb->dbg, RSTRING_PTR(expr), RSTRING_LEN(expr), NULL, 0); /* $print_no = result */ - s = mrb_str_cat_lit(mrb, result, "\0"); - printf("$%lu = %s\n", (unsigned long)mrdb->print_no++, RSTRING_PTR(s)); + printf("$%lu = ", (unsigned long)mrdb->print_no++); + fwrite(RSTRING_PTR(result), RSTRING_LEN(result), 1, stdout); + putc('\n', stdout); if (mrdb->print_no == 0) { mrdb->print_no = 1; @@ -56,3 +56,26 @@ dbgcmd_eval(mrb_state *mrb, mrdb_state *mrdb) { return dbgcmd_print(mrb, mrdb); } + +dbgcmd_state +dbgcmd_info_local(mrb_state *mrb, mrdb_state *mrdb) +{ + mrb_value result; + mrb_value s; + int ai; + + ai = mrb_gc_arena_save(mrb); + + result = mrb_debug_eval(mrb, mrdb->dbg, "local_variables", 0, NULL, 1); + + s = mrb_str_cat_lit(mrb, result, "\0"); + printf("$%lu = %s\n", (unsigned long)mrdb->print_no++, RSTRING_PTR(s)); + + if (mrdb->print_no == 0) { + mrdb->print_no = 1; + } + + mrb_gc_arena_restore(mrb, ai); + + return DBGST_PROMPT; +} diff --git a/mrbgems/mruby-bin-debugger/tools/mrdb/cmdrun.c b/mrbgems/mruby-bin-debugger/tools/mrdb/cmdrun.c index 8d8340560..fe8cf0aa7 100755..100644 --- a/mrbgems/mruby-bin-debugger/tools/mrdb/cmdrun.c +++ b/mrbgems/mruby-bin-debugger/tools/mrdb/cmdrun.c @@ -3,7 +3,7 @@ ** */ -#include "mruby/opcode.h" +#include <mruby/opcode.h> #include "mrdb.h" dbgcmd_state @@ -11,18 +11,19 @@ dbgcmd_run(mrb_state *mrb, mrdb_state *mrdb) { mrb_debug_context *dbg = mrdb->dbg; - if( dbg->xm == DBG_INIT ){ + if (dbg->xm == DBG_INIT){ dbg->xm = DBG_RUN; - } else { + } + else { dbg->xm = DBG_QUIT; - if( dbg->xphase == DBG_PHASE_RUNNING ){ + if (dbg->xphase == DBG_PHASE_RUNNING){ struct RClass *exc; - puts("Start it from the beginning."); - exc = mrb_define_class(mrb, "DebuggerRestart", mrb_class_get(mrb, "Exception")); - mrb_raise(mrb, exc, "Restart mrdb."); + puts("Start it from the beginning"); + exc = mrb_define_class(mrb, "DebuggerRestart", mrb->eException_class); + mrb_raise(mrb, exc, "Restart mrdb"); } } - + return DBGST_RESTART; } @@ -32,15 +33,16 @@ dbgcmd_continue(mrb_state *mrb, mrdb_state *mrdb) mrb_debug_context *dbg = mrdb->dbg; int ccnt = 1; - if( mrdb->wcnt > 1 ){ + if (mrdb->wcnt > 1){ sscanf(mrdb->words[1], "%d", &ccnt); } dbg->ccnt = (uint16_t)(ccnt > 0 ? ccnt : 1); /* count of continue */ - if( dbg->xphase == DBG_PHASE_AFTER_RUN ){ + if (dbg->xphase == DBG_PHASE_AFTER_RUN){ puts("The program is not running."); dbg->xm = DBG_QUIT; - } else { + } + else { dbg->xm = DBG_RUN; } return DBGST_CONTINUE; @@ -52,3 +54,11 @@ dbgcmd_step(mrb_state *mrb, mrdb_state *mrdb) mrdb->dbg->xm = DBG_STEP; return DBGST_CONTINUE; } + +dbgcmd_state +dbgcmd_next(mrb_state *mrb, mrdb_state *mrdb) +{ + mrdb->dbg->xm = DBG_NEXT; + mrdb->dbg->prvci = mrb->c->ci; + return DBGST_CONTINUE; +} diff --git a/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.c b/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.c index a0969a3ac..009cd955c 100755..100644 --- a/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.c +++ b/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.c @@ -5,22 +5,20 @@ #include <stdlib.h> #include <string.h> -#include <stdio.h> #include <ctype.h> -#include "mruby.h" -#include "mruby/dump.h" -#include "mruby/debug.h" -#include "mruby/class.h" -#include "mruby/opcode.h" -#include "mruby/variable.h" +#include <mruby.h> +#include <mruby/dump.h> +#include <mruby/debug.h> +#include <mruby/class.h> +#include <mruby/opcode.h> +#include <mruby/variable.h> +#include <mruby/proc.h> #include "mrdb.h" #include "apibreak.h" #include "apilist.h" -void mrb_show_version(mrb_state *); -void mrb_show_copyright(mrb_state *); void mrdb_state_free(mrb_state *); static mrb_debug_context *_debug_context = NULL; @@ -54,11 +52,13 @@ static const debug_command debug_command_list[] = { {"eval", NULL, 2, 0, 0, DBGCMD_EVAL, dbgcmd_eval}, /* ev[al] */ {"help", NULL, 1, 0, 1, DBGCMD_HELP, dbgcmd_help}, /* h[elp] */ {"info", "breakpoints", 1, 1, 1, DBGCMD_INFO_BREAK, dbgcmd_info_break}, /* i[nfo] b[reakpoints] */ + {"info", "locals", 1, 1, 0, DBGCMD_INFO_LOCAL, dbgcmd_info_local}, /* i[nfo] l[ocals] */ {"list", NULL, 1, 0, 1, DBGCMD_LIST, dbgcmd_list}, /* l[ist] */ {"print", NULL, 1, 0, 0, DBGCMD_PRINT, dbgcmd_print}, /* p[rint] */ {"quit", NULL, 1, 0, 0, DBGCMD_QUIT, dbgcmd_quit}, /* q[uit] */ {"run", NULL, 1, 0, 0, DBGCMD_RUN, dbgcmd_run}, /* r[un] */ {"step", NULL, 1, 0, 1, DBGCMD_STEP, dbgcmd_step}, /* s[tep] */ + {"next", NULL, 1, 0, 1, DBGCMD_NEXT, dbgcmd_next}, /* n[ext] */ {NULL} }; @@ -185,7 +185,7 @@ cleanup(mrb_state *mrb, struct _args *args) static mrb_debug_context* mrb_debug_context_new(mrb_state *mrb) { - mrb_debug_context *dbg = mrb_malloc(mrb, sizeof(mrb_debug_context)); + mrb_debug_context *dbg = (mrb_debug_context*)mrb_malloc(mrb, sizeof(mrb_debug_context)); memset(dbg, 0, sizeof(mrb_debug_context)); @@ -224,12 +224,12 @@ mrb_debug_context_free(mrb_state *mrb) static mrdb_state* mrdb_state_new(mrb_state *mrb) { - mrdb_state *mrdb = mrb_malloc(mrb, sizeof(mrb_state)); + mrdb_state *mrdb = (mrdb_state*)mrb_malloc(mrb, sizeof(mrdb_state)); - memset(mrdb, 0, sizeof(mrb_state)); + memset(mrdb, 0, sizeof(mrdb_state)); mrdb->dbg = mrb_debug_context_get(mrb); - mrdb->command = mrb_malloc(mrb, MAX_COMMAND_LINE+1); + mrdb->command = (char*)mrb_malloc(mrb, MAX_COMMAND_LINE+1); mrdb->print_no = 1; return mrdb; @@ -275,7 +275,7 @@ get_command(mrb_state *mrb, mrdb_state *mrdb) if (i == 0 && feof(stdin)) { clearerr(stdin); strcpy(mrdb->command, "quit"); - i += strlen("quit"); + i += sizeof("quit") - 1; } if (i == MAX_COMMAND_LINE) { @@ -407,7 +407,7 @@ print_info_stopped_break(mrb_state *mrb, mrdb_state *mrdb) const char *class_name; ret = mrb_debug_get_break(mrb, mrdb->dbg, mrdb->dbg->stopped_bpno, &bp); - if(ret == 0) { + if (ret == 0) { switch(bp.type) { case MRB_DEBUG_BPTYPE_LINE: file = bp.point.linepoint.file; @@ -417,13 +417,13 @@ print_info_stopped_break(mrb_state *mrb, mrdb_state *mrdb) case MRB_DEBUG_BPTYPE_METHOD: method_name = bp.point.methodpoint.method_name; class_name = bp.point.methodpoint.class_name; - if(class_name == NULL) { + if (class_name == NULL) { printf("Breakpoint %d, %s\n", bp.bpno, method_name); } else { printf("Breakpoint %d, %s:%s\n", bp.bpno, class_name, method_name); } - if(mrdb->dbg->isCfunc) { + if (mrdb->dbg->isCfunc) { printf("Stopped before calling the C function.\n"); } break; @@ -446,7 +446,7 @@ print_info_stopped_code(mrb_state *mrb, mrdb_state *mrdb) { char* file = mrb_debug_get_source(mrb, mrdb, mrdb->srcpath, mrdb->dbg->prvfile); uint16_t lineno = mrdb->dbg->prvline; - if(file != NULL) { + if (file != NULL) { mrb_debug_list(mrb, mrdb->dbg, file, lineno, lineno); mrb_free(mrb, file); } @@ -480,6 +480,7 @@ get_and_parse_command(mrb_state *mrb, mrdb_state *mrdb) while (!cmd) { for (p=NULL; !p || *p=='\0'; ) { printf("(%s:%d) ", mrdb->dbg->prvfile, mrdb->dbg->prvline); + fflush(stdout); p = get_command(mrb, mrdb); } @@ -504,12 +505,13 @@ get_and_parse_command(mrb_state *mrb, mrdb_state *mrdb) } static int32_t -check_method_breakpoint(mrb_state *mrb, mrb_irep *irep, mrb_code *pc, mrb_value *regs) +check_method_breakpoint(mrb_state *mrb, const mrb_irep *irep, const mrb_code *pc, mrb_value *regs) { struct RClass* c; mrb_sym sym; int32_t bpno; mrb_bool isCfunc; + struct mrb_insn_data insn; mrb_debug_context *dbg = mrb_debug_context_get(mrb); @@ -517,23 +519,24 @@ check_method_breakpoint(mrb_state *mrb, mrb_irep *irep, mrb_code *pc, mrb_value bpno = dbg->method_bpno; dbg->method_bpno = 0; - switch(GET_OPCODE(*pc)) { + insn = mrb_decode_insn(pc); + switch(insn.insn) { case OP_SEND: case OP_SENDB: - c = mrb_class(mrb, regs[GETARG_A(*pc)]); - sym = irep->syms[GETARG_B(*pc)]; + c = mrb_class(mrb, regs[insn.a]); + sym = irep->syms[insn.b]; break; case OP_SUPER: - c = mrb->c->ci->target_class->super; + c = mrb_vm_ci_target_class(mrb->c->ci)->super; sym = mrb->c->ci->mid; break; default: sym = 0; break; } - if(sym != 0) { + if (sym != 0) { dbg->method_bpno = mrb_debug_check_breakpoint_method(mrb, dbg, c, sym, &isCfunc); - if(isCfunc) { + if (isCfunc) { bpno = dbg->method_bpno; dbg->method_bpno = 0; } @@ -543,7 +546,7 @@ check_method_breakpoint(mrb_state *mrb, mrb_irep *irep, mrb_code *pc, mrb_value } static void -mrb_code_fetch_hook(mrb_state *mrb, mrb_irep *irep, mrb_code *pc, mrb_value *regs) +mrb_code_fetch_hook(mrb_state *mrb, const mrb_irep *irep, const mrb_code *pc, mrb_value *regs) { const char *file; int32_t line; @@ -557,27 +560,39 @@ mrb_code_fetch_hook(mrb_state *mrb, mrb_irep *irep, mrb_code *pc, mrb_value *reg dbg->pc = pc; dbg->regs = regs; - if(dbg->xphase == DBG_PHASE_RESTART) { + if (dbg->xphase == DBG_PHASE_RESTART) { dbg->root_irep = irep; dbg->prvfile = NULL; dbg->prvline = 0; + dbg->prvci = NULL; dbg->xm = DBG_RUN; dbg->xphase = DBG_PHASE_RUNNING; } - file = mrb_debug_get_filename(irep, (uint32_t)(pc - irep->iseq)); - line = mrb_debug_get_line(irep, (uint32_t)(pc - irep->iseq)); + file = mrb_debug_get_filename(mrb, irep, pc - irep->iseq); + line = mrb_debug_get_line(mrb, irep, pc - irep->iseq); switch (dbg->xm) { case DBG_STEP: - case DBG_NEXT: // temporary - if (dbg->prvfile == file && dbg->prvline == line) { + if (!file || (dbg->prvfile == file && dbg->prvline == line)) { return; } dbg->method_bpno = 0; dbg->bm = BRK_STEP; break; + case DBG_NEXT: + if (!file || (dbg->prvfile == file && dbg->prvline == line)) { + return; + } + if ((intptr_t)(dbg->prvci) < (intptr_t)(mrb->c->ci)) { + return; + } + dbg->prvci = NULL; + dbg->method_bpno = 0; + dbg->bm = BRK_NEXT; + break; + case DBG_RUN: bpno = check_method_breakpoint(mrb, irep, pc, regs); if (bpno > 0) { @@ -611,7 +626,7 @@ mrb_code_fetch_hook(mrb_state *mrb, mrb_irep *irep, mrb_code *pc, mrb_value *reg dbg->prvfile = file; dbg->prvline = line; - if(dbg->bm == BRK_BREAK && --dbg->ccnt > 0) { + if (dbg->bm == BRK_BREAK && --dbg->ccnt > 0) { return; } dbg->break_hook(mrb, dbg); @@ -634,7 +649,7 @@ mrb_debug_break_hook(mrb_state *mrb, mrb_debug_context *dbg) st = cmd->func(mrb, mrdb); - if( (st == DBGST_CONTINUE) || (st == DBGST_RESTART) ) break; + if ((st == DBGST_CONTINUE) || (st == DBGST_RESTART)) break; } return dbg->xm; } @@ -651,13 +666,13 @@ main(int argc, char **argv) mrb_debug_context* dbg_backup; debug_command *cmd; + l_restart: + if (mrb == NULL) { fputs("Invalid mrb_state, exiting mruby\n", stderr); return EXIT_FAILURE; } - l_restart: - /* parse command parameters */ n = parse_args(mrb, argc, argv, &args); if (n == EXIT_FAILURE || args.rfp == NULL) { @@ -671,7 +686,7 @@ main(int argc, char **argv) mrb_assert(mrdb && mrdb->dbg); mrdb->srcpath = args.srcpath; - if(mrdb->dbg->xm == DBG_QUIT) { + if (mrdb->dbg->xm == DBG_QUIT) { mrdb->dbg->xphase = DBG_PHASE_RESTART; } else { @@ -679,7 +694,7 @@ main(int argc, char **argv) } mrdb->dbg->xm = DBG_INIT; mrdb->dbg->ccnt = 1; - + /* setup hook functions */ mrb->code_fetch_hook = mrb_code_fetch_hook; mrdb->dbg->break_hook = mrb_debug_break_hook; @@ -726,21 +741,21 @@ main(int argc, char **argv) mrb_p(mrb, v); } } - + mrdb->dbg->prvfile = "-"; mrdb->dbg->prvline = 0; - + while (1) { cmd = get_and_parse_command(mrb, mrdb); mrb_assert(cmd); - + if (cmd->id == DBGCMD_QUIT) { break; } - - if( cmd->func(mrb, mrdb) == DBGST_RESTART ) goto l_restart; + + if ( cmd->func(mrb, mrdb) == DBGST_RESTART ) goto l_restart; } - + cleanup(mrb, &args); return 0; diff --git a/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.h b/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.h index 9e92ce879..24ccad126 100755..100644 --- a/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.h +++ b/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.h @@ -6,14 +6,10 @@ #ifndef MRDB_H #define MRDB_H -#include "mruby.h" +#include <mruby.h> #include "mrdbconf.h" -#ifdef _MSC_VER -# define __func__ __FUNCTION__ -#endif - #define MAX_COMMAND_WORD (16) typedef enum debug_command_id { @@ -23,6 +19,7 @@ typedef enum debug_command_id { DBGCMD_STEP, DBGCMD_BREAK, DBGCMD_INFO_BREAK, + DBGCMD_INFO_LOCAL, DBGCMD_WATCH, DBGCMD_INFO_WATCH, DBGCMD_ENABLE, @@ -102,13 +99,14 @@ typedef struct mrb_debug_breakpoint { } mrb_debug_breakpoint; typedef struct mrb_debug_context { - struct mrb_irep *root_irep; - struct mrb_irep *irep; - mrb_code *pc; + const struct mrb_irep *root_irep; + const struct mrb_irep *irep; + const mrb_code *pc; mrb_value *regs; const char *prvfile; int32_t prvline; + mrb_callinfo *prvci; mrdb_exemode xm; mrdb_exephase xphase; @@ -146,9 +144,11 @@ typedef dbgcmd_state (*debug_command_func)(mrb_state*, mrdb_state*); dbgcmd_state dbgcmd_run(mrb_state*, mrdb_state*); dbgcmd_state dbgcmd_continue(mrb_state*, mrdb_state*); dbgcmd_state dbgcmd_step(mrb_state*, mrdb_state*); +dbgcmd_state dbgcmd_next(mrb_state*, mrdb_state*); /* cmdbreak.c */ dbgcmd_state dbgcmd_break(mrb_state*, mrdb_state*); dbgcmd_state dbgcmd_info_break(mrb_state*, mrdb_state*); +dbgcmd_state dbgcmd_info_local(mrb_state*, mrdb_state*); dbgcmd_state dbgcmd_delete(mrb_state*, mrdb_state*); dbgcmd_state dbgcmd_enable(mrb_state*, mrdb_state*); dbgcmd_state dbgcmd_disable(mrb_state*, mrdb_state*); diff --git a/mrbgems/mruby-bin-debugger/tools/mrdb/mrdbconf.h b/mrbgems/mruby-bin-debugger/tools/mrdb/mrdbconf.h index f17f9c57d..0cc36c8b7 100755..100644 --- a/mrbgems/mruby-bin-debugger/tools/mrdb/mrdbconf.h +++ b/mrbgems/mruby-bin-debugger/tools/mrdb/mrdbconf.h @@ -6,6 +6,14 @@ #ifndef MRDBCONF_H #define MRDBCONF_H +#ifndef MRB_USE_DEBUG_HOOK +# error mruby-bin-debugger need 'MRB_USE_DEBUG_HOOK' in your build configuration +#endif + +#ifdef MRB_NO_STDIO +# error mruby-bin-debugger conflicts 'MRB_NO_STDIO' in your build configuration +#endif + /* configuration options: */ /* maximum size for command buffer */ #define MAX_COMMAND_LINE 1024 diff --git a/mrbgems/mruby-bin-debugger/tools/mrdb/mrdberror.h b/mrbgems/mruby-bin-debugger/tools/mrdb/mrdberror.h index c7812b0d6..6f1a53f3d 100755..100644 --- a/mrbgems/mruby-bin-debugger/tools/mrdb/mrdberror.h +++ b/mrbgems/mruby-bin-debugger/tools/mrdb/mrdberror.h @@ -17,4 +17,3 @@ #define MRB_DEBUG_BREAK_NO_OVER (-15) #endif - |