contrib/llvm/tools/lldb/source/Breakpoint/BreakpointOptions.cpp

   1 //===-- BreakpointOptions.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/Breakpoint/BreakpointOptions.h"
  11
  12 #include "lldb/Breakpoint/StoppointCallbackContext.h"
  13 #include "lldb/Core/Value.h"
  14 #include "lldb/Interpreter/CommandInterpreter.h"
  15 #include "lldb/Interpreter/CommandReturnObject.h"
  16 #include "lldb/Target/Process.h"
  17 #include "lldb/Target/Target.h"
  18 #include "lldb/Target/ThreadSpec.h"
  19 #include "lldb/Utility/Stream.h"
  20 #include "lldb/Utility/StringList.h"
  21
  22 #include "llvm/ADT/STLExtras.h"
  23
  24 using namespace lldb;
  25 using namespace lldb_private;
  26
  27 const char
  28     *BreakpointOptions::CommandData::g_option_names[static_cast<uint32_t>(
  29         BreakpointOptions::CommandData::OptionNames::LastOptionName)]{
  30         "UserSource", "ScriptSource", "StopOnError"};
  31
  32 StructuredData::ObjectSP
  33 BreakpointOptions::CommandData::SerializeToStructuredData() {
  34   size_t num_strings = user_source.GetSize();
  35   if (num_strings == 0 && script_source.empty()) {
  36     // We shouldn't serialize commands if there aren't any, return an empty sp
  37     // to indicate this.
  38     return StructuredData::ObjectSP();
  39   }
  40
  41   StructuredData::DictionarySP options_dict_sp(
  42       new StructuredData::Dictionary());
  43   options_dict_sp->AddBooleanItem(GetKey(OptionNames::StopOnError),
  44                                   stop_on_error);
  45
  46   StructuredData::ArraySP user_source_sp(new StructuredData::Array());
  47   for (size_t i = 0; i < num_strings; i++) {
  48     StructuredData::StringSP item_sp(
  49         new StructuredData::String(user_source[i]));
  50     user_source_sp->AddItem(item_sp);
  51     options_dict_sp->AddItem(GetKey(OptionNames::UserSource), user_source_sp);
  52   }
  53
  54   options_dict_sp->AddStringItem(
  55       GetKey(OptionNames::Interpreter),
  56       ScriptInterpreter::LanguageToString(interpreter));
  57   return options_dict_sp;
  58 }
  59
  60 std::unique_ptr<BreakpointOptions::CommandData>
  61 BreakpointOptions::CommandData::CreateFromStructuredData(
  62     const StructuredData::Dictionary &options_dict, Status &error) {
  63   std::unique_ptr<CommandData> data_up(new CommandData());
  64   bool found_something = false;
  65
  66   bool success = options_dict.GetValueForKeyAsBoolean(
  67       GetKey(OptionNames::StopOnError), data_up->stop_on_error);
  68
  69   if (success)
  70     found_something = true;
  71
  72   llvm::StringRef interpreter_str;
  73   ScriptLanguage interp_language;
  74   success = options_dict.GetValueForKeyAsString(
  75       GetKey(OptionNames::Interpreter), interpreter_str);
  76
  77   if (!success) {
  78     error.SetErrorString("Missing command language value.");
  79     return data_up;
  80   }
  81
  82   found_something = true;
  83   interp_language = ScriptInterpreter::StringToLanguage(interpreter_str);
  84   if (interp_language == eScriptLanguageUnknown) {
  85     error.SetErrorStringWithFormatv("Unknown breakpoint command language: {0}.",
  86                                     interpreter_str);
  87     return data_up;
  88   }
  89   data_up->interpreter = interp_language;
  90
  91   StructuredData::Array *user_source;
  92   success = options_dict.GetValueForKeyAsArray(GetKey(OptionNames::UserSource),
  93                                                user_source);
  94   if (success) {
  95     found_something = true;
  96     size_t num_elems = user_source->GetSize();
  97     for (size_t i = 0; i < num_elems; i++) {
  98       llvm::StringRef elem_string;
  99       success = user_source->GetItemAtIndexAsString(i, elem_string);
 100       if (success)
 101         data_up->user_source.AppendString(elem_string);
 102     }
 103   }
 104
 105   if (found_something)
 106     return data_up;
 107   else
 108     return std::unique_ptr<BreakpointOptions::CommandData>();
 109 }
 110
 111 const char *BreakpointOptions::g_option_names[(
 112     size_t)BreakpointOptions::OptionNames::LastOptionName]{
 113     "ConditionText", "IgnoreCount",
 114     "EnabledState", "OneShotState", "AutoContinue"};
 115
 116 bool BreakpointOptions::NullCallback(void *baton,
 117                                      StoppointCallbackContext *context,
 118                                      lldb::user_id_t break_id,
 119                                      lldb::user_id_t break_loc_id) {
 120   return true;
 121 }
 122
 123 //----------------------------------------------------------------------
 124 // BreakpointOptions constructor
 125 //----------------------------------------------------------------------
 126 BreakpointOptions::BreakpointOptions(bool all_flags_set)
 127     : m_callback(BreakpointOptions::NullCallback), m_callback_baton_sp(),
 128       m_baton_is_command_baton(false), m_callback_is_synchronous(false),
 129       m_enabled(true), m_one_shot(false), m_ignore_count(0), m_thread_spec_ap(),
 130       m_condition_text(), m_condition_text_hash(0), m_auto_continue(false),
 131       m_set_flags(0) {
 132         if (all_flags_set)
 133           m_set_flags.Set(~((Flags::ValueType) 0));
 134       }
 135
 136 BreakpointOptions::BreakpointOptions(const char *condition, bool enabled,
 137                                      int32_t ignore, bool one_shot,
 138                                      bool auto_continue)
 139     : m_callback(nullptr), m_baton_is_command_baton(false),
 140       m_callback_is_synchronous(false), m_enabled(enabled),
 141       m_one_shot(one_shot), m_ignore_count(ignore),
 142       m_condition_text_hash(0), m_auto_continue(auto_continue)
 143 {
 144     m_set_flags.Set(eEnabled | eIgnoreCount | eOneShot
 145                    | eAutoContinue);
 146     if (condition && *condition != '\0') {
 147       SetCondition(condition);
 148     }
 149 }
 150
 151 //----------------------------------------------------------------------
 152 // BreakpointOptions copy constructor
 153 //----------------------------------------------------------------------
 154 BreakpointOptions::BreakpointOptions(const BreakpointOptions &rhs)
 155     : m_callback(rhs.m_callback), m_callback_baton_sp(rhs.m_callback_baton_sp),
 156       m_baton_is_command_baton(rhs.m_baton_is_command_baton),
 157       m_callback_is_synchronous(rhs.m_callback_is_synchronous),
 158       m_enabled(rhs.m_enabled), m_one_shot(rhs.m_one_shot),
 159       m_ignore_count(rhs.m_ignore_count), m_thread_spec_ap(),
 160       m_auto_continue(rhs.m_auto_continue),
 161       m_set_flags(rhs.m_set_flags) {
 162   if (rhs.m_thread_spec_ap.get() != nullptr)
 163     m_thread_spec_ap.reset(new ThreadSpec(*rhs.m_thread_spec_ap.get()));
 164   m_condition_text = rhs.m_condition_text;
 165   m_condition_text_hash = rhs.m_condition_text_hash;
 166 }
 167
 168 //----------------------------------------------------------------------
 169 // BreakpointOptions assignment operator
 170 //----------------------------------------------------------------------
 171 const BreakpointOptions &BreakpointOptions::
 172 operator=(const BreakpointOptions &rhs) {
 173   m_callback = rhs.m_callback;
 174   m_callback_baton_sp = rhs.m_callback_baton_sp;
 175   m_baton_is_command_baton = rhs.m_baton_is_command_baton;
 176   m_callback_is_synchronous = rhs.m_callback_is_synchronous;
 177   m_enabled = rhs.m_enabled;
 178   m_one_shot = rhs.m_one_shot;
 179   m_ignore_count = rhs.m_ignore_count;
 180   if (rhs.m_thread_spec_ap.get() != nullptr)
 181     m_thread_spec_ap.reset(new ThreadSpec(*rhs.m_thread_spec_ap.get()));
 182   m_condition_text = rhs.m_condition_text;
 183   m_condition_text_hash = rhs.m_condition_text_hash;
 184   m_auto_continue = rhs.m_auto_continue;
 185   m_set_flags = rhs.m_set_flags;
 186   return *this;
 187 }
 188
 189 void BreakpointOptions::CopyOverSetOptions(const BreakpointOptions &incoming)
 190 {
 191   if (incoming.m_set_flags.Test(eEnabled))
 192   {
 193     m_enabled = incoming.m_enabled;
 194     m_set_flags.Set(eEnabled);
 195   }
 196   if (incoming.m_set_flags.Test(eOneShot))
 197   {
 198     m_one_shot = incoming.m_one_shot;
 199     m_set_flags.Set(eOneShot);
 200   }
 201   if (incoming.m_set_flags.Test(eCallback))
 202   {
 203     m_callback = incoming.m_callback;
 204     m_callback_baton_sp = incoming.m_callback_baton_sp;
 205     m_callback_is_synchronous = incoming.m_callback_is_synchronous;
 206     m_baton_is_command_baton = incoming.m_baton_is_command_baton;
 207     m_set_flags.Set(eCallback);
 208   }
 209   if (incoming.m_set_flags.Test(eIgnoreCount))
 210   {
 211     m_ignore_count = incoming.m_ignore_count;
 212     m_set_flags.Set(eIgnoreCount);
 213   }
 214   if (incoming.m_set_flags.Test(eCondition))
 215   {
 216     // If we're copying over an empty condition, mark it as unset.
 217     if (incoming.m_condition_text.empty()) {
 218       m_condition_text.clear();
 219       m_condition_text_hash = 0;
 220       m_set_flags.Clear(eCondition);
 221     } else {
 222       m_condition_text = incoming.m_condition_text;
 223       m_condition_text_hash = incoming.m_condition_text_hash;
 224       m_set_flags.Set(eCondition);
 225     }
 226   }
 227   if (incoming.m_set_flags.Test(eAutoContinue))
 228   {
 229     m_auto_continue = incoming.m_auto_continue;
 230     m_set_flags.Set(eAutoContinue);
 231   }
 232   if (incoming.m_set_flags.Test(eThreadSpec) && incoming.m_thread_spec_ap)
 233   {
 234     if (!m_thread_spec_ap)
 235       m_thread_spec_ap.reset(new ThreadSpec(*incoming.m_thread_spec_ap.get()));
 236     else
 237       *m_thread_spec_ap.get() = *incoming.m_thread_spec_ap.get();
 238     m_set_flags.Set(eThreadSpec);
 239   }
 240 }
 241
 242 //----------------------------------------------------------------------
 243 // Destructor
 244 //----------------------------------------------------------------------
 245 BreakpointOptions::~BreakpointOptions() = default;
 246
 247 std::unique_ptr<BreakpointOptions> BreakpointOptions::CreateFromStructuredData(
 248     Target &target, const StructuredData::Dictionary &options_dict,
 249     Status &error) {
 250   bool enabled = true;
 251   bool one_shot = false;
 252   bool auto_continue = false;
 253   int32_t ignore_count = 0;
 254   llvm::StringRef condition_ref("");
 255   Flags set_options;
 256
 257   const char *key = GetKey(OptionNames::EnabledState);
 258   bool success;
 259   if (key) {
 260     success = options_dict.GetValueForKeyAsBoolean(key, enabled);
 261     if (!success) {
 262       error.SetErrorStringWithFormat("%s key is not a boolean.",
 263                                    GetKey(OptionNames::EnabledState));
 264       return nullptr;
 265     }
 266     set_options.Set(eEnabled);
 267   }
 268
 269   key = GetKey(OptionNames::OneShotState);
 270   if (key) {
 271     success = options_dict.GetValueForKeyAsBoolean(key, one_shot);
 272     if (!success) {
 273       error.SetErrorStringWithFormat("%s key is not a boolean.",
 274                                      GetKey(OptionNames::OneShotState));
 275       return nullptr;
 276       }
 277       set_options.Set(eOneShot);
 278   }
 279
 280   key = GetKey(OptionNames::AutoContinue);
 281   if (key) {
 282     success = options_dict.GetValueForKeyAsBoolean(key, auto_continue);
 283     if (!success) {
 284       error.SetErrorStringWithFormat("%s key is not a boolean.",
 285                                      GetKey(OptionNames::AutoContinue));
 286       return nullptr;
 287       }
 288       set_options.Set(eAutoContinue);
 289   }
 290
 291   key = GetKey(OptionNames::IgnoreCount);
 292   if (key) {
 293     success = options_dict.GetValueForKeyAsInteger(key, ignore_count);
 294     if (!success) {
 295       error.SetErrorStringWithFormat("%s key is not an integer.",
 296                                      GetKey(OptionNames::IgnoreCount));
 297       return nullptr;
 298     }
 299     set_options.Set(eIgnoreCount);
 300   }
 301
 302   key = GetKey(OptionNames::ConditionText);
 303   if (key) {
 304     success = options_dict.GetValueForKeyAsString(key, condition_ref);
 305     if (!success) {
 306       error.SetErrorStringWithFormat("%s key is not an string.",
 307                                      GetKey(OptionNames::ConditionText));
 308       return nullptr;
 309     }
 310     set_options.Set(eCondition);
 311   }
 312
 313   std::unique_ptr<CommandData> cmd_data_up;
 314   StructuredData::Dictionary *cmds_dict;
 315   success = options_dict.GetValueForKeyAsDictionary(
 316       CommandData::GetSerializationKey(), cmds_dict);
 317   if (success && cmds_dict) {
 318     Status cmds_error;
 319     cmd_data_up = CommandData::CreateFromStructuredData(*cmds_dict, cmds_error);
 320     if (cmds_error.Fail()) {
 321       error.SetErrorStringWithFormat(
 322           "Failed to deserialize breakpoint command options: %s.",
 323           cmds_error.AsCString());
 324       return nullptr;
 325     }
 326   }
 327
 328   auto bp_options = llvm::make_unique<BreakpointOptions>(
 329       condition_ref.str().c_str(), enabled,
 330       ignore_count, one_shot, auto_continue);
 331   if (cmd_data_up.get()) {
 332     if (cmd_data_up->interpreter == eScriptLanguageNone)
 333       bp_options->SetCommandDataCallback(cmd_data_up);
 334     else {
 335       ScriptInterpreter *interp =
 336           target.GetDebugger().GetCommandInterpreter().GetScriptInterpreter();
 337       if (!interp) {
 338         error.SetErrorStringWithFormat(
 339             "Can't set script commands - no script interpreter");
 340         return nullptr;
 341       }
 342       if (interp->GetLanguage() != cmd_data_up->interpreter) {
 343         error.SetErrorStringWithFormat(
 344             "Current script language doesn't match breakpoint's language: %s",
 345             ScriptInterpreter::LanguageToString(cmd_data_up->interpreter)
 346                 .c_str());
 347         return nullptr;
 348       }
 349       Status script_error;
 350       script_error =
 351           interp->SetBreakpointCommandCallback(bp_options.get(), cmd_data_up);
 352       if (script_error.Fail()) {
 353         error.SetErrorStringWithFormat("Error generating script callback: %s.",
 354                                        error.AsCString());
 355         return nullptr;
 356       }
 357     }
 358   }
 359
 360   StructuredData::Dictionary *thread_spec_dict;
 361   success = options_dict.GetValueForKeyAsDictionary(
 362       ThreadSpec::GetSerializationKey(), thread_spec_dict);
 363   if (success) {
 364     Status thread_spec_error;
 365     std::unique_ptr<ThreadSpec> thread_spec_up =
 366         ThreadSpec::CreateFromStructuredData(*thread_spec_dict,
 367                                              thread_spec_error);
 368     if (thread_spec_error.Fail()) {
 369       error.SetErrorStringWithFormat(
 370           "Failed to deserialize breakpoint thread spec options: %s.",
 371           thread_spec_error.AsCString());
 372       return nullptr;
 373     }
 374     bp_options->SetThreadSpec(thread_spec_up);
 375   }
 376   return bp_options;
 377 }
 378
 379 StructuredData::ObjectSP BreakpointOptions::SerializeToStructuredData() {
 380   StructuredData::DictionarySP options_dict_sp(
 381       new StructuredData::Dictionary());
 382   if (m_set_flags.Test(eEnabled))
 383     options_dict_sp->AddBooleanItem(GetKey(OptionNames::EnabledState),
 384                                     m_enabled);
 385   if (m_set_flags.Test(eOneShot))
 386     options_dict_sp->AddBooleanItem(GetKey(OptionNames::OneShotState),
 387                                m_one_shot);
 388   if (m_set_flags.Test(eAutoContinue))
 389     options_dict_sp->AddBooleanItem(GetKey(OptionNames::AutoContinue),
 390                                m_auto_continue);
 391   if (m_set_flags.Test(eIgnoreCount))
 392     options_dict_sp->AddIntegerItem(GetKey(OptionNames::IgnoreCount),
 393                                     m_ignore_count);
 394   if (m_set_flags.Test(eCondition))
 395     options_dict_sp->AddStringItem(GetKey(OptionNames::ConditionText),
 396                                    m_condition_text);
 397
 398   if (m_set_flags.Test(eCallback) && m_baton_is_command_baton) {
 399     auto cmd_baton =
 400         std::static_pointer_cast<CommandBaton>(m_callback_baton_sp);
 401     StructuredData::ObjectSP commands_sp =
 402         cmd_baton->getItem()->SerializeToStructuredData();
 403     if (commands_sp) {
 404       options_dict_sp->AddItem(
 405           BreakpointOptions::CommandData::GetSerializationKey(), commands_sp);
 406     }
 407   }
 408   if (m_set_flags.Test(eThreadSpec) && m_thread_spec_ap) {
 409     StructuredData::ObjectSP thread_spec_sp =
 410         m_thread_spec_ap->SerializeToStructuredData();
 411     options_dict_sp->AddItem(ThreadSpec::GetSerializationKey(), thread_spec_sp);
 412   }
 413
 414   return options_dict_sp;
 415 }
 416
 417 //------------------------------------------------------------------
 418 // Callbacks
 419 //------------------------------------------------------------------
 420 void BreakpointOptions::SetCallback(BreakpointHitCallback callback,
 421                                     const lldb::BatonSP &callback_baton_sp,
 422                                     bool callback_is_synchronous) {
 423   // FIXME: This seems unsafe.  If BatonSP actually *is* a CommandBaton, but
 424   // in a shared_ptr<Baton> instead of a shared_ptr<CommandBaton>, then we will
 425   // set m_baton_is_command_baton to false, which is incorrect. One possible
 426   // solution is to make the base Baton class provide a method such as:
 427   //     virtual StringRef getBatonId() const { return ""; }
 428   // and have CommandBaton override this to return something unique, and then
 429   // check for it here.  Another option might be to make Baton using the llvm
 430   // casting infrastructure, so that we could write something like:
 431   //     if (llvm::isa<CommandBaton>(callback_baton_sp))
 432   // at relevant callsites instead of storing a boolean.
 433   m_callback_is_synchronous = callback_is_synchronous;
 434   m_callback = callback;
 435   m_callback_baton_sp = callback_baton_sp;
 436   m_baton_is_command_baton = false;
 437   m_set_flags.Set(eCallback);
 438 }
 439
 440 void BreakpointOptions::SetCallback(
 441     BreakpointHitCallback callback,
 442     const BreakpointOptions::CommandBatonSP &callback_baton_sp,
 443     bool callback_is_synchronous) {
 444   m_callback_is_synchronous = callback_is_synchronous;
 445   m_callback = callback;
 446   m_callback_baton_sp = callback_baton_sp;
 447   m_baton_is_command_baton = true;
 448   m_set_flags.Set(eCallback);
 449 }
 450
 451 void BreakpointOptions::ClearCallback() {
 452   m_callback = BreakpointOptions::NullCallback;
 453   m_callback_is_synchronous = false;
 454   m_callback_baton_sp.reset();
 455   m_baton_is_command_baton = false;
 456   m_set_flags.Clear(eCallback);
 457 }
 458
 459 Baton *BreakpointOptions::GetBaton() { return m_callback_baton_sp.get(); }
 460
 461 const Baton *BreakpointOptions::GetBaton() const {
 462   return m_callback_baton_sp.get();
 463 }
 464
 465 bool BreakpointOptions::InvokeCallback(StoppointCallbackContext *context,
 466                                        lldb::user_id_t break_id,
 467                                        lldb::user_id_t break_loc_id) {
 468   if (m_callback) {
 469     if (context->is_synchronous == IsCallbackSynchronous()) {
 470         return m_callback(m_callback_baton_sp ? m_callback_baton_sp->data()
 471                                           : nullptr,
 472                       context, break_id, break_loc_id);
 473     } else if (IsCallbackSynchronous()) {
 474       // If a synchronous callback is called at async time, it should not say
 475       // to stop.
 476       return false;
 477     }
 478   }
 479   return true;
 480 }
 481
 482 bool BreakpointOptions::HasCallback() const {
 483   return m_callback != BreakpointOptions::NullCallback;
 484 }
 485
 486 bool BreakpointOptions::GetCommandLineCallbacks(StringList &command_list) {
 487   if (!HasCallback())
 488     return false;
 489   if (!m_baton_is_command_baton)
 490     return false;
 491
 492   auto cmd_baton = std::static_pointer_cast<CommandBaton>(m_callback_baton_sp);
 493   CommandData *data = cmd_baton->getItem();
 494   if (!data)
 495     return false;
 496   command_list = data->user_source;
 497   return true;
 498 }
 499
 500 void BreakpointOptions::SetCondition(const char *condition) {
 501   if (!condition || condition[0] == '\0') {
 502     condition = "";
 503     m_set_flags.Clear(eCondition);
 504   }
 505   else
 506     m_set_flags.Set(eCondition);
 507
 508   m_condition_text.assign(condition);
 509   std::hash<std::string> hasher;
 510   m_condition_text_hash = hasher(m_condition_text);
 511 }
 512
 513 const char *BreakpointOptions::GetConditionText(size_t *hash) const {
 514   if (!m_condition_text.empty()) {
 515     if (hash)
 516       *hash = m_condition_text_hash;
 517
 518     return m_condition_text.c_str();
 519   } else {
 520     return nullptr;
 521   }
 522 }
 523
 524 const ThreadSpec *BreakpointOptions::GetThreadSpecNoCreate() const {
 525   return m_thread_spec_ap.get();
 526 }
 527
 528 ThreadSpec *BreakpointOptions::GetThreadSpec() {
 529   if (m_thread_spec_ap.get() == nullptr)
 530   {
 531     m_set_flags.Set(eThreadSpec);
 532     m_thread_spec_ap.reset(new ThreadSpec());
 533   }
 534
 535   return m_thread_spec_ap.get();
 536 }
 537
 538 void BreakpointOptions::SetThreadID(lldb::tid_t thread_id) {
 539   GetThreadSpec()->SetTID(thread_id);
 540   m_set_flags.Set(eThreadSpec);
 541 }
 542
 543 void BreakpointOptions::SetThreadSpec(
 544     std::unique_ptr<ThreadSpec> &thread_spec_up) {
 545   m_thread_spec_ap = std::move(thread_spec_up);
 546   m_set_flags.Set(eThreadSpec);
 547 }
 548
 549 void BreakpointOptions::GetDescription(Stream *s,
 550                                        lldb::DescriptionLevel level) const {
 551   // Figure out if there are any options not at their default value, and only
 552   // print anything if there are:
 553
 554   if (m_ignore_count != 0 || !m_enabled || m_one_shot || m_auto_continue ||
 555       (GetThreadSpecNoCreate() != nullptr &&
 556        GetThreadSpecNoCreate()->HasSpecification())) {
 557     if (level == lldb::eDescriptionLevelVerbose) {
 558       s->EOL();
 559       s->IndentMore();
 560       s->Indent();
 561       s->PutCString("Breakpoint Options:\n");
 562       s->IndentMore();
 563       s->Indent();
 564     } else
 565       s->PutCString(" Options: ");
 566
 567     if (m_ignore_count > 0)
 568       s->Printf("ignore: %d ", m_ignore_count);
 569     s->Printf("%sabled ", m_enabled ? "en" : "dis");
 570
 571     if (m_one_shot)
 572       s->Printf("one-shot ");
 573
 574     if (m_auto_continue)
 575       s->Printf("auto-continue ");
 576
 577     if (m_thread_spec_ap.get())
 578       m_thread_spec_ap->GetDescription(s, level);
 579
 580     if (level == lldb::eDescriptionLevelFull) {
 581       s->IndentLess();
 582       s->IndentMore();
 583     }
 584   }
 585
 586   if (m_callback_baton_sp.get()) {
 587     if (level != eDescriptionLevelBrief) {
 588       s->EOL();
 589       m_callback_baton_sp->GetDescription(s, level);
 590     }
 591   }
 592   if (!m_condition_text.empty()) {
 593     if (level != eDescriptionLevelBrief) {
 594       s->EOL();
 595       s->Printf("Condition: %s\n", m_condition_text.c_str());
 596     }
 597   }
 598 }
 599
 600 void BreakpointOptions::CommandBaton::GetDescription(
 601     Stream *s, lldb::DescriptionLevel level) const {
 602   const CommandData *data = getItem();
 603
 604   if (level == eDescriptionLevelBrief) {
 605     s->Printf(", commands = %s",
 606               (data && data->user_source.GetSize() > 0) ? "yes" : "no");
 607     return;
 608   }
 609
 610   s->IndentMore();
 611   s->Indent("Breakpoint commands");
 612   if (data->interpreter != eScriptLanguageNone)
 613     s->Printf(" (%s):\n",
 614               ScriptInterpreter::LanguageToString(data->interpreter).c_str());
 615   else
 616     s->PutCString(":\n");
 617
 618   s->IndentMore();
 619   if (data && data->user_source.GetSize() > 0) {
 620     const size_t num_strings = data->user_source.GetSize();
 621     for (size_t i = 0; i < num_strings; ++i) {
 622       s->Indent(data->user_source.GetStringAtIndex(i));
 623       s->EOL();
 624     }
 625   } else {
 626     s->PutCString("No commands.\n");
 627   }
 628   s->IndentLess();
 629   s->IndentLess();
 630 }
 631
 632 void BreakpointOptions::SetCommandDataCallback(
 633     std::unique_ptr<CommandData> &cmd_data) {
 634   cmd_data->interpreter = eScriptLanguageNone;
 635   auto baton_sp = std::make_shared<CommandBaton>(std::move(cmd_data));
 636   SetCallback(BreakpointOptions::BreakpointOptionsCallbackFunction, baton_sp);
 637   m_set_flags.Set(eCallback);
 638 }
 639
 640 bool BreakpointOptions::BreakpointOptionsCallbackFunction(
 641     void *baton, StoppointCallbackContext *context, lldb::user_id_t break_id,
 642     lldb::user_id_t break_loc_id) {
 643   bool ret_value = true;
 644   if (baton == nullptr)
 645     return true;
 646
 647   CommandData *data = (CommandData *)baton;
 648   StringList &commands = data->user_source;
 649
 650   if (commands.GetSize() > 0) {
 651     ExecutionContext exe_ctx(context->exe_ctx_ref);
 652     Target *target = exe_ctx.GetTargetPtr();
 653     if (target) {
 654       CommandReturnObject result;
 655       Debugger &debugger = target->GetDebugger();
 656       // Rig up the results secondary output stream to the debugger's, so the
 657       // output will come out synchronously if the debugger is set up that way.
 658
 659       StreamSP output_stream(debugger.GetAsyncOutputStream());
 660       StreamSP error_stream(debugger.GetAsyncErrorStream());
 661       result.SetImmediateOutputStream(output_stream);
 662       result.SetImmediateErrorStream(error_stream);
 663
 664       CommandInterpreterRunOptions options;
 665       options.SetStopOnContinue(true);
 666       options.SetStopOnError(data->stop_on_error);
 667       options.SetEchoCommands(true);
 668       options.SetPrintResults(true);
 669       options.SetAddToHistory(false);
 670
 671       debugger.GetCommandInterpreter().HandleCommands(commands, &exe_ctx,
 672                                                       options, result);
 673       result.GetImmediateOutputStream()->Flush();
 674       result.GetImmediateErrorStream()->Flush();
 675     }
 676   }
 677   return ret_value;
 678 }
 679
 680 void BreakpointOptions::Clear()
 681 {
 682   m_set_flags.Clear();
 683   m_thread_spec_ap.release();
 684   m_one_shot = false;
 685   m_ignore_count = 0;
 686   m_auto_continue = false;
 687   m_callback = nullptr;
 688   m_callback_baton_sp.reset();
 689   m_baton_is_command_baton = false;
 690   m_callback_is_synchronous = false;
 691   m_enabled = false;
 692   m_condition_text.clear();
 693 }