contrib/llvm/tools/lldb/source/Commands/CommandObjectBreakpointCommand.cpp

   1 //===-- CommandObjectBreakpointCommand.cpp ----------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "lldb/lldb-python.h"
  11
  12 // C Includes
  13 // C++ Includes
  14
  15
  16 #include "CommandObjectBreakpointCommand.h"
  17 #include "CommandObjectBreakpoint.h"
  18
  19 #include "lldb/Core/IOHandler.h"
  20 #include "lldb/Interpreter/CommandInterpreter.h"
  21 #include "lldb/Interpreter/CommandReturnObject.h"
  22 #include "lldb/Target/Target.h"
  23 #include "lldb/Target/Thread.h"
  24 #include "lldb/Breakpoint/BreakpointIDList.h"
  25 #include "lldb/Breakpoint/Breakpoint.h"
  26 #include "lldb/Breakpoint/BreakpointLocation.h"
  27 #include "lldb/Breakpoint/StoppointCallbackContext.h"
  28 #include "lldb/Core/State.h"
  29
  30 using namespace lldb;
  31 using namespace lldb_private;
  32
  33 //-------------------------------------------------------------------------
  34 // CommandObjectBreakpointCommandAdd
  35 //-------------------------------------------------------------------------
  36
  37
  38 class CommandObjectBreakpointCommandAdd :
  39     public CommandObjectParsed,
  40     public IOHandlerDelegateMultiline
  41 {
  42 public:
  43
  44     CommandObjectBreakpointCommandAdd (CommandInterpreter &interpreter) :
  45         CommandObjectParsed (interpreter,
  46                              "add",
  47                              "Add a set of commands to a breakpoint, to be executed whenever the breakpoint is hit.",
  48                              NULL),
  49     IOHandlerDelegateMultiline ("DONE", IOHandlerDelegate::Completion::LLDBCommand),
  50         m_options (interpreter)
  51     {
  52         SetHelpLong (
  53 "\nGeneral information about entering breakpoint commands\n\
  54 ------------------------------------------------------\n\
  55 \n\
  56 This command will cause you to be prompted to enter the command or set of\n\
  57 commands you wish to be executed when the specified breakpoint is hit. You\n\
  58 will be told to enter your command(s), and will see a '> 'prompt. Because\n\
  59 you can enter one or many commands to be executed when a breakpoint is hit,\n\
  60 you will continue to be prompted after each new-line that you enter, until you\n\
  61 enter the word 'DONE', which will cause the commands you have entered to be\n\
  62 stored with the breakpoint and executed when the breakpoint is hit.\n\
  63 \n\
  64 Syntax checking is not necessarily done when breakpoint commands are entered.\n\
  65 An improperly written breakpoint command will attempt to get executed when the\n\
  66 breakpoint gets hit, and usually silently fail.  If your breakpoint command does\n\
  67 not appear to be getting executed, go back and check your syntax.\n\
  68 \n\
  69 Special information about PYTHON breakpoint commands\n\
  70 ----------------------------------------------------\n\
  71 \n\
  72 You may enter either one line of Python, multiple lines of Python (including\n\
  73 function definitions), or specify a Python function in a module that has already,\n\
  74 or will be imported.  If you enter a single line of Python, that will be passed\n\
  75 to the Python interpreter 'as is' when the breakpoint gets hit.  If you enter\n\
  76 function definitions, they will be passed to the Python interpreter as soon as\n\
  77 you finish entering the breakpoint command, and they can be called later (don't\n\
  78 forget to add calls to them, if you want them called when the breakpoint is\n\
  79 hit).  If you enter multiple lines of Python that are not function definitions,\n\
  80 they will be collected into a new, automatically generated Python function, and\n\
  81 a call to the newly generated function will be attached to the breakpoint.\n\
  82 \n\
  83 \n\
  84 This auto-generated function is passed in three arguments:\n\
  85 \n\
  86     frame:  a lldb.SBFrame object for the frame which hit breakpoint.\n\
  87     bp_loc: a lldb.SBBreakpointLocation object that represents the breakpoint\n\
  88             location that was hit.\n\
  89     dict:   the python session dictionary hit.\n\
  90 \n\
  91 When specifying a python function with the --python-function option, you need\n\
  92 to supply the function name prepended by the module name. So if you import a\n\
  93 module named 'myutils' that contains a 'breakpoint_callback' function, you would\n\
  94 specify the option as:\n\
  95 \n\
  96     --python-function myutils.breakpoint_callback\n\
  97 \n\
  98 The function itself must have the following prototype:\n\
  99 \n\
 100 def breakpoint_callback(frame, bp_loc, dict):\n\
 101   # Your code goes here\n\
 102 \n\
 103 The arguments are the same as the 3 auto generation function arguments listed\n\
 104 above. Note that the global variable 'lldb.frame' will NOT be setup when this\n\
 105 function is called, so be sure to use the 'frame' argument. The 'frame' argument\n\
 106 can get you to the thread (frame.GetThread()), the thread can get you to the\n\
 107 process (thread.GetProcess()), and the process can get you back to the target\n\
 108 (process.GetTarget()).\n\
 109 \n\
 110 Important Note: Because loose Python code gets collected into functions, if you\n\
 111 want to access global variables in the 'loose' code, you need to specify that\n\
 112 they are global, using the 'global' keyword.  Be sure to use correct Python\n\
 113 syntax, including indentation, when entering Python breakpoint commands.\n\
 114 \n\
 115 As a third option, you can pass the name of an already existing Python function\n\
 116 and that function will be attached to the breakpoint. It will get passed the\n\
 117 frame and bp_loc arguments mentioned above.\n\
 118 \n\
 119 Example Python one-line breakpoint command:\n\
 120 \n\
 121 (lldb) breakpoint command add -s python 1\n\
 122 Enter your Python command(s). Type 'DONE' to end.\n\
 123 > print \"Hit this breakpoint!\"\n\
 124 > DONE\n\
 125 \n\
 126 As a convenience, this also works for a short Python one-liner:\n\
 127 (lldb) breakpoint command add -s python 1 -o \"import time; print time.asctime()\"\n\
 128 (lldb) run\n\
 129 Launching '.../a.out'  (x86_64)\n\
 130 (lldb) Fri Sep 10 12:17:45 2010\n\
 131 Process 21778 Stopped\n\
 132 * thread #1: tid = 0x2e03, 0x0000000100000de8 a.out`c + 7 at main.c:39, stop reason = breakpoint 1.1, queue = com.apple.main-thread\n\
 133   36    \n\
 134   37    int c(int val)\n\
 135   38    {\n\
 136   39 ->     return val + 3;\n\
 137   40    }\n\
 138   41    \n\
 139   42    int main (int argc, char const *argv[])\n\
 140 (lldb)\n\
 141 \n\
 142 Example multiple line Python breakpoint command, using function definition:\n\
 143 \n\
 144 (lldb) breakpoint command add -s python 1\n\
 145 Enter your Python command(s). Type 'DONE' to end.\n\
 146 > def breakpoint_output (bp_no):\n\
 147 >     out_string = \"Hit breakpoint number \" + repr (bp_no)\n\
 148 >     print out_string\n\
 149 >     return True\n\
 150 > breakpoint_output (1)\n\
 151 > DONE\n\
 152 \n\
 153 \n\
 154 Example multiple line Python breakpoint command, using 'loose' Python:\n\
 155 \n\
 156 (lldb) breakpoint command add -s p 1\n\
 157 Enter your Python command(s). Type 'DONE' to end.\n\
 158 > global bp_count\n\
 159 > bp_count = bp_count + 1\n\
 160 > print \"Hit this breakpoint \" + repr(bp_count) + \" times!\"\n\
 161 > DONE\n\
 162 \n\
 163 In this case, since there is a reference to a global variable,\n\
 164 'bp_count', you will also need to make sure 'bp_count' exists and is\n\
 165 initialized:\n\
 166 \n\
 167 (lldb) script\n\
 168 >>> bp_count = 0\n\
 169 >>> quit()\n\
 170 \n\
 171 (lldb)\n\
 172 \n\
 173 \n\
 174 Your Python code, however organized, can optionally return a value.\n\
 175 If the returned value is False, that tells LLDB not to stop at the breakpoint\n\
 176 to which the code is associated. Returning anything other than False, or even\n\
 177 returning None, or even omitting a return statement entirely, will cause\n\
 178 LLDB to stop.\n\
 179 \n\
 180 Final Note:  If you get a warning that no breakpoint command was generated, but\n\
 181 you did not get any syntax errors, you probably forgot to add a call to your\n\
 182 functions.\n\
 183 \n\
 184 Special information about debugger command breakpoint commands\n\
 185 --------------------------------------------------------------\n\
 186 \n\
 187 You may enter any debugger command, exactly as you would at the debugger prompt.\n\
 188 You may enter as many debugger commands as you like, but do NOT enter more than\n\
 189 one command per line.\n" );
 190
 191         CommandArgumentEntry arg;
 192         CommandArgumentData bp_id_arg;
 193
 194         // Define the first (and only) variant of this arg.
 195         bp_id_arg.arg_type = eArgTypeBreakpointID;
 196         bp_id_arg.arg_repetition = eArgRepeatPlain;
 197
 198         // There is only one variant this argument could be; put it into the argument entry.
 199         arg.push_back (bp_id_arg);
 200
 201         // Push the data for the first argument into the m_arguments vector.
 202         m_arguments.push_back (arg);
 203     }
 204
 205     virtual
 206     ~CommandObjectBreakpointCommandAdd () {}
 207
 208     virtual Options *
 209     GetOptions ()
 210     {
 211         return &m_options;
 212     }
 213
 214     virtual void
 215     IOHandlerActivated (IOHandler &io_handler)
 216     {
 217         StreamFileSP output_sp(io_handler.GetOutputStreamFile());
 218         if (output_sp)
 219         {
 220             output_sp->PutCString(g_reader_instructions);
 221             output_sp->Flush();
 222         }
 223     }
 224
 225
 226     virtual void
 227     IOHandlerInputComplete (IOHandler &io_handler, std::string &line)
 228     {
 229         io_handler.SetIsDone(true);
 230
 231         BreakpointOptions *bp_options = (BreakpointOptions *) io_handler.GetUserData();
 232         if (bp_options)
 233         {
 234             std::unique_ptr<BreakpointOptions::CommandData> data_ap(new BreakpointOptions::CommandData());
 235             if (data_ap.get())
 236             {
 237                 data_ap->user_source.SplitIntoLines (line.c_str(), line.size());
 238                 BatonSP baton_sp (new BreakpointOptions::CommandBaton (data_ap.release()));
 239                 bp_options->SetCallback (BreakpointOptionsCallbackFunction, baton_sp);
 240             }
 241         }
 242
 243     }
 244
 245     void
 246     CollectDataForBreakpointCommandCallback (BreakpointOptions *bp_options,
 247                                              CommandReturnObject &result)
 248     {
 249         m_interpreter.GetLLDBCommandsFromIOHandler ("> ",           // Prompt
 250                                                     *this,          // IOHandlerDelegate
 251                                                     true,           // Run IOHandler in async mode
 252                                                     bp_options);    // Baton for the "io_handler" that will be passed back into our IOHandlerDelegate functions
 253     }
 254
 255     /// Set a one-liner as the callback for the breakpoint.
 256     void
 257     SetBreakpointCommandCallback (BreakpointOptions *bp_options,
 258                                   const char *oneliner)
 259     {
 260         std::unique_ptr<BreakpointOptions::CommandData> data_ap(new BreakpointOptions::CommandData());
 261
 262         // It's necessary to set both user_source and script_source to the oneliner.
 263         // The former is used to generate callback description (as in breakpoint command list)
 264         // while the latter is used for Python to interpret during the actual callback.
 265         data_ap->user_source.AppendString (oneliner);
 266         data_ap->script_source.assign (oneliner);
 267         data_ap->stop_on_error = m_options.m_stop_on_error;
 268
 269         BatonSP baton_sp (new BreakpointOptions::CommandBaton (data_ap.release()));
 270         bp_options->SetCallback (BreakpointOptionsCallbackFunction, baton_sp);
 271
 272         return;
 273     }
 274
 275     static bool
 276     BreakpointOptionsCallbackFunction (void *baton,
 277                                        StoppointCallbackContext *context,
 278                                        lldb::user_id_t break_id,
 279                                        lldb::user_id_t break_loc_id)
 280     {
 281         bool ret_value = true;
 282         if (baton == NULL)
 283             return true;
 284
 285
 286         BreakpointOptions::CommandData *data = (BreakpointOptions::CommandData *) baton;
 287         StringList &commands = data->user_source;
 288
 289         if (commands.GetSize() > 0)
 290         {
 291             ExecutionContext exe_ctx (context->exe_ctx_ref);
 292             Target *target = exe_ctx.GetTargetPtr();
 293             if (target)
 294             {
 295                 CommandReturnObject result;
 296                 Debugger &debugger = target->GetDebugger();
 297                 // Rig up the results secondary output stream to the debugger's, so the output will come out synchronously
 298                 // if the debugger is set up that way.
 299
 300                 StreamSP output_stream (debugger.GetAsyncOutputStream());
 301                 StreamSP error_stream (debugger.GetAsyncErrorStream());
 302                 result.SetImmediateOutputStream (output_stream);
 303                 result.SetImmediateErrorStream (error_stream);
 304
 305                 bool stop_on_continue = true;
 306                 bool echo_commands    = false;
 307                 bool print_results    = true;
 308
 309                 debugger.GetCommandInterpreter().HandleCommands (commands,
 310                                                                  &exe_ctx,
 311                                                                  stop_on_continue,
 312                                                                  data->stop_on_error,
 313                                                                  echo_commands,
 314                                                                  print_results,
 315                                                                  eLazyBoolNo,
 316                                                                  result);
 317                 result.GetImmediateOutputStream()->Flush();
 318                 result.GetImmediateErrorStream()->Flush();
 319            }
 320         }
 321         return ret_value;
 322     }
 323
 324     class CommandOptions : public Options
 325     {
 326     public:
 327
 328         CommandOptions (CommandInterpreter &interpreter) :
 329             Options (interpreter),
 330             m_use_commands (false),
 331             m_use_script_language (false),
 332             m_script_language (eScriptLanguageNone),
 333             m_use_one_liner (false),
 334             m_one_liner(),
 335             m_function_name()
 336         {
 337         }
 338
 339         virtual
 340         ~CommandOptions () {}
 341
 342         virtual Error
 343         SetOptionValue (uint32_t option_idx, const char *option_arg)
 344         {
 345             Error error;
 346             const int short_option = m_getopt_table[option_idx].val;
 347
 348             switch (short_option)
 349             {
 350             case 'o':
 351                 m_use_one_liner = true;
 352                 m_one_liner = option_arg;
 353                 break;
 354
 355             case 's':
 356                 m_script_language = (lldb::ScriptLanguage) Args::StringToOptionEnum (option_arg,
 357                                                                                      g_option_table[option_idx].enum_values,
 358                                                                                      eScriptLanguageNone,
 359                                                                                      error);
 360
 361                 if (m_script_language == eScriptLanguagePython || m_script_language == eScriptLanguageDefault)
 362                 {
 363                     m_use_script_language = true;
 364                 }
 365                 else
 366                 {
 367                     m_use_script_language = false;
 368                 }
 369                 break;
 370
 371             case 'e':
 372                 {
 373                     bool success = false;
 374                     m_stop_on_error = Args::StringToBoolean(option_arg, false, &success);
 375                     if (!success)
 376                         error.SetErrorStringWithFormat("invalid value for stop-on-error: \"%s\"", option_arg);
 377                 }
 378                 break;
 379
 380             case 'F':
 381                 {
 382                     m_use_one_liner = false;
 383                     m_use_script_language = true;
 384                     m_function_name.assign(option_arg);
 385                 }
 386                 break;
 387
 388             default:
 389                 break;
 390             }
 391             return error;
 392         }
 393         void
 394         OptionParsingStarting ()
 395         {
 396             m_use_commands = true;
 397             m_use_script_language = false;
 398             m_script_language = eScriptLanguageNone;
 399
 400             m_use_one_liner = false;
 401             m_stop_on_error = true;
 402             m_one_liner.clear();
 403             m_function_name.clear();
 404         }
 405
 406         const OptionDefinition*
 407         GetDefinitions ()
 408         {
 409             return g_option_table;
 410         }
 411
 412         // Options table: Required for subclasses of Options.
 413
 414         static OptionDefinition g_option_table[];
 415
 416         // Instance variables to hold the values for command options.
 417
 418         bool m_use_commands;
 419         bool m_use_script_language;
 420         lldb::ScriptLanguage m_script_language;
 421
 422         // Instance variables to hold the values for one_liner options.
 423         bool m_use_one_liner;
 424         std::string m_one_liner;
 425         bool m_stop_on_error;
 426         std::string m_function_name;
 427     };
 428
 429 protected:
 430     virtual bool
 431     DoExecute (Args& command, CommandReturnObject &result)
 432     {
 433         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
 434
 435         if (target == NULL)
 436         {
 437             result.AppendError ("There is not a current executable; there are no breakpoints to which to add commands");
 438             result.SetStatus (eReturnStatusFailed);
 439             return false;
 440         }
 441
 442         const BreakpointList &breakpoints = target->GetBreakpointList();
 443         size_t num_breakpoints = breakpoints.GetSize();
 444
 445         if (num_breakpoints == 0)
 446         {
 447             result.AppendError ("No breakpoints exist to have commands added");
 448             result.SetStatus (eReturnStatusFailed);
 449             return false;
 450         }
 451
 452         if (m_options.m_use_script_language == false && m_options.m_function_name.size())
 453         {
 454             result.AppendError ("need to enable scripting to have a function run as a breakpoint command");
 455             result.SetStatus (eReturnStatusFailed);
 456             return false;
 457         }
 458
 459         BreakpointIDList valid_bp_ids;
 460         CommandObjectMultiwordBreakpoint::VerifyBreakpointIDs (command, target, result, &valid_bp_ids);
 461
 462         if (result.Succeeded())
 463         {
 464             const size_t count = valid_bp_ids.GetSize();
 465             if (count > 1)
 466             {
 467                 result.AppendError ("can only add commands to one breakpoint at a time.");
 468                 result.SetStatus (eReturnStatusFailed);
 469                 return false;
 470             }
 471
 472             for (size_t i = 0; i < count; ++i)
 473             {
 474                 BreakpointID cur_bp_id = valid_bp_ids.GetBreakpointIDAtIndex (i);
 475                 if (cur_bp_id.GetBreakpointID() != LLDB_INVALID_BREAK_ID)
 476                 {
 477                     Breakpoint *bp = target->GetBreakpointByID (cur_bp_id.GetBreakpointID()).get();
 478                     BreakpointOptions *bp_options = NULL;
 479                     if (cur_bp_id.GetLocationID() == LLDB_INVALID_BREAK_ID)
 480                     {
 481                         // This breakpoint does not have an associated location.
 482                         bp_options = bp->GetOptions();
 483                     }
 484                     else
 485                     {
 486                         BreakpointLocationSP bp_loc_sp(bp->FindLocationByID (cur_bp_id.GetLocationID()));
 487                         // This breakpoint does have an associated location.
 488                         // Get its breakpoint options.
 489                         if (bp_loc_sp)
 490                             bp_options = bp_loc_sp->GetLocationOptions();
 491                     }
 492
 493                     // Skip this breakpoint if bp_options is not good.
 494                     if (bp_options == NULL) continue;
 495
 496                     // If we are using script language, get the script interpreter
 497                     // in order to set or collect command callback.  Otherwise, call
 498                     // the methods associated with this object.
 499                     if (m_options.m_use_script_language)
 500                     {
 501                         // Special handling for one-liner specified inline.
 502                         if (m_options.m_use_one_liner)
 503                         {
 504                             m_interpreter.GetScriptInterpreter()->SetBreakpointCommandCallback (bp_options,
 505                                                                                                 m_options.m_one_liner.c_str());
 506                         }
 507                         // Special handling for using a Python function by name
 508                         // instead of extending the breakpoint callback data structures, we just automatize
 509                         // what the user would do manually: make their breakpoint command be a function call
 510                         else if (m_options.m_function_name.size())
 511                         {
 512                             std::string oneliner("return ");
 513                             oneliner += m_options.m_function_name;
 514                             oneliner += "(frame, bp_loc, internal_dict)";
 515                             m_interpreter.GetScriptInterpreter()->SetBreakpointCommandCallback (bp_options,
 516                                                                                                 oneliner.c_str());
 517                         }
 518                         else
 519                         {
 520                             m_interpreter.GetScriptInterpreter()->CollectDataForBreakpointCommandCallback (bp_options,
 521                                                                                                            result);
 522                         }
 523                     }
 524                     else
 525                     {
 526                         // Special handling for one-liner specified inline.
 527                         if (m_options.m_use_one_liner)
 528                             SetBreakpointCommandCallback (bp_options,
 529                                                           m_options.m_one_liner.c_str());
 530                         else
 531                             CollectDataForBreakpointCommandCallback (bp_options,
 532                                                                      result);
 533                     }
 534                 }
 535             }
 536         }
 537
 538         return result.Succeeded();
 539     }
 540
 541 private:
 542     CommandOptions m_options;
 543     static const char *g_reader_instructions;
 544
 545 };
 546
 547 const char *
 548 CommandObjectBreakpointCommandAdd::g_reader_instructions = "Enter your debugger command(s).  Type 'DONE' to end.\n";
 549
 550 // FIXME: "script-type" needs to have its contents determined dynamically, so somebody can add a new scripting
 551 // language to lldb and have it pickable here without having to change this enumeration by hand and rebuild lldb proper.
 552
 553 static OptionEnumValueElement
 554 g_script_option_enumeration[4] =
 555 {
 556     { eScriptLanguageNone,    "command",         "Commands are in the lldb command interpreter language"},
 557     { eScriptLanguagePython,  "python",          "Commands are in the Python language."},
 558     { eSortOrderByName,       "default-script",  "Commands are in the default scripting language."},
 559     { 0,                      NULL,              NULL }
 560 };
 561
 562 OptionDefinition
 563 CommandObjectBreakpointCommandAdd::CommandOptions::g_option_table[] =
 564 {
 565     { LLDB_OPT_SET_1, false, "one-liner", 'o', OptionParser::eRequiredArgument, NULL, 0, eArgTypeOneLiner,
 566         "Specify a one-line breakpoint command inline. Be sure to surround it with quotes." },
 567
 568     { LLDB_OPT_SET_ALL, false, "stop-on-error", 'e', OptionParser::eRequiredArgument, NULL, 0, eArgTypeBoolean,
 569         "Specify whether breakpoint command execution should terminate on error." },
 570
 571     { LLDB_OPT_SET_ALL,   false, "script-type",     's', OptionParser::eRequiredArgument, g_script_option_enumeration, 0, eArgTypeNone,
 572         "Specify the language for the commands - if none is specified, the lldb command interpreter will be used."},
 573
 574     { LLDB_OPT_SET_2,   false, "python-function",     'F', OptionParser::eRequiredArgument, NULL, 0, eArgTypePythonFunction,
 575         "Give the name of a Python function to run as command for this breakpoint. Be sure to give a module name if appropriate."},
 576
 577     { 0, false, NULL, 0, 0, NULL, 0, eArgTypeNone, NULL }
 578 };
 579
 580 //-------------------------------------------------------------------------
 581 // CommandObjectBreakpointCommandDelete
 582 //-------------------------------------------------------------------------
 583
 584 class CommandObjectBreakpointCommandDelete : public CommandObjectParsed
 585 {
 586 public:
 587     CommandObjectBreakpointCommandDelete (CommandInterpreter &interpreter) :
 588         CommandObjectParsed (interpreter,
 589                              "delete",
 590                              "Delete the set of commands from a breakpoint.",
 591                              NULL)
 592     {
 593         CommandArgumentEntry arg;
 594         CommandArgumentData bp_id_arg;
 595
 596         // Define the first (and only) variant of this arg.
 597         bp_id_arg.arg_type = eArgTypeBreakpointID;
 598         bp_id_arg.arg_repetition = eArgRepeatPlain;
 599
 600         // There is only one variant this argument could be; put it into the argument entry.
 601         arg.push_back (bp_id_arg);
 602
 603         // Push the data for the first argument into the m_arguments vector.
 604         m_arguments.push_back (arg);
 605     }
 606
 607
 608     virtual
 609     ~CommandObjectBreakpointCommandDelete () {}
 610
 611 protected:
 612     virtual bool
 613     DoExecute (Args& command, CommandReturnObject &result)
 614     {
 615         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
 616
 617         if (target == NULL)
 618         {
 619             result.AppendError ("There is not a current executable; there are no breakpoints from which to delete commands");
 620             result.SetStatus (eReturnStatusFailed);
 621             return false;
 622         }
 623
 624         const BreakpointList &breakpoints = target->GetBreakpointList();
 625         size_t num_breakpoints = breakpoints.GetSize();
 626
 627         if (num_breakpoints == 0)
 628         {
 629             result.AppendError ("No breakpoints exist to have commands deleted");
 630             result.SetStatus (eReturnStatusFailed);
 631             return false;
 632         }
 633
 634         if (command.GetArgumentCount() == 0)
 635         {
 636             result.AppendError ("No breakpoint specified from which to delete the commands");
 637             result.SetStatus (eReturnStatusFailed);
 638             return false;
 639         }
 640
 641         BreakpointIDList valid_bp_ids;
 642         CommandObjectMultiwordBreakpoint::VerifyBreakpointIDs (command, target, result, &valid_bp_ids);
 643
 644         if (result.Succeeded())
 645         {
 646             const size_t count = valid_bp_ids.GetSize();
 647             for (size_t i = 0; i < count; ++i)
 648             {
 649                 BreakpointID cur_bp_id = valid_bp_ids.GetBreakpointIDAtIndex (i);
 650                 if (cur_bp_id.GetBreakpointID() != LLDB_INVALID_BREAK_ID)
 651                 {
 652                     Breakpoint *bp = target->GetBreakpointByID (cur_bp_id.GetBreakpointID()).get();
 653                     if (cur_bp_id.GetLocationID() != LLDB_INVALID_BREAK_ID)
 654                     {
 655                         BreakpointLocationSP bp_loc_sp (bp->FindLocationByID (cur_bp_id.GetLocationID()));
 656                         if (bp_loc_sp)
 657                             bp_loc_sp->ClearCallback();
 658                         else
 659                         {
 660                             result.AppendErrorWithFormat("Invalid breakpoint ID: %u.%u.\n",
 661                                                          cur_bp_id.GetBreakpointID(),
 662                                                          cur_bp_id.GetLocationID());
 663                             result.SetStatus (eReturnStatusFailed);
 664                             return false;
 665                         }
 666                     }
 667                     else
 668                     {
 669                         bp->ClearCallback();
 670                     }
 671                 }
 672             }
 673         }
 674         return result.Succeeded();
 675     }
 676 };
 677
 678 //-------------------------------------------------------------------------
 679 // CommandObjectBreakpointCommandList
 680 //-------------------------------------------------------------------------
 681
 682 class CommandObjectBreakpointCommandList : public CommandObjectParsed
 683 {
 684 public:
 685     CommandObjectBreakpointCommandList (CommandInterpreter &interpreter) :
 686         CommandObjectParsed (interpreter,
 687                              "list",
 688                              "List the script or set of commands to be executed when the breakpoint is hit.",
 689                               NULL)
 690     {
 691         CommandArgumentEntry arg;
 692         CommandArgumentData bp_id_arg;
 693
 694         // Define the first (and only) variant of this arg.
 695         bp_id_arg.arg_type = eArgTypeBreakpointID;
 696         bp_id_arg.arg_repetition = eArgRepeatPlain;
 697
 698         // There is only one variant this argument could be; put it into the argument entry.
 699         arg.push_back (bp_id_arg);
 700
 701         // Push the data for the first argument into the m_arguments vector.
 702         m_arguments.push_back (arg);
 703     }
 704
 705     virtual
 706     ~CommandObjectBreakpointCommandList () {}
 707
 708 protected:
 709     virtual bool
 710     DoExecute (Args& command,
 711              CommandReturnObject &result)
 712     {
 713         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
 714
 715         if (target == NULL)
 716         {
 717             result.AppendError ("There is not a current executable; there are no breakpoints for which to list commands");
 718             result.SetStatus (eReturnStatusFailed);
 719             return false;
 720         }
 721
 722         const BreakpointList &breakpoints = target->GetBreakpointList();
 723         size_t num_breakpoints = breakpoints.GetSize();
 724
 725         if (num_breakpoints == 0)
 726         {
 727             result.AppendError ("No breakpoints exist for which to list commands");
 728             result.SetStatus (eReturnStatusFailed);
 729             return false;
 730         }
 731
 732         if (command.GetArgumentCount() == 0)
 733         {
 734             result.AppendError ("No breakpoint specified for which to list the commands");
 735             result.SetStatus (eReturnStatusFailed);
 736             return false;
 737         }
 738
 739         BreakpointIDList valid_bp_ids;
 740         CommandObjectMultiwordBreakpoint::VerifyBreakpointIDs (command, target, result, &valid_bp_ids);
 741
 742         if (result.Succeeded())
 743         {
 744             const size_t count = valid_bp_ids.GetSize();
 745             for (size_t i = 0; i < count; ++i)
 746             {
 747                 BreakpointID cur_bp_id = valid_bp_ids.GetBreakpointIDAtIndex (i);
 748                 if (cur_bp_id.GetBreakpointID() != LLDB_INVALID_BREAK_ID)
 749                 {
 750                     Breakpoint *bp = target->GetBreakpointByID (cur_bp_id.GetBreakpointID()).get();
 751
 752                     if (bp)
 753                     {
 754                         const BreakpointOptions *bp_options = NULL;
 755                         if (cur_bp_id.GetLocationID() != LLDB_INVALID_BREAK_ID)
 756                         {
 757                             BreakpointLocationSP bp_loc_sp(bp->FindLocationByID (cur_bp_id.GetLocationID()));
 758                             if (bp_loc_sp)
 759                                 bp_options = bp_loc_sp->GetOptionsNoCreate();
 760                             else
 761                             {
 762                                 result.AppendErrorWithFormat("Invalid breakpoint ID: %u.%u.\n",
 763                                                              cur_bp_id.GetBreakpointID(),
 764                                                              cur_bp_id.GetLocationID());
 765                                 result.SetStatus (eReturnStatusFailed);
 766                                 return false;
 767                             }
 768                         }
 769                         else
 770                         {
 771                             bp_options = bp->GetOptions();
 772                         }
 773
 774                         if (bp_options)
 775                         {
 776                             StreamString id_str;
 777                             BreakpointID::GetCanonicalReference (&id_str,
 778                                                                  cur_bp_id.GetBreakpointID(),
 779                                                                  cur_bp_id.GetLocationID());
 780                             const Baton *baton = bp_options->GetBaton();
 781                             if (baton)
 782                             {
 783                                 result.GetOutputStream().Printf ("Breakpoint %s:\n", id_str.GetData());
 784                                 result.GetOutputStream().IndentMore ();
 785                                 baton->GetDescription(&result.GetOutputStream(), eDescriptionLevelFull);
 786                                 result.GetOutputStream().IndentLess ();
 787                             }
 788                             else
 789                             {
 790                                 result.AppendMessageWithFormat ("Breakpoint %s does not have an associated command.\n",
 791                                                                 id_str.GetData());
 792                             }
 793                         }
 794                         result.SetStatus (eReturnStatusSuccessFinishResult);
 795                     }
 796                     else
 797                     {
 798                         result.AppendErrorWithFormat("Invalid breakpoint ID: %u.\n", cur_bp_id.GetBreakpointID());
 799                         result.SetStatus (eReturnStatusFailed);
 800                     }
 801
 802                 }
 803             }
 804         }
 805
 806         return result.Succeeded();
 807     }
 808 };
 809
 810 //-------------------------------------------------------------------------
 811 // CommandObjectBreakpointCommand
 812 //-------------------------------------------------------------------------
 813
 814 CommandObjectBreakpointCommand::CommandObjectBreakpointCommand (CommandInterpreter &interpreter) :
 815     CommandObjectMultiword (interpreter,
 816                             "command",
 817                             "A set of commands for adding, removing and examining bits of code to be executed when the breakpoint is hit (breakpoint 'commmands').",
 818                             "command <sub-command> [<sub-command-options>] <breakpoint-id>")
 819 {
 820     CommandObjectSP add_command_object (new CommandObjectBreakpointCommandAdd (interpreter));
 821     CommandObjectSP delete_command_object (new CommandObjectBreakpointCommandDelete (interpreter));
 822     CommandObjectSP list_command_object (new CommandObjectBreakpointCommandList (interpreter));
 823
 824     add_command_object->SetCommandName ("breakpoint command add");
 825     delete_command_object->SetCommandName ("breakpoint command delete");
 826     list_command_object->SetCommandName ("breakpoint command list");
 827
 828     LoadSubCommand ("add",    add_command_object);
 829     LoadSubCommand ("delete", delete_command_object);
 830     LoadSubCommand ("list",   list_command_object);
 831 }
 832
 833 CommandObjectBreakpointCommand::~CommandObjectBreakpointCommand ()
 834 {
 835 }
 836
 837