Update debugger to use exceptions for internal command processing.

arr committed 10 years ago

Commit 8549d341 parent 682a72b1 file · +47 −71Browse files

Showing the changes to src/exec/debugger.cpp (1 of 1 file). Show all

Unified · Split

 #undef CSI
     }
-    void debug_print_error(const std::string &str)
+    struct debug_cmd_error_t : std::runtime_error
+    {
+        debug_cmd_error_t(const char *message)
+            : std::runtime_error{ message }
+        { }
+    };
+    void debug_print_error(const char *str)
     {
         std::cout
             << console_modifiers::red_font
             << "\n";
     }
+    void debug_print_error(const std::string &str)
+    {
+        debug_print_error(str.c_str());
+    }
     void debug_print_info(const std::string &str)
     {
         std::cout
         cxt.exit_break = true;
     }
-    void cmd_term(const std::vector<std::string> &, dbg_cmd_cxt_t &cxt)
+    void cmd_term(const std::vector<std::string> &, dbg_cmd_cxt_t &)
     {
         throw vm_user_exception{ "Debugger signaled VM termination" };
     }
     void cmd_breakpoint_set(const std::vector<std::string> &a, dbg_cmd_cxt_t &cxt)
     {
         if (a.size() < 3)
-        {
+            throw debug_cmd_error_t{ "Must supply an IP and module ID" };
-            debug_print_error("Must supply an IP and module ID");
-            return;
-        }
         vm_pc_t pc;
         try
         }
         catch (...)
         {
-            debug_print_error("Invalid IP format");
+            throw debug_cmd_error_t{ "Invalid IP format" };
-            return;
         }
         uint32_t module_id;
         }
         catch (...)
         {
-            debug_print_error("Invalid module ID format");
+            throw debug_cmd_error_t{ "Invalid module ID format" };
-            return;
         }
         auto module = std::shared_ptr<vm_module_t>{};
         if (module == nullptr)
         {
-            debug_print_error("Invalid module ID");
+            throw debug_cmd_error_t{ "Invalid module ID" };
-            return;
         }
         else if (util::has_flag(module->header.runtime_flag, runtime_flags_t::builtin))
         {
-            debug_print_error("Unable to set breakpoint in built-in module");
+            throw debug_cmd_error_t{ "Unable to set breakpoint in built-in module" };
-            return;
         }
         if (pc < 0 || module->code_section.size() <= static_cast<std::size_t>(pc))
-        {
+            throw debug_cmd_error_t{ "Invalid IP for module" };
-            debug_print_error("Invalid IP for module");
-            return;
-        }
         cxt.dbg.breakpoint_cookies.push_back(cxt.dbg.controller->set_breakpoint(module, pc));
     }
     void cmd_breakpoint_clear(const std::vector<std::string> &a, dbg_cmd_cxt_t &cxt)
     {
         if (a.size() == 1)
-        {
+            throw debug_cmd_error_t{ "Must supply a breakpoint ID or wildcard" };
-            debug_print_error("Must supply a breakpoint ID or wildcard");
-            return;
-        }
         auto controller = cxt.dbg.controller;
         if (a[1].compare("*") == 0)
         }
         catch (...)
         {
-            debug_print_error("Invalid breakpoint ID format");
+            throw debug_cmd_error_t{ "Invalid breakpoint ID format" };
-            return;
         }
         auto cookie_iter = std::find_if(
             std::end(cxt.dbg.breakpoint_cookies),
             [breakpoint_cookie] (const cookie_t c) { return c == breakpoint_cookie; });
         if (cookie_iter == cxt.dbg.breakpoint_cookies.end())
-        {
+            throw debug_cmd_error_t{ "Unknown breakpoint ID" };
-            debug_print_error("Unknown breakpoint ID");
-            return;
-        }
         // Clear the breakpoint
         controller->clear_breakpoint(breakpoint_cookie);
             const auto details = cxt.dbg.controller->get_breakpoint_details(cookie);
             msg << std::setw(3) << cookie << ": "
                 << std::setw(16) << details.module->module_name->str()
