8 files changed, 176 insertions, 183 deletions
diff --git a/mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.c b/mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.c
index e3e0e66..942b9c4 100644
--- a/mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.c
+++ b/mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.c
@@ -65,21 +65,32 @@ static int32_t
 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) {
-      hit = TRUE;
-      index = i;
-      break;
-    }
+    if (dbg->bp[i].bpno == bpno) return i;
   }
+  return MRB_DEBUG_BREAK_INVALID_NO;
+}
 
-  if (hit == FALSE) {
-    return MRB_DEBUG_BREAK_INVALID_NO;
+static int32_t
+alloc_breakpoint(mrb_debug_context *dbg, mrb_debug_bptype type)
+{
+  int32_t index;
+
+  if (dbg->bpnum >= MAX_BREAKPOINT) {
+    return MRB_DEBUG_BREAK_NUM_OVER;
+  }
+  if (dbg->next_bpno > MAX_BREAKPOINTNO) {
+    return MRB_DEBUG_BREAK_NO_OVER;
   }
 
+  index = dbg->bpnum;
+  dbg->bp[index].bpno = dbg->next_bpno;
+  dbg->next_bpno++;
+  dbg->bp[index].enable = TRUE;
+  dbg->bp[index].type = type;
+  dbg->bpnum++;
+
   return index;
 }
 
@@ -189,21 +200,12 @@ int32_t
 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;
 
   if ((mrb == NULL)||(dbg == NULL)||(file == NULL)) {
     return MRB_DEBUG_INVALID_ARGUMENT;
   }
 
-  if (dbg->bpnum >= MAX_BREAKPOINT) {
-    return MRB_DEBUG_BREAK_NUM_OVER;
-  }
-
-  if (dbg->next_bpno > MAX_BREAKPOINTNO) {
-    return MRB_DEBUG_BREAK_NO_OVER;
-  }
-
   /* file and lineno check. */
   result = check_file_lineno(mrb, dbg->root_irep, file, lineno);
   if (result == 0) {
@@ -213,17 +215,11 @@ mrb_debug_set_break_line(mrb_state *mrb, mrb_debug_context *dbg, const char *fil
     return MRB_DEBUG_BREAK_INVALID_LINENO;
   }
 
-  set_file = mrdb_strdup(mrb, file);
+  index = alloc_breakpoint(dbg, MRB_DEBUG_BPTYPE_LINE);
+  if (index < 0) return index;
 
-  index = dbg->bpnum;
-  dbg->bp[index].bpno = dbg->next_bpno;
-  dbg->next_bpno++;
-  dbg->bp[index].enable = TRUE;
-  dbg->bp[index].type = MRB_DEBUG_BPTYPE_LINE;
+  dbg->bp[index].point.linepoint.file = mrdb_strdup(mrb, file);
   dbg->bp[index].point.linepoint.lineno = lineno;
-  dbg->bpnum++;
-
-  dbg->bp[index].point.linepoint.file = set_file;
 
   return dbg->bp[index].bpno;
 }
@@ -239,34 +235,21 @@ mrb_debug_set_break_method(mrb_state *mrb, mrb_debug_context *dbg, const char *c
     return MRB_DEBUG_INVALID_ARGUMENT;
   }
 
-  if (dbg->bpnum >= MAX_BREAKPOINT) {
-    return MRB_DEBUG_BREAK_NUM_OVER;
-  }
-
-  if (dbg->next_bpno > MAX_BREAKPOINTNO) {
-    return MRB_DEBUG_BREAK_NO_OVER;
-  }
-
-  if (class_name != NULL) {
-    set_class = mrdb_strdup(mrb, class_name);
-  }
-  else {
-    set_class = NULL;
-  }
-
+  set_class = class_name != NULL ? mrdb_strdup(mrb, class_name) : NULL;
   set_method = mrdb_strdup(mrb, method_name);
   if (set_method == NULL) {
     mrb_free(mrb, set_class);
   }
 
-  index = dbg->bpnum;
-  dbg->bp[index].bpno = dbg->next_bpno;
-  dbg->next_bpno++;
-  dbg->bp[index].enable = TRUE;
-  dbg->bp[index].type = MRB_DEBUG_BPTYPE_METHOD;
+  index = alloc_breakpoint(dbg, MRB_DEBUG_BPTYPE_METHOD);
+  if (index < 0) {
+    mrb_free(mrb, set_method);
+    mrb_free(mrb, set_class);
+    return index;
+  }
+
   dbg->bp[index].point.methodpoint.method_name = set_method;
   dbg->bp[index].point.methodpoint.class_name = set_class;
-  dbg->bpnum++;
 
   return dbg->bp[index].bpno;
 }