-                << std::setw(0) << " @ " << details.pc << "\n";
+                << std::setw(0) << "@" << details.pc << "\n";
         }
         debug_print_info(msg.str());
                 }
                 catch (...)
                 {
-                    debug_print_error("Invalid thread ID format");
+                    throw debug_cmd_error_t{ "Invalid thread ID format" };
-                    return;
                 }
             }
         }
         if (thread_registers.empty())
-        {
+            throw debug_cmd_error_t{ "Unknown thread ID" };
-            debug_print_error("Unknown thread ID");
-            return;
-        }
         auto msg = std::stringstream{};
         for (auto t : thread_registers)
     void cmd_switchthread(const std::vector<std::string> &a, dbg_cmd_cxt_t &cxt)
     {
         if (a.size() == 1)
-        {
+            throw debug_cmd_error_t{ "Must supply a target thread ID" };
-            debug_print_error("Must supply a target thread ID");
-            return;
-        }
         uint32_t thread_id;
         try
         }
         catch (...)
         {
-            debug_print_error("Invalid thread ID format");
+            throw debug_cmd_error_t{ "Invalid thread ID format" };
-            return;
         }
         auto all_threads = cxt.vm.get_scheduler_control().get_all_threads();
             }
         }
-        debug_print_error("Unknown thread ID");
+        throw debug_cmd_error_t{ "Unknown thread ID" };
     }
     void cmd_disassemble(const std::vector<std::string> &a, dbg_cmd_cxt_t &cxt)
             }
             catch (...)
             {
-                debug_print_error("Invalid disassemble count format");
+                throw debug_cmd_error_t{ "Invalid disassemble count format" };
-                return;
             }
         }
     void cmd_examine(const std::vector<std::string> &a, dbg_cmd_cxt_t &cxt)
     {
         if (a.size() < 3)
-        {
+            throw debug_cmd_error_t{ "Invalid number of arguments" };
-            debug_print_error("Invalid number of arguments");
-            return;
-        }
         std::shared_ptr<const type_descriptor_t> base_type;
         word_t *base_pointer;
         {
             auto frame = cxt.current_register->stack.peek_frame();
             if (frame == nullptr)
-            {
+                throw debug_cmd_error_t{ "Invalid frame pointer " };
-                debug_print_error("Invalid frame pointer ");
-                return;
-            }
             base_type = frame->frame_type;
             base_pointer = reinterpret_cast<word_t *>(frame->base());
         }
         else
         {
-            debug_print_error("Invalid memory base pointer");
+            throw debug_cmd_error_t{ "Invalid memory base pointer" };
-            return;
         }
         assert(base_type != nullptr && base_pointer != nullptr);
         }
         catch (...)
         {
-            debug_print_error("Invalid memory offset format");
+            throw debug_cmd_error_t{ "Invalid memory offset format" };
-            return;
         }
         if (0 > byte_offset1 || byte_offset1 >= base_type->size_in_bytes)
-        {
+            throw debug_cmd_error_t{ "First offset out of range" };
-            debug_print_error("First offset out of range");
-            return;
-        }
         auto msg = std::stringstream{};
         if (byte_offset2 != -1)
             if (byte_offset2 != -1)
             {
                 if (alloc_to_examine == nullptr)
-                {
+                    throw debug_cmd_error_t{ "First offset is nil" };
-                    debug_print_error("First offset is nil");
-                    return;
-                }
                 if (0 > byte_offset2 || byte_offset2 >= alloc_to_examine->alloc_type->size_in_bytes)
-                {
+                    throw debug_cmd_error_t{ "Second offset out of range" };
-                    debug_print_error("Second offset out of range");
-                    return;
-                }
                 // Update data pointer for 2nd indirection
                 base_pointer = reinterpret_cast<word_t *>(alloc_to_examine->get_allocation());
                 continue;
             }
-            cmd_exec(cmd_tokens, cxt);
+            try
-            if (cxt.exit_break)
+            {
-                break;
+                cmd_exec(cmd_tokens, cxt);
+                if (cxt.exit_break)
+                    break;
+            }
+            catch (const debug_cmd_error_t &e)
+            {
+                debug_print_error(e.what());
+            }
         }
     }
 }