diff --git a/mrbgems/mruby-bin-debugger/tools/mrdb/apiprint.c b/mrbgems/mruby-bin-debugger/tools/mrdb/apiprint.c
index 49c93e2..6376daa 100644
--- a/mrbgems/mruby-bin-debugger/tools/mrdb/apiprint.c
+++ b/mrbgems/mruby-bin-debugger/tools/mrdb/apiprint.c
@@ -11,7 +11,7 @@
 #include <mruby/error.h>
 #include <mruby/numeric.h>
 #include <mruby/string.h>
-#include <mruby/presym.h>
+#include <mruby/internal.h>
 #include "apiprint.h"
 
 static void
@@ -70,12 +70,15 @@ mrb_debug_eval(mrb_state *mrb, mrb_debug_context *dbg, const char *expr, size_t
 
     v =  mrb_funcall_argv(mrb, recv, MRB_SYM(instance_eval), 1, &ruby_code);
   }
-
-  if (exc) {
-    *exc = mrb_obj_is_kind_of(mrb, v, E_EXCEPTION);
+  mrb_bool is_exc = mrb_obj_is_kind_of(mrb, v, E_EXCEPTION);
+  if (is_exc) {
+    s = mrb_exc_get_output(mrb, mrb_obj_ptr(v));
+  }
+  else {
+    s = mrb_inspect(mrb, v);
   }
 
-  s = mrb_inspect(mrb, v);
+  if (exc) *exc = is_exc;
 
   /* enable code_fetch_hook */
   mrb->code_fetch_hook = tmp;
diff --git a/mrbgems/mruby-bin-debugger/tools/mrdb/cmdbreak.c b/mrbgems/mruby-bin-debugger/tools/mrdb/cmdbreak.c
index 151c403..7dff7e2 100644
--- a/mrbgems/mruby-bin-debugger/tools/mrdb/cmdbreak.c
+++ b/mrbgems/mruby-bin-debugger/tools/mrdb/cmdbreak.c
@@ -397,40 +397,30 @@ dbgcmd_info_break(mrb_state *mrb, mrdb_state *mrdb)
   return DBGST_PROMPT;
 }
 
-dbgcmd_state
-dbgcmd_delete(mrb_state *mrb, mrdb_state *mrdb)
+static dbgcmd_state
+dbgcmd_set_breakpoint(mrb_state *mrb, mrdb_state *mrdb,
+                      all_command_func all_func, select_command_func select_func)
 {
-  mrb_bool ret = FALSE;
-
-  ret = exe_set_command_all(mrb, mrdb, mrb_debug_delete_break_all);
-  if (ret != TRUE) {
-    exe_set_command_select(mrb, mrdb, mrb_debug_delete_break);
+  if (!exe_set_command_all(mrb, mrdb, all_func)) {
+    exe_set_command_select(mrb, mrdb, select_func);
   }
-
   return DBGST_PROMPT;
 }
 
 dbgcmd_state
-dbgcmd_enable(mrb_state *mrb, mrdb_state *mrdb)
+dbgcmd_delete(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) {
-    exe_set_command_select(mrb, mrdb, mrb_debug_enable_break);
-  }
+  return dbgcmd_set_breakpoint(mrb, mrdb, mrb_debug_delete_break_all, mrb_debug_delete_break);
+}
 
-  return DBGST_PROMPT;
+dbgcmd_state
+dbgcmd_enable(mrb_state *mrb, mrdb_state *mrdb)
+{
+  return dbgcmd_set_breakpoint(mrb, mrdb, mrb_debug_enable_break_all, mrb_debug_enable_break);
 }
 
 dbgcmd_state
 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) {
-    exe_set_command_select(mrb, mrdb, mrb_debug_disable_break);
-  }
-  return DBGST_PROMPT;
+  return dbgcmd_set_breakpoint(mrb, mrdb, mrb_debug_disable_break_all, mrb_debug_disable_break);
 }
diff --git a/mrbgems/mruby-bin-debugger/tools/mrdb/cmdmisc.c b/mrbgems/mruby-bin-debugger/tools/mrdb/cmdmisc.c
index 4cf635b..6beed46 100644
--- a/mrbgems/mruby-bin-debugger/tools/mrdb/cmdmisc.c
+++ b/mrbgems/mruby-bin-debugger/tools/mrdb/cmdmisc.c
@@ -270,35 +270,37 @@ replace_ext(mrb_state *mrb, const char *filename, const char *ext)
   return s;
 }
 
+/* parse: <lineno> | <filename>:<lineno> | <filename> */
+static void
+parse_file_line_spec(mrb_state *mrb, char *arg, listcmd_parser_state *st)
+{
+  char *p = arg;
+
+  if (parse_lineno(mrb, &p, st)) {
+    /* matched <lineno> or <lineno>,<lineno> */
+  }
+  else if (parse_filename(mrb, &p, st)) {
+    if (skip_char(&p, ':') && !parse_lineno(mrb, &p, st)) {
+      st->parse_error = TRUE;
+    }
+  }
+  else {
+    st->parse_error = TRUE;
+  }
+  if (*p != '\0') {
+    st->parse_error = TRUE;
+  }
+}
+
 static mrb_bool
 parse_listcmd_args(mrb_state *mrb, mrdb_state *mrdb, listcmd_parser_state *st)
 {
-  char *p;
-
   switch (mrdb->wcnt) {
   case 2:
-    p = mrdb->words[1];
-
-    /* mrdb->words[1] ::= <lineno> | <filename> ':' <lineno> | <filename> */
-    if (!parse_lineno(mrb, &p, st)) {
-      if (parse_filename(mrb, &p, st)) {
-        if (skip_char(&p, ':')) {
-          if (!parse_lineno(mrb, &p, st)) {
-            st->parse_error = TRUE;
-          }
-        }
-      }
-      else {
-        st->parse_error = TRUE;
-      }
-    }
-    if (*p != '\0') {
-      st->parse_error = TRUE;
-    }
+    parse_file_line_spec(mrb, mrdb->words[1], st);
     break;
   case 1:
   case 0:
-    /* do nothing */
     break;
   default:
     st->parse_error = TRUE;
@@ -501,9 +503,7 @@ dbgcmd_quit(mrb_state *mrb, mrdb_state *mrdb)
   }
 
   if (mrdb->dbg->xm == DBG_QUIT) {
-    struct RClass *exc;
-    exc = mrb_define_class(mrb, "DebuggerExit", E_EXCEPTION);
-    mrb_raise(mrb, exc, "Exit mrdb");
+    raise_debugger_exception(mrb, "DebuggerExit", "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 f78c1e1..1e09f6d 100644
--- a/mrbgems/mruby-bin-debugger/tools/mrdb/cmdprint.c
+++ b/mrbgems/mruby-bin-debugger/tools/mrdb/cmdprint.c
@@ -13,39 +13,38 @@
 #include <mruby/string.h>
 #include "apiprint.h"
 
+static uint32_t
+next_print_no(mrdb_state *mrdb)
+{
+  uint32_t no = mrdb->print_no++;
+  if (mrdb->print_no == 0) mrdb->print_no = 1;
+  return no;
+}
+
 dbgcmd_state
 dbgcmd_print(mrb_state *mrb, mrdb_state *mrdb)
 {
-  mrb_value expr;
-  mrb_value result;
-  uint8_t wcnt;
-  int ai;
-
   if (mrdb->wcnt <= 1) {
     puts("Parameter not specified.");
     return DBGST_PROMPT;
   }
 
-  ai = mrb_gc_arena_save(mrb);
+  int ai = mrb_gc_arena_save(mrb);
 
   /* eval expr */
-  expr = mrb_str_new_cstr(mrb, NULL);
-  for (wcnt=1; wcnt<mrdb->wcnt; wcnt++) {
+  mrb_value expr = mrb_str_new_cstr(mrb, NULL);
+  for (uint8_t wcnt=1; wcnt<mrdb->wcnt; wcnt++) {
     expr = mrb_str_cat_lit(mrb, expr, " ");
     expr = mrb_str_cat_cstr(mrb, expr, mrdb->words[wcnt]);
   }
 
-  result = mrb_debug_eval(mrb, mrdb->dbg, RSTRING_PTR(expr), RSTRING_LEN(expr), NULL, 0);
+  mrb_value result = mrb_debug_eval(mrb, mrdb->dbg, RSTRING_PTR(expr), RSTRING_LEN(expr), NULL, 0);
 
   /* $print_no = result */
-  printf("$%lu = ", (unsigned long)mrdb->print_no++);
+  printf("$%lu = ", (unsigned long)next_print_no(mrdb));
   fwrite(RSTRING_PTR(result), RSTRING_LEN(result), 1, stdout);
   putc('\n', stdout);
 
-  if (mrdb->print_no == 0) {
-    mrdb->print_no = 1;
-  }
-
   mrb_gc_arena_restore(mrb, ai);
 
   return DBGST_PROMPT;
@@ -60,20 +59,11 @@ dbgcmd_eval(mrb_state *mrb, mrdb_state *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);
+  int ai = mrb_gc_arena_save(mrb);
 
-  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_value result = mrb_debug_eval(mrb, mrdb->dbg, "local_variables", 0, NULL, 1);
+  mrb_value s = mrb_str_cat_lit(mrb, result, "\0");
+  printf("$%lu = %s\n", (unsigned long)next_print_no(mrdb), RSTRING_PTR(s));
 
   mrb_gc_arena_restore(mrb, ai);
 
diff --git a/mrbgems/mruby-bin-debugger/tools/mrdb/cmdrun.c b/mrbgems/mruby-bin-debugger/tools/mrdb/cmdrun.c
index 1cd463e..dd914af 100644
--- a/mrbgems/mruby-bin-debugger/tools/mrdb/cmdrun.c
+++ b/mrbgems/mruby-bin-debugger/tools/mrdb/cmdrun.c
@@ -17,10 +17,8 @@ dbgcmd_run(mrb_state *mrb, mrdb_state *mrdb)
   else {
     dbg->xm = DBG_QUIT;
     if (dbg->xphase == DBG_PHASE_RUNNING){
-      struct RClass *exc;
       puts("Start it from the beginning");
-      exc = mrb_define_class(mrb, "DebuggerRestart", E_EXCEPTION);
-      mrb_raise(mrb, exc, "Restart mrdb");
+      raise_debugger_exception(mrb, "DebuggerRestart", "Restart mrdb");
     }
   }
 
diff --git a/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.c b/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.c
index 0413c0b..42fa2fa 100644
--- a/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.c
+++ b/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.c
@@ -322,12 +322,48 @@ pick_out_word(mrb_state *mrb, char **pp)
   return ps;
 }
 
+/* find first command entry matching word1 (ignoring cmd2) */
+static debug_command*
+find_command_by_word1(const char *word1)
+{
+  debug_command *cmd;
+  size_t wlen = strlen(word1);
+
+  for (cmd=(debug_command*)debug_command_list; cmd->cmd1; cmd++) {
+    if (wlen >= cmd->len1 && strncmp(word1, cmd->cmd1, wlen) == 0) {
+      return cmd;
+    }
+  }
+  return NULL;
+}
+
+/* find command entry matching both word1 and word2 */
+static debug_command*
+find_command_by_words(const char *word1, const char *word2)
+{
+  debug_command *cmd;
+  size_t wlen;
+
+  for (cmd=(debug_command*)debug_command_list; cmd->cmd1; cmd++) {
+    wlen = strlen(word1);
+    if (wlen < cmd->len1 || strncmp(word1, cmd->cmd1, wlen)) {
+      continue;
+    }
+    if (!cmd->cmd2) return cmd;       /* word #1 only match */
+    if (word2 == NULL) continue;      /* word #2 not specified */
+    wlen = strlen(word2);
+    if (wlen >= cmd->len2 && strncmp(word2, cmd->cmd2, wlen) == 0) {
+      return cmd;                     /* word #1 and #2 match */
+    }
+  }
+  return NULL;
+}
+
 static debug_command*
 parse_command(mrb_state *mrb, mrdb_state *mrdb, char *buf)
 {
-  debug_command *cmd = NULL;
+  debug_command *cmd;
   char *p = buf;
-  size_t wlen;
 
   /* get word #1 */
   mrdb->words[0] = pick_out_word(mrb, &p);
@@ -342,51 +378,26 @@ parse_command(mrb_state *mrb, mrdb_state *mrdb, char *buf)
     mrdb->words[mrdb->wcnt++] = p;
   }
 
-  /* check word #1 */
-  for (cmd=(debug_command*)debug_command_list; cmd->cmd1; cmd++) {
-    wlen = strlen(mrdb->words[0]);
-    if (wlen >= cmd->len1 &&
-        strncmp(mrdb->words[0], cmd->cmd1, wlen) == 0) {
-      break;
-    }
-  }
-
-  if (cmd->cmd2) {
-    if (mrdb->wcnt > 1) {
-      /* get word #2 */
-      mrdb->words[1] = pick_out_word(mrb, &p);
-      if (mrdb->words[1]) {
-        /* update remain parameter */
-        for (; *p && ISBLANK(*p); p++)
-          ;
-        if (*p) {
-          mrdb->words[mrdb->wcnt++] = p;
-        }
-      }
-    }
-
-    /* check word #1,#2 */
-    for (; cmd->cmd1; cmd++) {
-      wlen = strlen(mrdb->words[0]);
-      if (wlen < cmd->len1 ||
-          strncmp(mrdb->words[0], cmd->cmd1, wlen)) {
-        continue;
-      }
-
-      if (!cmd->cmd2) break;          /* word #1 only */
-
-      if (mrdb->wcnt == 1) continue;  /* word #2 not specified */
+  cmd = find_command_by_word1(mrdb->words[0]);
+  if (!cmd) return NULL;
 
-      wlen = strlen(mrdb->words[1]);
-      if (wlen >= cmd->len2 &&
-          strncmp(mrdb->words[1], cmd->cmd2, wlen) == 0) {
-        break;  /* word #1 and #2 */
+  /* if matched command has a sub-command, try word #1 + #2 */
+  if (cmd->cmd2 && mrdb->wcnt > 1) {
+    mrdb->words[1] = pick_out_word(mrb, &p);
+    if (mrdb->words[1]) {
+      /* update remain parameter */
+      for (; *p && ISBLANK(*p); p++)
+        ;
+      if (*p) {
+        mrdb->words[mrdb->wcnt++] = p;
       }
     }
+    cmd = find_command_by_words(mrdb->words[0], mrdb->words[1]);
+    if (!cmd) return NULL;
   }
 
   /* divide remain parameters */
-  if (cmd->cmd1 && cmd->div) {
+  if (cmd->div) {
     p = mrdb->words[--mrdb->wcnt];
     for (; mrdb->wcnt<MAX_COMMAND_WORD; mrdb->wcnt++) {
       mrdb->words[mrdb->wcnt] = pick_out_word(mrb, &p);
@@ -396,7 +407,7 @@ parse_command(mrb_state *mrb, mrdb_state *mrdb, char *buf)
     }
   }
 
-  return cmd->cmd1 ? cmd : NULL;
+  return cmd;
 }
 
 static void
@@ -548,6 +559,22 @@ check_method_breakpoint(mrb_state *mrb, const mrb_irep *irep, const mrb_code *pc
   return bpno;
 }
 
+static int32_t
+check_breakpoint_hit(mrb_state *mrb, mrb_debug_context *dbg,
+                     const mrb_irep *irep, const mrb_code *pc,
+                     const char *file, int32_t line, mrb_value *regs)
+{
+  int32_t bpno;
+
+  bpno = check_method_breakpoint(mrb, irep, pc, regs);
+  if (bpno > 0) return bpno;
+  if (dbg->prvfile != file || dbg->prvline != line) {
+    bpno = mrb_debug_check_breakpoint_line(mrb, dbg, file, line);
+    if (bpno > 0) return bpno;
+  }
+  return 0;
+}
+
 static void
 mrb_code_fetch_hook(mrb_state *mrb, const mrb_irep *irep, const mrb_code *pc, mrb_value *regs)
 {
@@ -597,23 +624,16 @@ mrb_code_fetch_hook(mrb_state *mrb, const mrb_irep *irep, const mrb_code *pc, mr
     break;
 
   case DBG_RUN:
-    bpno = check_method_breakpoint(mrb, irep, pc, regs);
+    bpno = check_breakpoint_hit(mrb, dbg, irep, pc, file, line, regs);
     if (bpno > 0) {
       dbg->stopped_bpno = bpno;
       dbg->bm = BRK_BREAK;
       break;
     }
-    if (dbg->prvfile != file || dbg->prvline != line) {
-      bpno = mrb_debug_check_breakpoint_line(mrb, dbg, file, line);
-      if (bpno > 0) {
-        dbg->stopped_bpno = bpno;
-        dbg->bm = BRK_BREAK;
-        break;
-      }
-    }
     dbg->prvfile = file;
     dbg->prvline = line;
     return;
+
   case DBG_INIT:
     dbg->root_irep = irep;
     dbg->bm = BRK_INIT;
@@ -673,8 +693,9 @@ main(int argc, char **argv)
 
  l_restart:
 
-  if (mrb == NULL) {
-    fputs("Invalid mrb_state, exiting mruby\n", stderr);
+  if (MRB_OPEN_FAILURE(mrb)) {
+    mrb_print_error(mrb);  /* handles NULL */
+    mrb_close(mrb);        /* handles NULL */
     return EXIT_FAILURE;
   }
 
diff --git a/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.h b/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.h
index 1d379f4..df7680a 100644
--- a/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.h
+++ b/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.h
@@ -7,6 +7,7 @@
 #define MRDB_H
 
 #include <mruby.h>
+#include <mruby/class.h>
 
 #include "mrdbconf.h"
 
@@ -136,6 +137,13 @@ typedef struct mrdb_state {
 
 typedef dbgcmd_state (*debug_command_func)(mrb_state*, mrdb_state*);
 
+static inline mrb_noreturn void
+raise_debugger_exception(mrb_state *mrb, const char *name, const char *msg)
+{
+  struct RClass *exc = mrb_define_class(mrb, name, E_EXCEPTION);
+  mrb_raise(mrb, exc, msg);
+}
+
 /* cmdrun.c */
 dbgcmd_state dbgcmd_run(mrb_state*, mrdb_state*);
 dbgcmd_state dbgcmd_continue(mrb_state*, mrdb_state*);