contrib/llvm-project/lldb/source/Commands/CommandObjectType.cpp

   1 //===-- CommandObjectType.cpp -----------------------------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "CommandObjectType.h"
  10
  11 #include "lldb/Core/Debugger.h"
  12 #include "lldb/Core/IOHandler.h"
  13 #include "lldb/DataFormatters/DataVisualization.h"
  14 #include "lldb/Host/OptionParser.h"
  15 #include "lldb/Interpreter/CommandInterpreter.h"
  16 #include "lldb/Interpreter/CommandObject.h"
  17 #include "lldb/Interpreter/CommandReturnObject.h"
  18 #include "lldb/Interpreter/OptionArgParser.h"
  19 #include "lldb/Interpreter/OptionGroupFormat.h"
  20 #include "lldb/Interpreter/OptionValueBoolean.h"
  21 #include "lldb/Interpreter/OptionValueLanguage.h"
  22 #include "lldb/Interpreter/OptionValueString.h"
  23 #include "lldb/Interpreter/Options.h"
  24 #include "lldb/Symbol/Symbol.h"
  25 #include "lldb/Target/Language.h"
  26 #include "lldb/Target/Process.h"
  27 #include "lldb/Target/StackFrame.h"
  28 #include "lldb/Target/Target.h"
  29 #include "lldb/Target/Thread.h"
  30 #include "lldb/Target/ThreadList.h"
  31 #include "lldb/Utility/ConstString.h"
  32 #include "lldb/Utility/RegularExpression.h"
  33 #include "lldb/Utility/State.h"
  34 #include "lldb/Utility/StringList.h"
  35
  36 #include "llvm/ADT/STLExtras.h"
  37
  38 #include <algorithm>
  39 #include <cctype>
  40 #include <functional>
  41 #include <memory>
  42
  43 using namespace lldb;
  44 using namespace lldb_private;
  45
  46 class ScriptAddOptions {
  47 public:
  48   TypeSummaryImpl::Flags m_flags;
  49   StringList m_target_types;
  50   bool m_regex;
  51   ConstString m_name;
  52   std::string m_category;
  53
  54   ScriptAddOptions(const TypeSummaryImpl::Flags &flags, bool regx,
  55                    ConstString name, std::string catg)
  56       : m_flags(flags), m_regex(regx), m_name(name), m_category(catg) {}
  57
  58   typedef std::shared_ptr<ScriptAddOptions> SharedPointer;
  59 };
  60
  61 class SynthAddOptions {
  62 public:
  63   bool m_skip_pointers;
  64   bool m_skip_references;
  65   bool m_cascade;
  66   bool m_regex;
  67   StringList m_target_types;
  68   std::string m_category;
  69
  70   SynthAddOptions(bool sptr, bool sref, bool casc, bool regx, std::string catg)
  71       : m_skip_pointers(sptr), m_skip_references(sref), m_cascade(casc),
  72         m_regex(regx), m_target_types(), m_category(catg) {}
  73
  74   typedef std::shared_ptr<SynthAddOptions> SharedPointer;
  75 };
  76
  77 static bool WarnOnPotentialUnquotedUnsignedType(Args &command,
  78                                                 CommandReturnObject &result) {
  79   if (command.empty())
  80     return false;
  81
  82   for (auto entry : llvm::enumerate(command.entries().drop_back())) {
  83     if (entry.value().ref != "unsigned")
  84       continue;
  85     auto next = command.entries()[entry.index() + 1].ref;
  86     if (next == "int" || next == "short" || next == "char" || next == "long") {
  87       result.AppendWarningWithFormat(
  88           "unsigned %s being treated as two types. if you meant the combined "
  89           "type "
  90           "name use  quotes, as in \"unsigned %s\"\n",
  91           next.str().c_str(), next.str().c_str());
  92       return true;
  93     }
  94   }
  95   return false;
  96 }
  97
  98 static constexpr OptionDefinition g_type_summary_add_options[] = {
  99 #define LLDB_OPTIONS_type_summary_add
 100 #include "CommandOptions.inc"
 101 };
 102
 103 class CommandObjectTypeSummaryAdd : public CommandObjectParsed,
 104                                     public IOHandlerDelegateMultiline {
 105 private:
 106   class CommandOptions : public Options {
 107   public:
 108     CommandOptions(CommandInterpreter &interpreter) : Options() {}
 109
 110     ~CommandOptions() override = default;
 111
 112     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
 113                           ExecutionContext *execution_context) override;
 114
 115     void OptionParsingStarting(ExecutionContext *execution_context) override;
 116
 117     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
 118       return llvm::makeArrayRef(g_type_summary_add_options);
 119     }
 120
 121     // Instance variables to hold the values for command options.
 122
 123     TypeSummaryImpl::Flags m_flags;
 124     bool m_regex;
 125     std::string m_format_string;
 126     ConstString m_name;
 127     std::string m_python_script;
 128     std::string m_python_function;
 129     bool m_is_add_script;
 130     std::string m_category;
 131   };
 132
 133   CommandOptions m_options;
 134
 135   Options *GetOptions() override { return &m_options; }
 136
 137   bool Execute_ScriptSummary(Args &command, CommandReturnObject &result);
 138
 139   bool Execute_StringSummary(Args &command, CommandReturnObject &result);
 140
 141 public:
 142   enum SummaryFormatType { eRegularSummary, eRegexSummary, eNamedSummary };
 143
 144   CommandObjectTypeSummaryAdd(CommandInterpreter &interpreter);
 145
 146   ~CommandObjectTypeSummaryAdd() override = default;
 147
 148   void IOHandlerActivated(IOHandler &io_handler, bool interactive) override {
 149     static const char *g_summary_addreader_instructions =
 150         "Enter your Python command(s). Type 'DONE' to end.\n"
 151         "def function (valobj,internal_dict):\n"
 152         "     \"\"\"valobj: an SBValue which you want to provide a summary "
 153         "for\n"
 154         "        internal_dict: an LLDB support object not to be used\"\"\"\n";
 155
 156     StreamFileSP output_sp(io_handler.GetOutputStreamFile());
 157     if (output_sp && interactive) {
 158       output_sp->PutCString(g_summary_addreader_instructions);
 159       output_sp->Flush();
 160     }
 161   }
 162
 163   void IOHandlerInputComplete(IOHandler &io_handler,
 164                               std::string &data) override {
 165     StreamFileSP error_sp = io_handler.GetErrorStreamFile();
 166
 167 #ifndef LLDB_DISABLE_PYTHON
 168     ScriptInterpreter *interpreter = GetDebugger().GetScriptInterpreter();
 169     if (interpreter) {
 170       StringList lines;
 171       lines.SplitIntoLines(data);
 172       if (lines.GetSize() > 0) {
 173         ScriptAddOptions *options_ptr =
 174             ((ScriptAddOptions *)io_handler.GetUserData());
 175         if (options_ptr) {
 176           ScriptAddOptions::SharedPointer options(
 177               options_ptr); // this will ensure that we get rid of the pointer
 178                             // when going out of scope
 179
 180           ScriptInterpreter *interpreter = GetDebugger().GetScriptInterpreter();
 181           if (interpreter) {
 182             std::string funct_name_str;
 183             if (interpreter->GenerateTypeScriptFunction(lines,
 184                                                         funct_name_str)) {
 185               if (funct_name_str.empty()) {
 186                 error_sp->Printf("unable to obtain a valid function name from "
 187                                  "the script interpreter.\n");
 188                 error_sp->Flush();
 189               } else {
 190                 // now I have a valid function name, let's add this as script
 191                 // for every type in the list
 192
 193                 TypeSummaryImplSP script_format;
 194                 script_format = std::make_shared<ScriptSummaryFormat>(
 195                     options->m_flags, funct_name_str.c_str(),
 196                     lines.CopyList("    ").c_str());
 197
 198                 Status error;
 199
 200                 for (size_t i = 0; i < options->m_target_types.GetSize(); i++) {
 201                   const char *type_name =
 202                       options->m_target_types.GetStringAtIndex(i);
 203                   CommandObjectTypeSummaryAdd::AddSummary(
 204                       ConstString(type_name), script_format,
 205                       (options->m_regex
 206                            ? CommandObjectTypeSummaryAdd::eRegexSummary
 207                            : CommandObjectTypeSummaryAdd::eRegularSummary),
 208                       options->m_category, &error);
 209                   if (error.Fail()) {
 210                     error_sp->Printf("error: %s", error.AsCString());
 211                     error_sp->Flush();
 212                   }
 213                 }
 214
 215                 if (options->m_name) {
 216                   CommandObjectTypeSummaryAdd::AddSummary(
 217                       options->m_name, script_format,
 218                       CommandObjectTypeSummaryAdd::eNamedSummary,
 219                       options->m_category, &error);
 220                   if (error.Fail()) {
 221                     CommandObjectTypeSummaryAdd::AddSummary(
 222                         options->m_name, script_format,
 223                         CommandObjectTypeSummaryAdd::eNamedSummary,
 224                         options->m_category, &error);
 225                     if (error.Fail()) {
 226                       error_sp->Printf("error: %s", error.AsCString());
 227                       error_sp->Flush();
 228                     }
 229                   } else {
 230                     error_sp->Printf("error: %s", error.AsCString());
 231                     error_sp->Flush();
 232                   }
 233                 } else {
 234                   if (error.AsCString()) {
 235                     error_sp->Printf("error: %s", error.AsCString());
 236                     error_sp->Flush();
 237                   }
 238                 }
 239               }
 240             } else {
 241               error_sp->Printf("error: unable to generate a function.\n");
 242               error_sp->Flush();
 243             }
 244           } else {
 245             error_sp->Printf("error: no script interpreter.\n");
 246             error_sp->Flush();
 247           }
 248         } else {
 249           error_sp->Printf("error: internal synchronization information "
 250                            "missing or invalid.\n");
 251           error_sp->Flush();
 252         }
 253       } else {
 254         error_sp->Printf("error: empty function, didn't add python command.\n");
 255         error_sp->Flush();
 256       }
 257     } else {
 258       error_sp->Printf(
 259           "error: script interpreter missing, didn't add python command.\n");
 260       error_sp->Flush();
 261     }
 262 #endif // LLDB_DISABLE_PYTHON
 263     io_handler.SetIsDone(true);
 264   }
 265
 266   static bool AddSummary(ConstString type_name, lldb::TypeSummaryImplSP entry,
 267                          SummaryFormatType type, std::string category,
 268                          Status *error = nullptr);
 269
 270 protected:
 271   bool DoExecute(Args &command, CommandReturnObject &result) override;
 272 };
 273
 274 static const char *g_synth_addreader_instructions =
 275     "Enter your Python command(s). Type 'DONE' to end.\n"
 276     "You must define a Python class with these methods:\n"
 277     "    def __init__(self, valobj, dict):\n"
 278     "    def num_children(self):\n"
 279     "    def get_child_at_index(self, index):\n"
 280     "    def get_child_index(self, name):\n"
 281     "    def update(self):\n"
 282     "        '''Optional'''\n"
 283     "class synthProvider:\n";
 284
 285 static constexpr OptionDefinition g_type_synth_add_options[] = {
 286 #define LLDB_OPTIONS_type_synth_add
 287 #include "CommandOptions.inc"
 288 };
 289
 290 class CommandObjectTypeSynthAdd : public CommandObjectParsed,
 291                                   public IOHandlerDelegateMultiline {
 292 private:
 293   class CommandOptions : public Options {
 294   public:
 295     CommandOptions() : Options() {}
 296
 297     ~CommandOptions() override = default;
 298
 299     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
 300                           ExecutionContext *execution_context) override {
 301       Status error;
 302       const int short_option = m_getopt_table[option_idx].val;
 303       bool success;
 304
 305       switch (short_option) {
 306       case 'C':
 307         m_cascade = OptionArgParser::ToBoolean(option_arg, true, &success);
 308         if (!success)
 309           error.SetErrorStringWithFormat("invalid value for cascade: %s",
 310                                          option_arg.str().c_str());
 311         break;
 312       case 'P':
 313         handwrite_python = true;
 314         break;
 315       case 'l':
 316         m_class_name = std::string(option_arg);
 317         is_class_based = true;
 318         break;
 319       case 'p':
 320         m_skip_pointers = true;
 321         break;
 322       case 'r':
 323         m_skip_references = true;
 324         break;
 325       case 'w':
 326         m_category = std::string(option_arg);
 327         break;
 328       case 'x':
 329         m_regex = true;
 330         break;
 331       default:
 332         error.SetErrorStringWithFormat("unrecognized option '%c'",
 333                                        short_option);
 334         break;
 335       }
 336
 337       return error;
 338     }
 339
 340     void OptionParsingStarting(ExecutionContext *execution_context) override {
 341       m_cascade = true;
 342       m_class_name = "";
 343       m_skip_pointers = false;
 344       m_skip_references = false;
 345       m_category = "default";
 346       is_class_based = false;
 347       handwrite_python = false;
 348       m_regex = false;
 349     }
 350
 351     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
 352       return llvm::makeArrayRef(g_type_synth_add_options);
 353     }
 354
 355     // Instance variables to hold the values for command options.
 356
 357     bool m_cascade;
 358     bool m_skip_references;
 359     bool m_skip_pointers;
 360     std::string m_class_name;
 361     bool m_input_python;
 362     std::string m_category;
 363     bool is_class_based;
 364     bool handwrite_python;
 365     bool m_regex;
 366   };
 367
 368   CommandOptions m_options;
 369
 370   Options *GetOptions() override { return &m_options; }
 371
 372   bool Execute_HandwritePython(Args &command, CommandReturnObject &result);
 373
 374   bool Execute_PythonClass(Args &command, CommandReturnObject &result);
 375
 376 protected:
 377   bool DoExecute(Args &command, CommandReturnObject &result) override {
 378     WarnOnPotentialUnquotedUnsignedType(command, result);
 379
 380     if (m_options.handwrite_python)
 381       return Execute_HandwritePython(command, result);
 382     else if (m_options.is_class_based)
 383       return Execute_PythonClass(command, result);
 384     else {
 385       result.AppendError("must either provide a children list, a Python class "
 386                          "name, or use -P and type a Python class "
 387                          "line-by-line");
 388       result.SetStatus(eReturnStatusFailed);
 389       return false;
 390     }
 391   }
 392
 393   void IOHandlerActivated(IOHandler &io_handler, bool interactive) override {
 394     StreamFileSP output_sp(io_handler.GetOutputStreamFile());
 395     if (output_sp && interactive) {
 396       output_sp->PutCString(g_synth_addreader_instructions);
 397       output_sp->Flush();
 398     }
 399   }
 400
 401   void IOHandlerInputComplete(IOHandler &io_handler,
 402                               std::string &data) override {
 403     StreamFileSP error_sp = io_handler.GetErrorStreamFile();
 404
 405 #ifndef LLDB_DISABLE_PYTHON
 406     ScriptInterpreter *interpreter = GetDebugger().GetScriptInterpreter();
 407     if (interpreter) {
 408       StringList lines;
 409       lines.SplitIntoLines(data);
 410       if (lines.GetSize() > 0) {
 411         SynthAddOptions *options_ptr =
 412             ((SynthAddOptions *)io_handler.GetUserData());
 413         if (options_ptr) {
 414           SynthAddOptions::SharedPointer options(
 415               options_ptr); // this will ensure that we get rid of the pointer
 416                             // when going out of scope
 417
 418           ScriptInterpreter *interpreter = GetDebugger().GetScriptInterpreter();
 419           if (interpreter) {
 420             std::string class_name_str;
 421             if (interpreter->GenerateTypeSynthClass(lines, class_name_str)) {
 422               if (class_name_str.empty()) {
 423                 error_sp->Printf(
 424                     "error: unable to obtain a proper name for the class.\n");
 425                 error_sp->Flush();
 426               } else {
 427                 // everything should be fine now, let's add the synth provider
 428                 // class
 429
 430                 SyntheticChildrenSP synth_provider;
 431                 synth_provider = std::make_shared<ScriptedSyntheticChildren>(
 432                     SyntheticChildren::Flags()
 433                         .SetCascades(options->m_cascade)
 434                         .SetSkipPointers(options->m_skip_pointers)
 435                         .SetSkipReferences(options->m_skip_references),
 436                     class_name_str.c_str());
 437
 438                 lldb::TypeCategoryImplSP category;
 439                 DataVisualization::Categories::GetCategory(
 440                     ConstString(options->m_category.c_str()), category);
 441
 442                 Status error;
 443
 444                 for (size_t i = 0; i < options->m_target_types.GetSize(); i++) {
 445                   const char *type_name =
 446                       options->m_target_types.GetStringAtIndex(i);
 447                   ConstString const_type_name(type_name);
 448                   if (const_type_name) {
 449                     if (!CommandObjectTypeSynthAdd::AddSynth(
 450                             const_type_name, synth_provider,
 451                             options->m_regex
 452                                 ? CommandObjectTypeSynthAdd::eRegexSynth
 453                                 : CommandObjectTypeSynthAdd::eRegularSynth,
 454                             options->m_category, &error)) {
 455                       error_sp->Printf("error: %s\n", error.AsCString());
 456                       error_sp->Flush();
 457                       break;
 458                     }
 459                   } else {
 460                     error_sp->Printf("error: invalid type name.\n");
 461                     error_sp->Flush();
 462                     break;
 463                   }
 464                 }
 465               }
 466             } else {
 467               error_sp->Printf("error: unable to generate a class.\n");
 468               error_sp->Flush();
 469             }
 470           } else {
 471             error_sp->Printf("error: no script interpreter.\n");
 472             error_sp->Flush();
 473           }
 474         } else {
 475           error_sp->Printf("error: internal synchronization data missing.\n");
 476           error_sp->Flush();
 477         }
 478       } else {
 479         error_sp->Printf("error: empty function, didn't add python command.\n");
 480         error_sp->Flush();
 481       }
 482     } else {
 483       error_sp->Printf(
 484           "error: script interpreter missing, didn't add python command.\n");
 485       error_sp->Flush();
 486     }
 487
 488 #endif // LLDB_DISABLE_PYTHON
 489     io_handler.SetIsDone(true);
 490   }
 491
 492 public:
 493   enum SynthFormatType { eRegularSynth, eRegexSynth };
 494
 495   CommandObjectTypeSynthAdd(CommandInterpreter &interpreter);
 496
 497   ~CommandObjectTypeSynthAdd() override = default;
 498
 499   static bool AddSynth(ConstString type_name, lldb::SyntheticChildrenSP entry,
 500                        SynthFormatType type, std::string category_name,
 501                        Status *error);
 502 };
 503
 504 // CommandObjectTypeFormatAdd
 505
 506 static constexpr OptionDefinition g_type_format_add_options[] = {
 507 #define LLDB_OPTIONS_type_format_add
 508 #include "CommandOptions.inc"
 509 };
 510
 511 class CommandObjectTypeFormatAdd : public CommandObjectParsed {
 512 private:
 513   class CommandOptions : public OptionGroup {
 514   public:
 515     CommandOptions() : OptionGroup() {}
 516
 517     ~CommandOptions() override = default;
 518
 519     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
 520       return llvm::makeArrayRef(g_type_format_add_options);
 521     }
 522
 523     void OptionParsingStarting(ExecutionContext *execution_context) override {
 524       m_cascade = true;
 525       m_skip_pointers = false;
 526       m_skip_references = false;
 527       m_regex = false;
 528       m_category.assign("default");
 529       m_custom_type_name.clear();
 530     }
 531
 532     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
 533                           ExecutionContext *execution_context) override {
 534       Status error;
 535       const int short_option =
 536           g_type_format_add_options[option_idx].short_option;
 537       bool success;
 538
 539       switch (short_option) {
 540       case 'C':
 541         m_cascade = OptionArgParser::ToBoolean(option_value, true, &success);
 542         if (!success)
 543           error.SetErrorStringWithFormat("invalid value for cascade: %s",
 544                                          option_value.str().c_str());
 545         break;
 546       case 'p':
 547         m_skip_pointers = true;
 548         break;
 549       case 'w':
 550         m_category.assign(option_value);
 551         break;
 552       case 'r':
 553         m_skip_references = true;
 554         break;
 555       case 'x':
 556         m_regex = true;
 557         break;
 558       case 't':
 559         m_custom_type_name.assign(option_value);
 560         break;
 561       default:
 562         error.SetErrorStringWithFormat("unrecognized option '%c'",
 563                                        short_option);
 564         break;
 565       }
 566
 567       return error;
 568     }
 569
 570     // Instance variables to hold the values for command options.
 571
 572     bool m_cascade;
 573     bool m_skip_references;
 574     bool m_skip_pointers;
 575     bool m_regex;
 576     std::string m_category;
 577     std::string m_custom_type_name;
 578   };
 579
 580   OptionGroupOptions m_option_group;
 581   OptionGroupFormat m_format_options;
 582   CommandOptions m_command_options;
 583
 584   Options *GetOptions() override { return &m_option_group; }
 585
 586 public:
 587   CommandObjectTypeFormatAdd(CommandInterpreter &interpreter)
 588       : CommandObjectParsed(interpreter, "type format add",
 589                             "Add a new formatting style for a type.", nullptr),
 590         m_option_group(), m_format_options(eFormatInvalid),
 591         m_command_options() {
 592     CommandArgumentEntry type_arg;
 593     CommandArgumentData type_style_arg;
 594
 595     type_style_arg.arg_type = eArgTypeName;
 596     type_style_arg.arg_repetition = eArgRepeatPlus;
 597
 598     type_arg.push_back(type_style_arg);
 599
 600     m_arguments.push_back(type_arg);
 601
 602     SetHelpLong(
 603         R"(
 604 The following examples of 'type format add' refer to this code snippet for context:
 605
 606     typedef int Aint;
 607     typedef float Afloat;
 608     typedef Aint Bint;
 609     typedef Afloat Bfloat;
 610
 611     Aint ix = 5;
 612     Bint iy = 5;
 613
 614     Afloat fx = 3.14;
 615     BFloat fy = 3.14;
 616
 617 Adding default formatting:
 618
 619 (lldb) type format add -f hex AInt
 620 (lldb) frame variable iy
 621
 622 )"
 623         "    Produces hexadecimal display of iy, because no formatter is available for Bint and \
 624 the one for Aint is used instead."
 625         R"(
 626
 627 To prevent this use the cascade option '-C no' to prevent evaluation of typedef chains:
 628
 629
 630 (lldb) type format add -f hex -C no AInt
 631
 632 Similar reasoning applies to this:
 633
 634 (lldb) type format add -f hex -C no float -p
 635
 636 )"
 637         "    All float values and float references are now formatted as hexadecimal, but not \
 638 pointers to floats.  Nor will it change the default display for Afloat and Bfloat objects.");
 639
 640     // Add the "--format" to all options groups
 641     m_option_group.Append(&m_format_options,
 642                           OptionGroupFormat::OPTION_GROUP_FORMAT,
 643                           LLDB_OPT_SET_1);
 644     m_option_group.Append(&m_command_options);
 645     m_option_group.Finalize();
 646   }
 647
 648   ~CommandObjectTypeFormatAdd() override = default;
 649
 650 protected:
 651   bool DoExecute(Args &command, CommandReturnObject &result) override {
 652     const size_t argc = command.GetArgumentCount();
 653
 654     if (argc < 1) {
 655       result.AppendErrorWithFormat("%s takes one or more args.\n",
 656                                    m_cmd_name.c_str());
 657       result.SetStatus(eReturnStatusFailed);
 658       return false;
 659     }
 660
 661     const Format format = m_format_options.GetFormat();
 662     if (format == eFormatInvalid &&
 663         m_command_options.m_custom_type_name.empty()) {
 664       result.AppendErrorWithFormat("%s needs a valid format.\n",
 665                                    m_cmd_name.c_str());
 666       result.SetStatus(eReturnStatusFailed);
 667       return false;
 668     }
 669
 670     TypeFormatImplSP entry;
 671
 672     if (m_command_options.m_custom_type_name.empty())
 673       entry = std::make_shared<TypeFormatImpl_Format>(
 674           format, TypeFormatImpl::Flags()
 675                       .SetCascades(m_command_options.m_cascade)
 676                       .SetSkipPointers(m_command_options.m_skip_pointers)
 677                       .SetSkipReferences(m_command_options.m_skip_references));
 678     else
 679       entry = std::make_shared<TypeFormatImpl_EnumType>(
 680           ConstString(m_command_options.m_custom_type_name.c_str()),
 681           TypeFormatImpl::Flags()
 682               .SetCascades(m_command_options.m_cascade)
 683               .SetSkipPointers(m_command_options.m_skip_pointers)
 684               .SetSkipReferences(m_command_options.m_skip_references));
 685
 686     // now I have a valid format, let's add it to every type
 687
 688     TypeCategoryImplSP category_sp;
 689     DataVisualization::Categories::GetCategory(
 690         ConstString(m_command_options.m_category), category_sp);
 691     if (!category_sp)
 692       return false;
 693
 694     WarnOnPotentialUnquotedUnsignedType(command, result);
 695
 696     for (auto &arg_entry : command.entries()) {
 697       if (arg_entry.ref.empty()) {
 698         result.AppendError("empty typenames not allowed");
 699         result.SetStatus(eReturnStatusFailed);
 700         return false;
 701       }
 702
 703       ConstString typeCS(arg_entry.ref);
 704       if (m_command_options.m_regex) {
 705         RegularExpressionSP typeRX(new RegularExpression());
 706         if (!typeRX->Compile(arg_entry.ref)) {
 707           result.AppendError(
 708               "regex format error (maybe this is not really a regex?)");
 709           result.SetStatus(eReturnStatusFailed);
 710           return false;
 711         }
 712         category_sp->GetRegexTypeSummariesContainer()->Delete(typeCS);
 713         category_sp->GetRegexTypeFormatsContainer()->Add(typeRX, entry);
 714       } else
 715         category_sp->GetTypeFormatsContainer()->Add(typeCS, entry);
 716     }
 717
 718     result.SetStatus(eReturnStatusSuccessFinishNoResult);
 719     return result.Succeeded();
 720   }
 721 };
 722
 723 static constexpr OptionDefinition g_type_formatter_delete_options[] = {
 724 #define LLDB_OPTIONS_type_formatter_delete
 725 #include "CommandOptions.inc"
 726 };
 727
 728 class CommandObjectTypeFormatterDelete : public CommandObjectParsed {
 729 protected:
 730   class CommandOptions : public Options {
 731   public:
 732     CommandOptions() : Options() {}
 733
 734     ~CommandOptions() override = default;
 735
 736     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
 737                           ExecutionContext *execution_context) override {
 738       Status error;
 739       const int short_option = m_getopt_table[option_idx].val;
 740
 741       switch (short_option) {
 742       case 'a':
 743         m_delete_all = true;
 744         break;
 745       case 'w':
 746         m_category = std::string(option_arg);
 747         break;
 748       case 'l':
 749         m_language = Language::GetLanguageTypeFromString(option_arg);
 750         break;
 751       default:
 752         error.SetErrorStringWithFormat("unrecognized option '%c'",
 753                                        short_option);
 754         break;
 755       }
 756
 757       return error;
 758     }
 759
 760     void OptionParsingStarting(ExecutionContext *execution_context) override {
 761       m_delete_all = false;
 762       m_category = "default";
 763       m_language = lldb::eLanguageTypeUnknown;
 764     }
 765
 766     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
 767       return llvm::makeArrayRef(g_type_formatter_delete_options);
 768     }
 769
 770     // Instance variables to hold the values for command options.
 771
 772     bool m_delete_all;
 773     std::string m_category;
 774     lldb::LanguageType m_language;
 775   };
 776
 777   CommandOptions m_options;
 778   uint32_t m_formatter_kind_mask;
 779
 780   Options *GetOptions() override { return &m_options; }
 781
 782 public:
 783   CommandObjectTypeFormatterDelete(CommandInterpreter &interpreter,
 784                                    uint32_t formatter_kind_mask,
 785                                    const char *name, const char *help)
 786       : CommandObjectParsed(interpreter, name, help, nullptr), m_options(),
 787         m_formatter_kind_mask(formatter_kind_mask) {
 788     CommandArgumentEntry type_arg;
 789     CommandArgumentData type_style_arg;
 790
 791     type_style_arg.arg_type = eArgTypeName;
 792     type_style_arg.arg_repetition = eArgRepeatPlain;
 793
 794     type_arg.push_back(type_style_arg);
 795
 796     m_arguments.push_back(type_arg);
 797   }
 798
 799   ~CommandObjectTypeFormatterDelete() override = default;
 800
 801 protected:
 802   virtual bool FormatterSpecificDeletion(ConstString typeCS) { return false; }
 803
 804   bool DoExecute(Args &command, CommandReturnObject &result) override {
 805     const size_t argc = command.GetArgumentCount();
 806
 807     if (argc != 1) {
 808       result.AppendErrorWithFormat("%s takes 1 arg.\n", m_cmd_name.c_str());
 809       result.SetStatus(eReturnStatusFailed);
 810       return false;
 811     }
 812
 813     const char *typeA = command.GetArgumentAtIndex(0);
 814     ConstString typeCS(typeA);
 815
 816     if (!typeCS) {
 817       result.AppendError("empty typenames not allowed");
 818       result.SetStatus(eReturnStatusFailed);
 819       return false;
 820     }
 821
 822     if (m_options.m_delete_all) {
 823       DataVisualization::Categories::ForEach(
 824           [this, typeCS](const lldb::TypeCategoryImplSP &category_sp) -> bool {
 825             category_sp->Delete(typeCS, m_formatter_kind_mask);
 826             return true;
 827           });
 828       result.SetStatus(eReturnStatusSuccessFinishNoResult);
 829       return result.Succeeded();
 830     }
 831
 832     bool delete_category = false;
 833     bool extra_deletion = false;
 834
 835     if (m_options.m_language != lldb::eLanguageTypeUnknown) {
 836       lldb::TypeCategoryImplSP category;
 837       DataVisualization::Categories::GetCategory(m_options.m_language,
 838                                                  category);
 839       if (category)
 840         delete_category = category->Delete(typeCS, m_formatter_kind_mask);
 841       extra_deletion = FormatterSpecificDeletion(typeCS);
 842     } else {
 843       lldb::TypeCategoryImplSP category;
 844       DataVisualization::Categories::GetCategory(
 845           ConstString(m_options.m_category.c_str()), category);
 846       if (category)
 847         delete_category = category->Delete(typeCS, m_formatter_kind_mask);
 848       extra_deletion = FormatterSpecificDeletion(typeCS);
 849     }
 850
 851     if (delete_category || extra_deletion) {
 852       result.SetStatus(eReturnStatusSuccessFinishNoResult);
 853       return result.Succeeded();
 854     } else {
 855       result.AppendErrorWithFormat("no custom formatter for %s.\n", typeA);
 856       result.SetStatus(eReturnStatusFailed);
 857       return false;
 858     }
 859   }
 860 };
 861
 862 static constexpr OptionDefinition g_type_formatter_clear_options[] = {
 863 #define LLDB_OPTIONS_type_formatter_clear
 864 #include "CommandOptions.inc"
 865 };
 866
 867 class CommandObjectTypeFormatterClear : public CommandObjectParsed {
 868 private:
 869   class CommandOptions : public Options {
 870   public:
 871     CommandOptions() : Options() {}
 872
 873     ~CommandOptions() override = default;
 874
 875     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
 876                           ExecutionContext *execution_context) override {
 877       Status error;
 878       const int short_option = m_getopt_table[option_idx].val;
 879
 880       switch (short_option) {
 881       case 'a':
 882         m_delete_all = true;
 883         break;
 884       default:
 885         error.SetErrorStringWithFormat("unrecognized option '%c'",
 886                                        short_option);
 887         break;
 888       }
 889
 890       return error;
 891     }
 892
 893     void OptionParsingStarting(ExecutionContext *execution_context) override {
 894       m_delete_all = false;
 895     }
 896
 897     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
 898       return llvm::makeArrayRef(g_type_formatter_clear_options);
 899     }
 900
 901     // Instance variables to hold the values for command options.
 902     bool m_delete_all;
 903   };
 904
 905   CommandOptions m_options;
 906   uint32_t m_formatter_kind_mask;
 907
 908   Options *GetOptions() override { return &m_options; }
 909
 910 public:
 911   CommandObjectTypeFormatterClear(CommandInterpreter &interpreter,
 912                                   uint32_t formatter_kind_mask,
 913                                   const char *name, const char *help)
 914       : CommandObjectParsed(interpreter, name, help, nullptr), m_options(),
 915         m_formatter_kind_mask(formatter_kind_mask) {}
 916
 917   ~CommandObjectTypeFormatterClear() override = default;
 918
 919 protected:
 920   virtual void FormatterSpecificDeletion() {}
 921
 922   bool DoExecute(Args &command, CommandReturnObject &result) override {
 923     if (m_options.m_delete_all) {
 924       DataVisualization::Categories::ForEach(
 925           [this](const TypeCategoryImplSP &category_sp) -> bool {
 926             category_sp->Clear(m_formatter_kind_mask);
 927             return true;
 928           });
 929     } else {
 930       lldb::TypeCategoryImplSP category;
 931       if (command.GetArgumentCount() > 0) {
 932         const char *cat_name = command.GetArgumentAtIndex(0);
 933         ConstString cat_nameCS(cat_name);
 934         DataVisualization::Categories::GetCategory(cat_nameCS, category);
 935       } else {
 936         DataVisualization::Categories::GetCategory(ConstString(nullptr),
 937                                                    category);
 938       }
 939       category->Clear(m_formatter_kind_mask);
 940     }
 941
 942     FormatterSpecificDeletion();
 943
 944     result.SetStatus(eReturnStatusSuccessFinishResult);
 945     return result.Succeeded();
 946   }
 947 };
 948
 949 // CommandObjectTypeFormatDelete
 950
 951 class CommandObjectTypeFormatDelete : public CommandObjectTypeFormatterDelete {
 952 public:
 953   CommandObjectTypeFormatDelete(CommandInterpreter &interpreter)
 954       : CommandObjectTypeFormatterDelete(
 955             interpreter,
 956             eFormatCategoryItemValue | eFormatCategoryItemRegexValue,
 957             "type format delete",
 958             "Delete an existing formatting style for a type.") {}
 959
 960   ~CommandObjectTypeFormatDelete() override = default;
 961 };
 962
 963 // CommandObjectTypeFormatClear
 964
 965 class CommandObjectTypeFormatClear : public CommandObjectTypeFormatterClear {
 966 public:
 967   CommandObjectTypeFormatClear(CommandInterpreter &interpreter)
 968       : CommandObjectTypeFormatterClear(
 969             interpreter,
 970             eFormatCategoryItemValue | eFormatCategoryItemRegexValue,
 971             "type format clear", "Delete all existing format styles.") {}
 972 };
 973
 974
 975 static constexpr OptionDefinition g_type_formatter_list_options[] = {
 976 #define LLDB_OPTIONS_type_formatter_list
 977 #include "CommandOptions.inc"
 978 };
 979
 980 template <typename FormatterType>
 981 class CommandObjectTypeFormatterList : public CommandObjectParsed {
 982   typedef typename FormatterType::SharedPointer FormatterSharedPointer;
 983
 984   class CommandOptions : public Options {
 985   public:
 986     CommandOptions()
 987         : Options(), m_category_regex("", ""),
 988           m_category_language(lldb::eLanguageTypeUnknown,
 989                               lldb::eLanguageTypeUnknown) {}
 990
 991     ~CommandOptions() override = default;
 992
 993     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
 994                           ExecutionContext *execution_context) override {
 995       Status error;
 996       const int short_option = m_getopt_table[option_idx].val;
 997       switch (short_option) {
 998       case 'w':
 999         m_category_regex.SetCurrentValue(option_arg);
1000         m_category_regex.SetOptionWasSet();
1001         break;
1002       case 'l':
1003         error = m_category_language.SetValueFromString(option_arg);
1004         if (error.Success())
1005           m_category_language.SetOptionWasSet();
1006         break;
1007       default:
1008         error.SetErrorStringWithFormat("unrecognized option '%c'",
1009                                        short_option);
1010         break;
1011       }
1012
1013       return error;
1014     }
1015
1016     void OptionParsingStarting(ExecutionContext *execution_context) override {
1017       m_category_regex.Clear();
1018       m_category_language.Clear();
1019     }
1020
1021     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
1022       return llvm::makeArrayRef(g_type_formatter_list_options);
1023     }
1024
1025     // Instance variables to hold the values for command options.
1026
1027     OptionValueString m_category_regex;
1028     OptionValueLanguage m_category_language;
1029   };
1030
1031   CommandOptions m_options;
1032
1033   Options *GetOptions() override { return &m_options; }
1034
1035 public:
1036   CommandObjectTypeFormatterList(CommandInterpreter &interpreter,
1037                                  const char *name, const char *help)
1038       : CommandObjectParsed(interpreter, name, help, nullptr), m_options() {
1039     CommandArgumentEntry type_arg;
1040     CommandArgumentData type_style_arg;
1041
1042     type_style_arg.arg_type = eArgTypeName;
1043     type_style_arg.arg_repetition = eArgRepeatOptional;
1044
1045     type_arg.push_back(type_style_arg);
1046
1047     m_arguments.push_back(type_arg);
1048   }
1049
1050   ~CommandObjectTypeFormatterList() override = default;
1051
1052 protected:
1053   virtual bool FormatterSpecificList(CommandReturnObject &result) {
1054     return false;
1055   }
1056
1057   bool DoExecute(Args &command, CommandReturnObject &result) override {
1058     const size_t argc = command.GetArgumentCount();
1059
1060     std::unique_ptr<RegularExpression> category_regex;
1061     std::unique_ptr<RegularExpression> formatter_regex;
1062
1063     if (m_options.m_category_regex.OptionWasSet()) {
1064       category_regex.reset(new RegularExpression());
1065       if (!category_regex->Compile(
1066               m_options.m_category_regex.GetCurrentValueAsRef())) {
1067         result.AppendErrorWithFormat(
1068             "syntax error in category regular expression '%s'",
1069             m_options.m_category_regex.GetCurrentValueAsRef().str().c_str());
1070         result.SetStatus(eReturnStatusFailed);
1071         return false;
1072       }
1073     }
1074
1075     if (argc == 1) {
1076       const char *arg = command.GetArgumentAtIndex(0);
1077       formatter_regex.reset(new RegularExpression());
1078       if (!formatter_regex->Compile(llvm::StringRef::withNullAsEmpty(arg))) {
1079         result.AppendErrorWithFormat("syntax error in regular expression '%s'",
1080                                      arg);
1081         result.SetStatus(eReturnStatusFailed);
1082         return false;
1083       }
1084     }
1085
1086     bool any_printed = false;
1087
1088     auto category_closure = [&result, &formatter_regex, &any_printed](
1089         const lldb::TypeCategoryImplSP &category) -> void {
1090       result.GetOutputStream().Printf(
1091           "-----------------------\nCategory: %s%s\n-----------------------\n",
1092           category->GetName(), category->IsEnabled() ? "" : " (disabled)");
1093
1094       TypeCategoryImpl::ForEachCallbacks<FormatterType> foreach;
1095       foreach
1096         .SetExact([&result, &formatter_regex, &any_printed](
1097                       ConstString name,
1098                       const FormatterSharedPointer &format_sp) -> bool {
1099           if (formatter_regex) {
1100             bool escape = true;
1101             if (name.GetStringRef() == formatter_regex->GetText()) {
1102               escape = false;
1103             } else if (formatter_regex->Execute(name.GetStringRef())) {
1104               escape = false;
1105             }
1106
1107             if (escape)
1108               return true;
1109           }
1110
1111           any_printed = true;
1112           result.GetOutputStream().Printf("%s: %s\n", name.AsCString(),
1113                                           format_sp->GetDescription().c_str());
1114           return true;
1115         });
1116
1117       foreach
1118         .SetWithRegex([&result, &formatter_regex, &any_printed](
1119                           RegularExpressionSP regex_sp,
1120                           const FormatterSharedPointer &format_sp) -> bool {
1121           if (formatter_regex) {
1122             bool escape = true;
1123             if (regex_sp->GetText() == formatter_regex->GetText()) {
1124               escape = false;
1125             } else if (formatter_regex->Execute(regex_sp->GetText())) {
1126               escape = false;
1127             }
1128
1129             if (escape)
1130               return true;
1131           }
1132
1133           any_printed = true;
1134           result.GetOutputStream().Printf("%s: %s\n",
1135                                           regex_sp->GetText().str().c_str(),
1136                                           format_sp->GetDescription().c_str());
1137           return true;
1138         });
1139
1140       category->ForEach(foreach);
1141     };
1142
1143     if (m_options.m_category_language.OptionWasSet()) {
1144       lldb::TypeCategoryImplSP category_sp;
1145       DataVisualization::Categories::GetCategory(
1146           m_options.m_category_language.GetCurrentValue(), category_sp);
1147       if (category_sp)
1148         category_closure(category_sp);
1149     } else {
1150       DataVisualization::Categories::ForEach(
1151           [&category_regex, &category_closure](
1152               const lldb::TypeCategoryImplSP &category) -> bool {
1153             if (category_regex) {
1154               bool escape = true;
1155               if (category->GetName() == category_regex->GetText()) {
1156                 escape = false;
1157               } else if (category_regex->Execute(
1158                              llvm::StringRef::withNullAsEmpty(
1159                                  category->GetName()))) {
1160                 escape = false;
1161               }
1162
1163               if (escape)
1164                 return true;
1165             }
1166
1167             category_closure(category);
1168
1169             return true;
1170           });
1171
1172       any_printed = FormatterSpecificList(result) | any_printed;
1173     }
1174
1175     if (any_printed)
1176       result.SetStatus(eReturnStatusSuccessFinishResult);
1177     else {
1178       result.GetOutputStream().PutCString("no matching results found.\n");
1179       result.SetStatus(eReturnStatusSuccessFinishNoResult);
1180     }
1181     return result.Succeeded();
1182   }
1183 };
1184
1185 // CommandObjectTypeFormatList
1186
1187 class CommandObjectTypeFormatList
1188     : public CommandObjectTypeFormatterList<TypeFormatImpl> {
1189 public:
1190   CommandObjectTypeFormatList(CommandInterpreter &interpreter)
1191       : CommandObjectTypeFormatterList(interpreter, "type format list",
1192                                        "Show a list of current formats.") {}
1193 };
1194
1195 #ifndef LLDB_DISABLE_PYTHON
1196
1197 // CommandObjectTypeSummaryAdd
1198
1199 #endif // LLDB_DISABLE_PYTHON
1200
1201 Status CommandObjectTypeSummaryAdd::CommandOptions::SetOptionValue(
1202     uint32_t option_idx, llvm::StringRef option_arg,
1203     ExecutionContext *execution_context) {
1204   Status error;
1205   const int short_option = m_getopt_table[option_idx].val;
1206   bool success;
1207
1208   switch (short_option) {
1209   case 'C':
1210     m_flags.SetCascades(OptionArgParser::ToBoolean(option_arg, true, &success));
1211     if (!success)
1212       error.SetErrorStringWithFormat("invalid value for cascade: %s",
1213                                      option_arg.str().c_str());
1214     break;
1215   case 'e':
1216     m_flags.SetDontShowChildren(false);
1217     break;
1218   case 'h':
1219     m_flags.SetHideEmptyAggregates(true);
1220     break;
1221   case 'v':
1222     m_flags.SetDontShowValue(true);
1223     break;
1224   case 'c':
1225     m_flags.SetShowMembersOneLiner(true);
1226     break;
1227   case 's':
1228     m_format_string = std::string(option_arg);
1229     break;
1230   case 'p':
1231     m_flags.SetSkipPointers(true);
1232     break;
1233   case 'r':
1234     m_flags.SetSkipReferences(true);
1235     break;
1236   case 'x':
1237     m_regex = true;
1238     break;
1239   case 'n':
1240     m_name.SetString(option_arg);
1241     break;
1242   case 'o':
1243     m_python_script = option_arg;
1244     m_is_add_script = true;
1245     break;
1246   case 'F':
1247     m_python_function = option_arg;
1248     m_is_add_script = true;
1249     break;
1250   case 'P':
1251     m_is_add_script = true;
1252     break;
1253   case 'w':
1254     m_category = std::string(option_arg);
1255     break;
1256   case 'O':
1257     m_flags.SetHideItemNames(true);
1258     break;
1259   default:
1260     error.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
1261     break;
1262   }
1263
1264   return error;
1265 }
1266
1267 void CommandObjectTypeSummaryAdd::CommandOptions::OptionParsingStarting(
1268     ExecutionContext *execution_context) {
1269   m_flags.Clear().SetCascades().SetDontShowChildren().SetDontShowValue(false);
1270   m_flags.SetShowMembersOneLiner(false)
1271       .SetSkipPointers(false)
1272       .SetSkipReferences(false)
1273       .SetHideItemNames(false);
1274
1275   m_regex = false;
1276   m_name.Clear();
1277   m_python_script = "";
1278   m_python_function = "";
1279   m_format_string = "";
1280   m_is_add_script = false;
1281   m_category = "default";
1282 }
1283
1284 #ifndef LLDB_DISABLE_PYTHON
1285
1286 bool CommandObjectTypeSummaryAdd::Execute_ScriptSummary(
1287     Args &command, CommandReturnObject &result) {
1288   const size_t argc = command.GetArgumentCount();
1289
1290   if (argc < 1 && !m_options.m_name) {
1291     result.AppendErrorWithFormat("%s takes one or more args.\n",
1292                                  m_cmd_name.c_str());
1293     result.SetStatus(eReturnStatusFailed);
1294     return false;
1295   }
1296
1297   TypeSummaryImplSP script_format;
1298
1299   if (!m_options.m_python_function
1300            .empty()) // we have a Python function ready to use
1301   {
1302     const char *funct_name = m_options.m_python_function.c_str();
1303     if (!funct_name || !funct_name[0]) {
1304       result.AppendError("function name empty.\n");
1305       result.SetStatus(eReturnStatusFailed);
1306       return false;
1307     }
1308
1309     std::string code =
1310         ("    " + m_options.m_python_function + "(valobj,internal_dict)");
1311
1312     script_format = std::make_shared<ScriptSummaryFormat>(
1313         m_options.m_flags, funct_name, code.c_str());
1314
1315     ScriptInterpreter *interpreter = GetDebugger().GetScriptInterpreter();
1316
1317     if (interpreter && !interpreter->CheckObjectExists(funct_name))
1318       result.AppendWarningWithFormat(
1319           "The provided function \"%s\" does not exist - "
1320           "please define it before attempting to use this summary.\n",
1321           funct_name);
1322   } else if (!m_options.m_python_script
1323                   .empty()) // we have a quick 1-line script, just use it
1324   {
1325     ScriptInterpreter *interpreter = GetDebugger().GetScriptInterpreter();
1326     if (!interpreter) {
1327       result.AppendError("script interpreter missing - unable to generate "
1328                          "function wrapper.\n");
1329       result.SetStatus(eReturnStatusFailed);
1330       return false;
1331     }
1332     StringList funct_sl;
1333     funct_sl << m_options.m_python_script.c_str();
1334     std::string funct_name_str;
1335     if (!interpreter->GenerateTypeScriptFunction(funct_sl, funct_name_str)) {
1336       result.AppendError("unable to generate function wrapper.\n");
1337       result.SetStatus(eReturnStatusFailed);
1338       return false;
1339     }
1340     if (funct_name_str.empty()) {
1341       result.AppendError(
1342           "script interpreter failed to generate a valid function name.\n");
1343       result.SetStatus(eReturnStatusFailed);
1344       return false;
1345     }
1346
1347     std::string code = "    " + m_options.m_python_script;
1348
1349     script_format = std::make_shared<ScriptSummaryFormat>(
1350         m_options.m_flags, funct_name_str.c_str(), code.c_str());
1351   } else {
1352     // Use an IOHandler to grab Python code from the user
1353     ScriptAddOptions *options =
1354         new ScriptAddOptions(m_options.m_flags, m_options.m_regex,
1355                              m_options.m_name, m_options.m_category);
1356
1357     for (auto &entry : command.entries()) {
1358       if (entry.ref.empty()) {
1359         result.AppendError("empty typenames not allowed");
1360         result.SetStatus(eReturnStatusFailed);
1361         return false;
1362       }
1363
1364       options->m_target_types << entry.ref;
1365     }
1366
1367     m_interpreter.GetPythonCommandsFromIOHandler(
1368         "    ",   // Prompt
1369         *this,    // IOHandlerDelegate
1370         true,     // Run IOHandler in async mode
1371         options); // Baton for the "io_handler" that will be passed back into
1372                   // our IOHandlerDelegate functions
1373     result.SetStatus(eReturnStatusSuccessFinishNoResult);
1374
1375     return result.Succeeded();
1376   }
1377
1378   // if I am here, script_format must point to something good, so I can add
1379   // that as a script summary to all interested parties
1380
1381   Status error;
1382
1383   for (auto &entry : command.entries()) {
1384     CommandObjectTypeSummaryAdd::AddSummary(
1385         ConstString(entry.ref), script_format,
1386         (m_options.m_regex ? eRegexSummary : eRegularSummary),
1387         m_options.m_category, &error);
1388     if (error.Fail()) {
1389       result.AppendError(error.AsCString());
1390       result.SetStatus(eReturnStatusFailed);
1391       return false;
1392     }
1393   }
1394
1395   if (m_options.m_name) {
1396     AddSummary(m_options.m_name, script_format, eNamedSummary,
1397                m_options.m_category, &error);
1398     if (error.Fail()) {
1399       result.AppendError(error.AsCString());
1400       result.AppendError("added to types, but not given a name");
1401       result.SetStatus(eReturnStatusFailed);
1402       return false;
1403     }
1404   }
1405
1406   return result.Succeeded();
1407 }
1408
1409 #endif // LLDB_DISABLE_PYTHON
1410
1411 bool CommandObjectTypeSummaryAdd::Execute_StringSummary(
1412     Args &command, CommandReturnObject &result) {
1413   const size_t argc = command.GetArgumentCount();
1414
1415   if (argc < 1 && !m_options.m_name) {
1416     result.AppendErrorWithFormat("%s takes one or more args.\n",
1417                                  m_cmd_name.c_str());
1418     result.SetStatus(eReturnStatusFailed);
1419     return false;
1420   }
1421
1422   if (!m_options.m_flags.GetShowMembersOneLiner() &&
1423       m_options.m_format_string.empty()) {
1424     result.AppendError("empty summary strings not allowed");
1425     result.SetStatus(eReturnStatusFailed);
1426     return false;
1427   }
1428
1429   const char *format_cstr = (m_options.m_flags.GetShowMembersOneLiner()
1430                                  ? ""
1431                                  : m_options.m_format_string.c_str());
1432
1433   // ${var%S} is an endless recursion, prevent it
1434   if (strcmp(format_cstr, "${var%S}") == 0) {
1435     result.AppendError("recursive summary not allowed");
1436     result.SetStatus(eReturnStatusFailed);
1437     return false;
1438   }
1439
1440   std::unique_ptr<StringSummaryFormat> string_format(
1441       new StringSummaryFormat(m_options.m_flags, format_cstr));
1442   if (!string_format) {
1443     result.AppendError("summary creation failed");
1444     result.SetStatus(eReturnStatusFailed);
1445     return false;
1446   }
1447   if (string_format->m_error.Fail()) {
1448     result.AppendErrorWithFormat("syntax error: %s",
1449                                  string_format->m_error.AsCString("<unknown>"));
1450     result.SetStatus(eReturnStatusFailed);
1451     return false;
1452   }
1453   lldb::TypeSummaryImplSP entry(string_format.release());
1454
1455   // now I have a valid format, let's add it to every type
1456   Status error;
1457   for (auto &arg_entry : command.entries()) {
1458     if (arg_entry.ref.empty()) {
1459       result.AppendError("empty typenames not allowed");
1460       result.SetStatus(eReturnStatusFailed);
1461       return false;
1462     }
1463     ConstString typeCS(arg_entry.ref);
1464
1465     AddSummary(typeCS, entry,
1466                (m_options.m_regex ? eRegexSummary : eRegularSummary),
1467                m_options.m_category, &error);
1468
1469     if (error.Fail()) {
1470       result.AppendError(error.AsCString());
1471       result.SetStatus(eReturnStatusFailed);
1472       return false;
1473     }
1474   }
1475
1476   if (m_options.m_name) {
1477     AddSummary(m_options.m_name, entry, eNamedSummary, m_options.m_category,
1478                &error);
1479     if (error.Fail()) {
1480       result.AppendError(error.AsCString());
1481       result.AppendError("added to types, but not given a name");
1482       result.SetStatus(eReturnStatusFailed);
1483       return false;
1484     }
1485   }
1486
1487   result.SetStatus(eReturnStatusSuccessFinishNoResult);
1488   return result.Succeeded();
1489 }
1490
1491 CommandObjectTypeSummaryAdd::CommandObjectTypeSummaryAdd(
1492     CommandInterpreter &interpreter)
1493     : CommandObjectParsed(interpreter, "type summary add",
1494                           "Add a new summary style for a type.", nullptr),
1495       IOHandlerDelegateMultiline("DONE"), m_options(interpreter) {
1496   CommandArgumentEntry type_arg;
1497   CommandArgumentData type_style_arg;
1498
1499   type_style_arg.arg_type = eArgTypeName;
1500   type_style_arg.arg_repetition = eArgRepeatPlus;
1501
1502   type_arg.push_back(type_style_arg);
1503
1504   m_arguments.push_back(type_arg);
1505
1506   SetHelpLong(
1507       R"(
1508 The following examples of 'type summary add' refer to this code snippet for context:
1509
1510     struct JustADemo
1511     {
1512         int* ptr;
1513         float value;
1514         JustADemo(int p = 1, float v = 0.1) : ptr(new int(p)), value(v) {}
1515     };
1516     JustADemo demo_instance(42, 3.14);
1517
1518     typedef JustADemo NewDemo;
1519     NewDemo new_demo_instance(42, 3.14);
1520
1521 (lldb) type summary add --summary-string "the answer is ${*var.ptr}" JustADemo
1522
1523     Subsequently displaying demo_instance with 'frame variable' or 'expression' will display "the answer is 42"
1524
1525 (lldb) type summary add --summary-string "the answer is ${*var.ptr}, and the question is ${var.value}" JustADemo
1526
1527     Subsequently displaying demo_instance with 'frame variable' or 'expression' will display "the answer is 42 and the question is 3.14"
1528
1529 )"
1530       "Alternatively, you could define formatting for all pointers to integers and \
1531 rely on that when formatting JustADemo to obtain the same result:"
1532       R"(
1533
1534 (lldb) type summary add --summary-string "${var%V} -> ${*var}" "int *"
1535 (lldb) type summary add --summary-string "the answer is ${var.ptr}, and the question is ${var.value}" JustADemo
1536
1537 )"
1538       "Type summaries are automatically applied to derived typedefs, so the examples \
1539 above apply to both JustADemo and NewDemo.  The cascade option can be used to \
1540 suppress this behavior:"
1541       R"(
1542
1543 (lldb) type summary add --summary-string "${var.ptr}, ${var.value},{${var.byte}}" JustADemo -C no
1544
1545     The summary will now be used for values of JustADemo but not NewDemo.
1546
1547 )"
1548       "By default summaries are shown for pointers and references to values of the \
1549 specified type.  To suppress formatting for pointers use the -p option, or apply \
1550 the corresponding -r option to suppress formatting for references:"
1551       R"(
1552
1553 (lldb) type summary add -p -r --summary-string "${var.ptr}, ${var.value},{${var.byte}}" JustADemo
1554
1555 )"
1556       "One-line summaries including all fields in a type can be inferred without supplying an \
1557 explicit summary string by passing the -c option:"
1558       R"(
1559
1560 (lldb) type summary add -c JustADemo
1561 (lldb) frame variable demo_instance
1562 (ptr=<address>, value=3.14)
1563
1564 )"
1565       "Type summaries normally suppress the nested display of individual fields.  To \
1566 supply a summary to supplement the default structure add the -e option:"
1567       R"(
1568
1569 (lldb) type summary add -e --summary-string "*ptr = ${*var.ptr}" JustADemo
1570
1571 )"
1572       "Now when displaying JustADemo values the int* is displayed, followed by the \
1573 standard LLDB sequence of children, one per line:"
1574       R"(
1575
1576 *ptr = 42 {
1577   ptr = <address>
1578   value = 3.14
1579 }
1580
1581 )"
1582       "You can also add summaries written in Python.  These scripts use lldb public API to \
1583 gather information from your variables and produce a meaningful summary.  To start a \
1584 multi-line script use the -P option.  The function declaration will be displayed along with \
1585 a comment describing the two arguments.  End your script with the  word 'DONE' on a line by \
1586 itself:"
1587       R"(
1588
1589 (lldb) type summary add JustADemo -P
1590 def function (valobj,internal_dict):
1591 """valobj: an SBValue which you want to provide a summary for
1592 internal_dict: an LLDB support object not to be used"""
1593     value = valobj.GetChildMemberWithName('value');
1594     return 'My value is ' + value.GetValue();
1595     DONE
1596
1597 Alternatively, the -o option can be used when providing a simple one-line Python script:
1598
1599 (lldb) type summary add JustADemo -o "value = valobj.GetChildMemberWithName('value'); return 'My value is ' + value.GetValue();")");
1600 }
1601
1602 bool CommandObjectTypeSummaryAdd::DoExecute(Args &command,
1603                                             CommandReturnObject &result) {
1604   WarnOnPotentialUnquotedUnsignedType(command, result);
1605
1606   if (m_options.m_is_add_script) {
1607 #ifndef LLDB_DISABLE_PYTHON
1608     return Execute_ScriptSummary(command, result);
1609 #else
1610     result.AppendError("python is disabled");
1611     result.SetStatus(eReturnStatusFailed);
1612     return false;
1613 #endif // LLDB_DISABLE_PYTHON
1614   }
1615
1616   return Execute_StringSummary(command, result);
1617 }
1618
1619 static bool FixArrayTypeNameWithRegex(ConstString &type_name) {
1620   llvm::StringRef type_name_ref(type_name.GetStringRef());
1621
1622   if (type_name_ref.endswith("[]")) {
1623     std::string type_name_str(type_name.GetCString());
1624     type_name_str.resize(type_name_str.length() - 2);
1625     if (type_name_str.back() != ' ')
1626       type_name_str.append(" \\[[0-9]+\\]");
1627     else
1628       type_name_str.append("\\[[0-9]+\\]");
1629     type_name.SetCString(type_name_str.c_str());
1630     return true;
1631   }
1632   return false;
1633 }
1634
1635 bool CommandObjectTypeSummaryAdd::AddSummary(ConstString type_name,
1636                                              TypeSummaryImplSP entry,
1637                                              SummaryFormatType type,
1638                                              std::string category_name,
1639                                              Status *error) {
1640   lldb::TypeCategoryImplSP category;
1641   DataVisualization::Categories::GetCategory(ConstString(category_name.c_str()),
1642                                              category);
1643
1644   if (type == eRegularSummary) {
1645     if (FixArrayTypeNameWithRegex(type_name))
1646       type = eRegexSummary;
1647   }
1648
1649   if (type == eRegexSummary) {
1650     RegularExpressionSP typeRX(new RegularExpression());
1651     if (!typeRX->Compile(type_name.GetStringRef())) {
1652       if (error)
1653         error->SetErrorString(
1654             "regex format error (maybe this is not really a regex?)");
1655       return false;
1656     }
1657
1658     category->GetRegexTypeSummariesContainer()->Delete(type_name);
1659     category->GetRegexTypeSummariesContainer()->Add(typeRX, entry);
1660
1661     return true;
1662   } else if (type == eNamedSummary) {
1663     // system named summaries do not exist (yet?)
1664     DataVisualization::NamedSummaryFormats::Add(type_name, entry);
1665     return true;
1666   } else {
1667     category->GetTypeSummariesContainer()->Add(type_name, entry);
1668     return true;
1669   }
1670 }
1671
1672 // CommandObjectTypeSummaryDelete
1673
1674 class CommandObjectTypeSummaryDelete : public CommandObjectTypeFormatterDelete {
1675 public:
1676   CommandObjectTypeSummaryDelete(CommandInterpreter &interpreter)
1677       : CommandObjectTypeFormatterDelete(
1678             interpreter,
1679             eFormatCategoryItemSummary | eFormatCategoryItemRegexSummary,
1680             "type summary delete", "Delete an existing summary for a type.") {}
1681
1682   ~CommandObjectTypeSummaryDelete() override = default;
1683
1684 protected:
1685   bool FormatterSpecificDeletion(ConstString typeCS) override {
1686     if (m_options.m_language != lldb::eLanguageTypeUnknown)
1687       return false;
1688     return DataVisualization::NamedSummaryFormats::Delete(typeCS);
1689   }
1690 };
1691
1692 class CommandObjectTypeSummaryClear : public CommandObjectTypeFormatterClear {
1693 public:
1694   CommandObjectTypeSummaryClear(CommandInterpreter &interpreter)
1695       : CommandObjectTypeFormatterClear(
1696             interpreter,
1697             eFormatCategoryItemSummary | eFormatCategoryItemRegexSummary,
1698             "type summary clear", "Delete all existing summaries.") {}
1699
1700 protected:
1701   void FormatterSpecificDeletion() override {
1702     DataVisualization::NamedSummaryFormats::Clear();
1703   }
1704 };
1705
1706 // CommandObjectTypeSummaryList
1707
1708 class CommandObjectTypeSummaryList
1709     : public CommandObjectTypeFormatterList<TypeSummaryImpl> {
1710 public:
1711   CommandObjectTypeSummaryList(CommandInterpreter &interpreter)
1712       : CommandObjectTypeFormatterList(interpreter, "type summary list",
1713                                        "Show a list of current summaries.") {}
1714
1715 protected:
1716   bool FormatterSpecificList(CommandReturnObject &result) override {
1717     if (DataVisualization::NamedSummaryFormats::GetCount() > 0) {
1718       result.GetOutputStream().Printf("Named summaries:\n");
1719       DataVisualization::NamedSummaryFormats::ForEach(
1720           [&result](ConstString name,
1721                     const TypeSummaryImplSP &summary_sp) -> bool {
1722             result.GetOutputStream().Printf(
1723                 "%s: %s\n", name.AsCString(),
1724                 summary_sp->GetDescription().c_str());
1725             return true;
1726           });
1727       return true;
1728     }
1729     return false;
1730   }
1731 };
1732
1733 // CommandObjectTypeCategoryDefine
1734
1735 static constexpr OptionDefinition g_type_category_define_options[] = {
1736 #define LLDB_OPTIONS_type_category_define
1737 #include "CommandOptions.inc"
1738 };
1739
1740 class CommandObjectTypeCategoryDefine : public CommandObjectParsed {
1741   class CommandOptions : public Options {
1742   public:
1743     CommandOptions()
1744         : Options(), m_define_enabled(false, false),
1745           m_cate_language(eLanguageTypeUnknown, eLanguageTypeUnknown) {}
1746
1747     ~CommandOptions() override = default;
1748
1749     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
1750                           ExecutionContext *execution_context) override {
1751       Status error;
1752       const int short_option = m_getopt_table[option_idx].val;
1753
1754       switch (short_option) {
1755       case 'e':
1756         m_define_enabled.SetValueFromString(llvm::StringRef("true"));
1757         break;
1758       case 'l':
1759         error = m_cate_language.SetValueFromString(option_arg);
1760         break;
1761       default:
1762         error.SetErrorStringWithFormat("unrecognized option '%c'",
1763                                        short_option);
1764         break;
1765       }
1766
1767       return error;
1768     }
1769
1770     void OptionParsingStarting(ExecutionContext *execution_context) override {
1771       m_define_enabled.Clear();
1772       m_cate_language.Clear();
1773     }
1774
1775     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
1776       return llvm::makeArrayRef(g_type_category_define_options);
1777     }
1778
1779     // Instance variables to hold the values for command options.
1780
1781     OptionValueBoolean m_define_enabled;
1782     OptionValueLanguage m_cate_language;
1783   };
1784
1785   CommandOptions m_options;
1786
1787   Options *GetOptions() override { return &m_options; }
1788
1789 public:
1790   CommandObjectTypeCategoryDefine(CommandInterpreter &interpreter)
1791       : CommandObjectParsed(interpreter, "type category define",
1792                             "Define a new category as a source of formatters.",
1793                             nullptr),
1794         m_options() {
1795     CommandArgumentEntry type_arg;
1796     CommandArgumentData type_style_arg;
1797
1798     type_style_arg.arg_type = eArgTypeName;
1799     type_style_arg.arg_repetition = eArgRepeatPlus;
1800
1801     type_arg.push_back(type_style_arg);
1802
1803     m_arguments.push_back(type_arg);
1804   }
1805
1806   ~CommandObjectTypeCategoryDefine() override = default;
1807
1808 protected:
1809   bool DoExecute(Args &command, CommandReturnObject &result) override {
1810     const size_t argc = command.GetArgumentCount();
1811
1812     if (argc < 1) {
1813       result.AppendErrorWithFormat("%s takes 1 or more args.\n",
1814                                    m_cmd_name.c_str());
1815       result.SetStatus(eReturnStatusFailed);
1816       return false;
1817     }
1818
1819     for (auto &entry : command.entries()) {
1820       TypeCategoryImplSP category_sp;
1821       if (DataVisualization::Categories::GetCategory(ConstString(entry.ref),
1822                                                      category_sp) &&
1823           category_sp) {
1824         category_sp->AddLanguage(m_options.m_cate_language.GetCurrentValue());
1825         if (m_options.m_define_enabled.GetCurrentValue())
1826           DataVisualization::Categories::Enable(category_sp,
1827                                                 TypeCategoryMap::Default);
1828       }
1829     }
1830
1831     result.SetStatus(eReturnStatusSuccessFinishResult);
1832     return result.Succeeded();
1833   }
1834 };
1835
1836 // CommandObjectTypeCategoryEnable
1837
1838 static constexpr OptionDefinition g_type_category_enable_options[] = {
1839 #define LLDB_OPTIONS_type_category_enable
1840 #include "CommandOptions.inc"
1841 };
1842
1843 class CommandObjectTypeCategoryEnable : public CommandObjectParsed {
1844   class CommandOptions : public Options {
1845   public:
1846     CommandOptions() : Options() {}
1847
1848     ~CommandOptions() override = default;
1849
1850     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
1851                           ExecutionContext *execution_context) override {
1852       Status error;
1853       const int short_option = m_getopt_table[option_idx].val;
1854
1855       switch (short_option) {
1856       case 'l':
1857         if (!option_arg.empty()) {
1858           m_language = Language::GetLanguageTypeFromString(option_arg);
1859           if (m_language == lldb::eLanguageTypeUnknown)
1860             error.SetErrorStringWithFormat("unrecognized language '%s'",
1861                                            option_arg.str().c_str());
1862         }
1863         break;
1864       default:
1865         error.SetErrorStringWithFormat("unrecognized option '%c'",
1866                                        short_option);
1867         break;
1868       }
1869
1870       return error;
1871     }
1872
1873     void OptionParsingStarting(ExecutionContext *execution_context) override {
1874       m_language = lldb::eLanguageTypeUnknown;
1875     }
1876
1877     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
1878       return llvm::makeArrayRef(g_type_category_enable_options);
1879     }
1880
1881     // Instance variables to hold the values for command options.
1882
1883     lldb::LanguageType m_language;
1884   };
1885
1886   CommandOptions m_options;
1887
1888   Options *GetOptions() override { return &m_options; }
1889
1890 public:
1891   CommandObjectTypeCategoryEnable(CommandInterpreter &interpreter)
1892       : CommandObjectParsed(interpreter, "type category enable",
1893                             "Enable a category as a source of formatters.",
1894                             nullptr),
1895         m_options() {
1896     CommandArgumentEntry type_arg;
1897     CommandArgumentData type_style_arg;
1898
1899     type_style_arg.arg_type = eArgTypeName;
1900     type_style_arg.arg_repetition = eArgRepeatPlus;
1901
1902     type_arg.push_back(type_style_arg);
1903
1904     m_arguments.push_back(type_arg);
1905   }
1906
1907   ~CommandObjectTypeCategoryEnable() override = default;
1908
1909 protected:
1910   bool DoExecute(Args &command, CommandReturnObject &result) override {
1911     const size_t argc = command.GetArgumentCount();
1912
1913     if (argc < 1 && m_options.m_language == lldb::eLanguageTypeUnknown) {
1914       result.AppendErrorWithFormat("%s takes arguments and/or a language",
1915                                    m_cmd_name.c_str());
1916       result.SetStatus(eReturnStatusFailed);
1917       return false;
1918     }
1919
1920     if (argc == 1 && strcmp(command.GetArgumentAtIndex(0), "*") == 0) {
1921       DataVisualization::Categories::EnableStar();
1922     } else if (argc > 0) {
1923       for (int i = argc - 1; i >= 0; i--) {
1924         const char *typeA = command.GetArgumentAtIndex(i);
1925         ConstString typeCS(typeA);
1926
1927         if (!typeCS) {
1928           result.AppendError("empty category name not allowed");
1929           result.SetStatus(eReturnStatusFailed);
1930           return false;
1931         }
1932         DataVisualization::Categories::Enable(typeCS);
1933         lldb::TypeCategoryImplSP cate;
1934         if (DataVisualization::Categories::GetCategory(typeCS, cate) && cate) {
1935           if (cate->GetCount() == 0) {
1936             result.AppendWarning("empty category enabled (typo?)");
1937           }
1938         }
1939       }
1940     }
1941
1942     if (m_options.m_language != lldb::eLanguageTypeUnknown)
1943       DataVisualization::Categories::Enable(m_options.m_language);
1944
1945     result.SetStatus(eReturnStatusSuccessFinishResult);
1946     return result.Succeeded();
1947   }
1948 };
1949
1950 // CommandObjectTypeCategoryDelete
1951
1952 class CommandObjectTypeCategoryDelete : public CommandObjectParsed {
1953 public:
1954   CommandObjectTypeCategoryDelete(CommandInterpreter &interpreter)
1955       : CommandObjectParsed(interpreter, "type category delete",
1956                             "Delete a category and all associated formatters.",
1957                             nullptr) {
1958     CommandArgumentEntry type_arg;
1959     CommandArgumentData type_style_arg;
1960
1961     type_style_arg.arg_type = eArgTypeName;
1962     type_style_arg.arg_repetition = eArgRepeatPlus;
1963
1964     type_arg.push_back(type_style_arg);
1965
1966     m_arguments.push_back(type_arg);
1967   }
1968
1969   ~CommandObjectTypeCategoryDelete() override = default;
1970
1971 protected:
1972   bool DoExecute(Args &command, CommandReturnObject &result) override {
1973     const size_t argc = command.GetArgumentCount();
1974
1975     if (argc < 1) {
1976       result.AppendErrorWithFormat("%s takes 1 or more arg.\n",
1977                                    m_cmd_name.c_str());
1978       result.SetStatus(eReturnStatusFailed);
1979       return false;
1980     }
1981
1982     bool success = true;
1983
1984     // the order is not relevant here
1985     for (int i = argc - 1; i >= 0; i--) {
1986       const char *typeA = command.GetArgumentAtIndex(i);
1987       ConstString typeCS(typeA);
1988
1989       if (!typeCS) {
1990         result.AppendError("empty category name not allowed");
1991         result.SetStatus(eReturnStatusFailed);
1992         return false;
1993       }
1994       if (!DataVisualization::Categories::Delete(typeCS))
1995         success = false; // keep deleting even if we hit an error
1996     }
1997     if (success) {
1998       result.SetStatus(eReturnStatusSuccessFinishResult);
1999       return result.Succeeded();
2000     } else {
2001       result.AppendError("cannot delete one or more categories\n");
2002       result.SetStatus(eReturnStatusFailed);
2003       return false;
2004     }
2005   }
2006 };
2007
2008 // CommandObjectTypeCategoryDisable
2009
2010 OptionDefinition constexpr g_type_category_disable_options[] = {
2011 #define LLDB_OPTIONS_type_category_disable
2012 #include "CommandOptions.inc"
2013 };
2014
2015 class CommandObjectTypeCategoryDisable : public CommandObjectParsed {
2016   class CommandOptions : public Options {
2017   public:
2018     CommandOptions() : Options() {}
2019
2020     ~CommandOptions() override = default;
2021
2022     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
2023                           ExecutionContext *execution_context) override {
2024       Status error;
2025       const int short_option = m_getopt_table[option_idx].val;
2026
2027       switch (short_option) {
2028       case 'l':
2029         if (!option_arg.empty()) {
2030           m_language = Language::GetLanguageTypeFromString(option_arg);
2031           if (m_language == lldb::eLanguageTypeUnknown)
2032             error.SetErrorStringWithFormat("unrecognized language '%s'",
2033                                            option_arg.str().c_str());
2034         }
2035         break;
2036       default:
2037         error.SetErrorStringWithFormat("unrecognized option '%c'",
2038                                        short_option);
2039         break;
2040       }
2041
2042       return error;
2043     }
2044
2045     void OptionParsingStarting(ExecutionContext *execution_context) override {
2046       m_language = lldb::eLanguageTypeUnknown;
2047     }
2048
2049     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
2050       return llvm::makeArrayRef(g_type_category_disable_options);
2051     }
2052
2053     // Instance variables to hold the values for command options.
2054
2055     lldb::LanguageType m_language;
2056   };
2057
2058   CommandOptions m_options;
2059
2060   Options *GetOptions() override { return &m_options; }
2061
2062 public:
2063   CommandObjectTypeCategoryDisable(CommandInterpreter &interpreter)
2064       : CommandObjectParsed(interpreter, "type category disable",
2065                             "Disable a category as a source of formatters.",
2066                             nullptr),
2067         m_options() {
2068     CommandArgumentEntry type_arg;
2069     CommandArgumentData type_style_arg;
2070
2071     type_style_arg.arg_type = eArgTypeName;
2072     type_style_arg.arg_repetition = eArgRepeatPlus;
2073
2074     type_arg.push_back(type_style_arg);
2075
2076     m_arguments.push_back(type_arg);
2077   }
2078
2079   ~CommandObjectTypeCategoryDisable() override = default;
2080
2081 protected:
2082   bool DoExecute(Args &command, CommandReturnObject &result) override {
2083     const size_t argc = command.GetArgumentCount();
2084
2085     if (argc < 1 && m_options.m_language == lldb::eLanguageTypeUnknown) {
2086       result.AppendErrorWithFormat("%s takes arguments and/or a language",
2087                                    m_cmd_name.c_str());
2088       result.SetStatus(eReturnStatusFailed);
2089       return false;
2090     }
2091
2092     if (argc == 1 && strcmp(command.GetArgumentAtIndex(0), "*") == 0) {
2093       DataVisualization::Categories::DisableStar();
2094     } else if (argc > 0) {
2095       // the order is not relevant here
2096       for (int i = argc - 1; i >= 0; i--) {
2097         const char *typeA = command.GetArgumentAtIndex(i);
2098         ConstString typeCS(typeA);
2099
2100         if (!typeCS) {
2101           result.AppendError("empty category name not allowed");
2102           result.SetStatus(eReturnStatusFailed);
2103           return false;
2104         }
2105         DataVisualization::Categories::Disable(typeCS);
2106       }
2107     }
2108
2109     if (m_options.m_language != lldb::eLanguageTypeUnknown)
2110       DataVisualization::Categories::Disable(m_options.m_language);
2111
2112     result.SetStatus(eReturnStatusSuccessFinishResult);
2113     return result.Succeeded();
2114   }
2115 };
2116
2117 // CommandObjectTypeCategoryList
2118
2119 class CommandObjectTypeCategoryList : public CommandObjectParsed {
2120 public:
2121   CommandObjectTypeCategoryList(CommandInterpreter &interpreter)
2122       : CommandObjectParsed(interpreter, "type category list",
2123                             "Provide a list of all existing categories.",
2124                             nullptr) {
2125     CommandArgumentEntry type_arg;
2126     CommandArgumentData type_style_arg;
2127
2128     type_style_arg.arg_type = eArgTypeName;
2129     type_style_arg.arg_repetition = eArgRepeatOptional;
2130
2131     type_arg.push_back(type_style_arg);
2132
2133     m_arguments.push_back(type_arg);
2134   }
2135
2136   ~CommandObjectTypeCategoryList() override = default;
2137
2138 protected:
2139   bool DoExecute(Args &command, CommandReturnObject &result) override {
2140     const size_t argc = command.GetArgumentCount();
2141
2142     std::unique_ptr<RegularExpression> regex;
2143
2144     if (argc == 1) {
2145       regex.reset(new RegularExpression());
2146       const char *arg = command.GetArgumentAtIndex(0);
2147       if (!regex->Compile(llvm::StringRef::withNullAsEmpty(arg))) {
2148         result.AppendErrorWithFormat(
2149             "syntax error in category regular expression '%s'", arg);
2150         result.SetStatus(eReturnStatusFailed);
2151         return false;
2152       }
2153     } else if (argc != 0) {
2154       result.AppendErrorWithFormat("%s takes 0 or one arg.\n",
2155                                    m_cmd_name.c_str());
2156       result.SetStatus(eReturnStatusFailed);
2157       return false;
2158     }
2159
2160     DataVisualization::Categories::ForEach(
2161         [&regex, &result](const lldb::TypeCategoryImplSP &category_sp) -> bool {
2162           if (regex) {
2163             bool escape = true;
2164             if (regex->GetText() == category_sp->GetName()) {
2165               escape = false;
2166             } else if (regex->Execute(llvm::StringRef::withNullAsEmpty(
2167                            category_sp->GetName()))) {
2168               escape = false;
2169             }
2170
2171             if (escape)
2172               return true;
2173           }
2174
2175           result.GetOutputStream().Printf(
2176               "Category: %s\n", category_sp->GetDescription().c_str());
2177
2178           return true;
2179         });
2180
2181     result.SetStatus(eReturnStatusSuccessFinishResult);
2182     return result.Succeeded();
2183   }
2184 };
2185
2186 // CommandObjectTypeFilterList
2187
2188 class CommandObjectTypeFilterList
2189     : public CommandObjectTypeFormatterList<TypeFilterImpl> {
2190 public:
2191   CommandObjectTypeFilterList(CommandInterpreter &interpreter)
2192       : CommandObjectTypeFormatterList(interpreter, "type filter list",
2193                                        "Show a list of current filters.") {}
2194 };
2195
2196 #ifndef LLDB_DISABLE_PYTHON
2197
2198 // CommandObjectTypeSynthList
2199
2200 class CommandObjectTypeSynthList
2201     : public CommandObjectTypeFormatterList<SyntheticChildren> {
2202 public:
2203   CommandObjectTypeSynthList(CommandInterpreter &interpreter)
2204       : CommandObjectTypeFormatterList(
2205             interpreter, "type synthetic list",
2206             "Show a list of current synthetic providers.") {}
2207 };
2208
2209 #endif // LLDB_DISABLE_PYTHON
2210
2211 // CommandObjectTypeFilterDelete
2212
2213 class CommandObjectTypeFilterDelete : public CommandObjectTypeFormatterDelete {
2214 public:
2215   CommandObjectTypeFilterDelete(CommandInterpreter &interpreter)
2216       : CommandObjectTypeFormatterDelete(
2217             interpreter,
2218             eFormatCategoryItemFilter | eFormatCategoryItemRegexFilter,
2219             "type filter delete", "Delete an existing filter for a type.") {}
2220
2221   ~CommandObjectTypeFilterDelete() override = default;
2222 };
2223
2224 #ifndef LLDB_DISABLE_PYTHON
2225
2226 // CommandObjectTypeSynthDelete
2227
2228 class CommandObjectTypeSynthDelete : public CommandObjectTypeFormatterDelete {
2229 public:
2230   CommandObjectTypeSynthDelete(CommandInterpreter &interpreter)
2231       : CommandObjectTypeFormatterDelete(
2232             interpreter,
2233             eFormatCategoryItemSynth | eFormatCategoryItemRegexSynth,
2234             "type synthetic delete",
2235             "Delete an existing synthetic provider for a type.") {}
2236
2237   ~CommandObjectTypeSynthDelete() override = default;
2238 };
2239
2240 #endif // LLDB_DISABLE_PYTHON
2241
2242 // CommandObjectTypeFilterClear
2243
2244 class CommandObjectTypeFilterClear : public CommandObjectTypeFormatterClear {
2245 public:
2246   CommandObjectTypeFilterClear(CommandInterpreter &interpreter)
2247       : CommandObjectTypeFormatterClear(
2248             interpreter,
2249             eFormatCategoryItemFilter | eFormatCategoryItemRegexFilter,
2250             "type filter clear", "Delete all existing filter.") {}
2251 };
2252
2253 #ifndef LLDB_DISABLE_PYTHON
2254 // CommandObjectTypeSynthClear
2255
2256 class CommandObjectTypeSynthClear : public CommandObjectTypeFormatterClear {
2257 public:
2258   CommandObjectTypeSynthClear(CommandInterpreter &interpreter)
2259       : CommandObjectTypeFormatterClear(
2260             interpreter,
2261             eFormatCategoryItemSynth | eFormatCategoryItemRegexSynth,
2262             "type synthetic clear",
2263             "Delete all existing synthetic providers.") {}
2264 };
2265
2266 bool CommandObjectTypeSynthAdd::Execute_HandwritePython(
2267     Args &command, CommandReturnObject &result) {
2268   SynthAddOptions *options = new SynthAddOptions(
2269       m_options.m_skip_pointers, m_options.m_skip_references,
2270       m_options.m_cascade, m_options.m_regex, m_options.m_category);
2271
2272   for (auto &entry : command.entries()) {
2273     if (entry.ref.empty()) {
2274       result.AppendError("empty typenames not allowed");
2275       result.SetStatus(eReturnStatusFailed);
2276       return false;
2277     }
2278
2279     options->m_target_types << entry.ref;
2280   }
2281
2282   m_interpreter.GetPythonCommandsFromIOHandler(
2283       "    ",   // Prompt
2284       *this,    // IOHandlerDelegate
2285       true,     // Run IOHandler in async mode
2286       options); // Baton for the "io_handler" that will be passed back into our
2287                 // IOHandlerDelegate functions
2288   result.SetStatus(eReturnStatusSuccessFinishNoResult);
2289   return result.Succeeded();
2290 }
2291
2292 bool CommandObjectTypeSynthAdd::Execute_PythonClass(
2293     Args &command, CommandReturnObject &result) {
2294   const size_t argc = command.GetArgumentCount();
2295
2296   if (argc < 1) {
2297     result.AppendErrorWithFormat("%s takes one or more args.\n",
2298                                  m_cmd_name.c_str());
2299     result.SetStatus(eReturnStatusFailed);
2300     return false;
2301   }
2302
2303   if (m_options.m_class_name.empty() && !m_options.m_input_python) {
2304     result.AppendErrorWithFormat("%s needs either a Python class name or -P to "
2305                                  "directly input Python code.\n",
2306                                  m_cmd_name.c_str());
2307     result.SetStatus(eReturnStatusFailed);
2308     return false;
2309   }
2310
2311   SyntheticChildrenSP entry;
2312
2313   ScriptedSyntheticChildren *impl = new ScriptedSyntheticChildren(
2314       SyntheticChildren::Flags()
2315           .SetCascades(m_options.m_cascade)
2316           .SetSkipPointers(m_options.m_skip_pointers)
2317           .SetSkipReferences(m_options.m_skip_references),
2318       m_options.m_class_name.c_str());
2319
2320   entry.reset(impl);
2321
2322   ScriptInterpreter *interpreter = GetDebugger().GetScriptInterpreter();
2323
2324   if (interpreter &&
2325       !interpreter->CheckObjectExists(impl->GetPythonClassName()))
2326     result.AppendWarning("The provided class does not exist - please define it "
2327                          "before attempting to use this synthetic provider");
2328
2329   // now I have a valid provider, let's add it to every type
2330
2331   lldb::TypeCategoryImplSP category;
2332   DataVisualization::Categories::GetCategory(
2333       ConstString(m_options.m_category.c_str()), category);
2334
2335   Status error;
2336
2337   for (auto &arg_entry : command.entries()) {
2338     if (arg_entry.ref.empty()) {
2339       result.AppendError("empty typenames not allowed");
2340       result.SetStatus(eReturnStatusFailed);
2341       return false;
2342     }
2343
2344     ConstString typeCS(arg_entry.ref);
2345     if (!AddSynth(typeCS, entry,
2346                   m_options.m_regex ? eRegexSynth : eRegularSynth,
2347                   m_options.m_category, &error)) {
2348       result.AppendError(error.AsCString());
2349       result.SetStatus(eReturnStatusFailed);
2350       return false;
2351     }
2352   }
2353
2354   result.SetStatus(eReturnStatusSuccessFinishNoResult);
2355   return result.Succeeded();
2356 }
2357
2358 CommandObjectTypeSynthAdd::CommandObjectTypeSynthAdd(
2359     CommandInterpreter &interpreter)
2360     : CommandObjectParsed(interpreter, "type synthetic add",
2361                           "Add a new synthetic provider for a type.", nullptr),
2362       IOHandlerDelegateMultiline("DONE"), m_options() {
2363   CommandArgumentEntry type_arg;
2364   CommandArgumentData type_style_arg;
2365
2366   type_style_arg.arg_type = eArgTypeName;
2367   type_style_arg.arg_repetition = eArgRepeatPlus;
2368
2369   type_arg.push_back(type_style_arg);
2370
2371   m_arguments.push_back(type_arg);
2372 }
2373
2374 bool CommandObjectTypeSynthAdd::AddSynth(ConstString type_name,
2375                                          SyntheticChildrenSP entry,
2376                                          SynthFormatType type,
2377                                          std::string category_name,
2378                                          Status *error) {
2379   lldb::TypeCategoryImplSP category;
2380   DataVisualization::Categories::GetCategory(ConstString(category_name.c_str()),
2381                                              category);
2382
2383   if (type == eRegularSynth) {
2384     if (FixArrayTypeNameWithRegex(type_name))
2385       type = eRegexSynth;
2386   }
2387
2388   if (category->AnyMatches(type_name, eFormatCategoryItemFilter |
2389                                           eFormatCategoryItemRegexFilter,
2390                            false)) {
2391     if (error)
2392       error->SetErrorStringWithFormat("cannot add synthetic for type %s when "
2393                                       "filter is defined in same category!",
2394                                       type_name.AsCString());
2395     return false;
2396   }
2397
2398   if (type == eRegexSynth) {
2399     RegularExpressionSP typeRX(new RegularExpression());
2400     if (!typeRX->Compile(type_name.GetStringRef())) {
2401       if (error)
2402         error->SetErrorString(
2403             "regex format error (maybe this is not really a regex?)");
2404       return false;
2405     }
2406
2407     category->GetRegexTypeSyntheticsContainer()->Delete(type_name);
2408     category->GetRegexTypeSyntheticsContainer()->Add(typeRX, entry);
2409
2410     return true;
2411   } else {
2412     category->GetTypeSyntheticsContainer()->Add(type_name, entry);
2413     return true;
2414   }
2415 }
2416
2417 #endif // LLDB_DISABLE_PYTHON
2418
2419 static constexpr OptionDefinition g_type_filter_add_options[] = {
2420 #define LLDB_OPTIONS_type_filter_add
2421 #include "CommandOptions.inc"
2422 };
2423
2424 class CommandObjectTypeFilterAdd : public CommandObjectParsed {
2425 private:
2426   class CommandOptions : public Options {
2427     typedef std::vector<std::string> option_vector;
2428
2429   public:
2430     CommandOptions() : Options() {}
2431
2432     ~CommandOptions() override = default;
2433
2434     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
2435                           ExecutionContext *execution_context) override {
2436       Status error;
2437       const int short_option = m_getopt_table[option_idx].val;
2438       bool success;
2439
2440       switch (short_option) {
2441       case 'C':
2442         m_cascade = OptionArgParser::ToBoolean(option_arg, true, &success);
2443         if (!success)
2444           error.SetErrorStringWithFormat("invalid value for cascade: %s",
2445                                          option_arg.str().c_str());
2446         break;
2447       case 'c':
2448         m_expr_paths.push_back(option_arg);
2449         has_child_list = true;
2450         break;
2451       case 'p':
2452         m_skip_pointers = true;
2453         break;
2454       case 'r':
2455         m_skip_references = true;
2456         break;
2457       case 'w':
2458         m_category = std::string(option_arg);
2459         break;
2460       case 'x':
2461         m_regex = true;
2462         break;
2463       default:
2464         error.SetErrorStringWithFormat("unrecognized option '%c'",
2465                                        short_option);
2466         break;
2467       }
2468
2469       return error;
2470     }
2471
2472     void OptionParsingStarting(ExecutionContext *execution_context) override {
2473       m_cascade = true;
2474       m_skip_pointers = false;
2475       m_skip_references = false;
2476       m_category = "default";
2477       m_expr_paths.clear();
2478       has_child_list = false;
2479       m_regex = false;
2480     }
2481
2482     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
2483       return llvm::makeArrayRef(g_type_filter_add_options);
2484     }
2485
2486     // Instance variables to hold the values for command options.
2487
2488     bool m_cascade;
2489     bool m_skip_references;
2490     bool m_skip_pointers;
2491     bool m_input_python;
2492     option_vector m_expr_paths;
2493     std::string m_category;
2494     bool has_child_list;
2495     bool m_regex;
2496
2497     typedef option_vector::iterator ExpressionPathsIterator;
2498   };
2499
2500   CommandOptions m_options;
2501
2502   Options *GetOptions() override { return &m_options; }
2503
2504   enum FilterFormatType { eRegularFilter, eRegexFilter };
2505
2506   bool AddFilter(ConstString type_name, TypeFilterImplSP entry,
2507                  FilterFormatType type, std::string category_name,
2508                  Status *error) {
2509     lldb::TypeCategoryImplSP category;
2510     DataVisualization::Categories::GetCategory(
2511         ConstString(category_name.c_str()), category);
2512
2513     if (type == eRegularFilter) {
2514       if (FixArrayTypeNameWithRegex(type_name))
2515         type = eRegexFilter;
2516     }
2517
2518     if (category->AnyMatches(type_name, eFormatCategoryItemSynth |
2519                                             eFormatCategoryItemRegexSynth,
2520                              false)) {
2521       if (error)
2522         error->SetErrorStringWithFormat("cannot add filter for type %s when "
2523                                         "synthetic is defined in same "
2524                                         "category!",
2525                                         type_name.AsCString());
2526       return false;
2527     }
2528
2529     if (type == eRegexFilter) {
2530       RegularExpressionSP typeRX(new RegularExpression());
2531       if (!typeRX->Compile(type_name.GetStringRef())) {
2532         if (error)
2533           error->SetErrorString(
2534               "regex format error (maybe this is not really a regex?)");
2535         return false;
2536       }
2537
2538       category->GetRegexTypeFiltersContainer()->Delete(type_name);
2539       category->GetRegexTypeFiltersContainer()->Add(typeRX, entry);
2540
2541       return true;
2542     } else {
2543       category->GetTypeFiltersContainer()->Add(type_name, entry);
2544       return true;
2545     }
2546   }
2547
2548 public:
2549   CommandObjectTypeFilterAdd(CommandInterpreter &interpreter)
2550       : CommandObjectParsed(interpreter, "type filter add",
2551                             "Add a new filter for a type.", nullptr),
2552         m_options() {
2553     CommandArgumentEntry type_arg;
2554     CommandArgumentData type_style_arg;
2555
2556     type_style_arg.arg_type = eArgTypeName;
2557     type_style_arg.arg_repetition = eArgRepeatPlus;
2558
2559     type_arg.push_back(type_style_arg);
2560
2561     m_arguments.push_back(type_arg);
2562
2563     SetHelpLong(
2564         R"(
2565 The following examples of 'type filter add' refer to this code snippet for context:
2566
2567     class Foo {
2568         int a;
2569         int b;
2570         int c;
2571         int d;
2572         int e;
2573         int f;
2574         int g;
2575         int h;
2576         int i;
2577     }
2578     Foo my_foo;
2579
2580 Adding a simple filter:
2581
2582 (lldb) type filter add --child a --child g Foo
2583 (lldb) frame variable my_foo
2584
2585 )"
2586         "Produces output where only a and g are displayed.  Other children of my_foo \
2587 (b, c, d, e, f, h and i) are available by asking for them explicitly:"
2588         R"(
2589
2590 (lldb) frame variable my_foo.b my_foo.c my_foo.i
2591
2592 )"
2593         "The formatting option --raw on frame variable bypasses the filter, showing \
2594 all children of my_foo as if no filter was defined:"
2595         R"(
2596
2597 (lldb) frame variable my_foo --raw)");
2598   }
2599
2600   ~CommandObjectTypeFilterAdd() override = default;
2601
2602 protected:
2603   bool DoExecute(Args &command, CommandReturnObject &result) override {
2604     const size_t argc = command.GetArgumentCount();
2605
2606     if (argc < 1) {
2607       result.AppendErrorWithFormat("%s takes one or more args.\n",
2608                                    m_cmd_name.c_str());
2609       result.SetStatus(eReturnStatusFailed);
2610       return false;
2611     }
2612
2613     if (m_options.m_expr_paths.empty()) {
2614       result.AppendErrorWithFormat("%s needs one or more children.\n",
2615                                    m_cmd_name.c_str());
2616       result.SetStatus(eReturnStatusFailed);
2617       return false;
2618     }
2619
2620     TypeFilterImplSP entry(new TypeFilterImpl(
2621         SyntheticChildren::Flags()
2622             .SetCascades(m_options.m_cascade)
2623             .SetSkipPointers(m_options.m_skip_pointers)
2624             .SetSkipReferences(m_options.m_skip_references)));
2625
2626     // go through the expression paths
2627     CommandOptions::ExpressionPathsIterator begin,
2628         end = m_options.m_expr_paths.end();
2629
2630     for (begin = m_options.m_expr_paths.begin(); begin != end; begin++)
2631       entry->AddExpressionPath(*begin);
2632
2633     // now I have a valid provider, let's add it to every type
2634
2635     lldb::TypeCategoryImplSP category;
2636     DataVisualization::Categories::GetCategory(
2637         ConstString(m_options.m_category.c_str()), category);
2638
2639     Status error;
2640
2641     WarnOnPotentialUnquotedUnsignedType(command, result);
2642
2643     for (auto &arg_entry : command.entries()) {
2644       if (arg_entry.ref.empty()) {
2645         result.AppendError("empty typenames not allowed");
2646         result.SetStatus(eReturnStatusFailed);
2647         return false;
2648       }
2649
2650       ConstString typeCS(arg_entry.ref);
2651       if (!AddFilter(typeCS, entry,
2652                      m_options.m_regex ? eRegexFilter : eRegularFilter,
2653                      m_options.m_category, &error)) {
2654         result.AppendError(error.AsCString());
2655         result.SetStatus(eReturnStatusFailed);
2656         return false;
2657       }
2658     }
2659
2660     result.SetStatus(eReturnStatusSuccessFinishNoResult);
2661     return result.Succeeded();
2662   }
2663 };
2664
2665 // "type lookup"
2666 static constexpr OptionDefinition g_type_lookup_options[] = {
2667 #define LLDB_OPTIONS_type_lookup
2668 #include "CommandOptions.inc"
2669 };
2670
2671 class CommandObjectTypeLookup : public CommandObjectRaw {
2672 protected:
2673   // this function is allowed to do a more aggressive job at guessing languages
2674   // than the expression parser is comfortable with - so leave the original
2675   // call alone and add one that is specific to type lookup
2676   lldb::LanguageType GuessLanguage(StackFrame *frame) {
2677     lldb::LanguageType lang_type = lldb::eLanguageTypeUnknown;
2678
2679     if (!frame)
2680       return lang_type;
2681
2682     lang_type = frame->GuessLanguage();
2683     if (lang_type != lldb::eLanguageTypeUnknown)
2684       return lang_type;
2685
2686     Symbol *s = frame->GetSymbolContext(eSymbolContextSymbol).symbol;
2687     if (s)
2688       lang_type = s->GetMangled().GuessLanguage();
2689
2690     return lang_type;
2691   }
2692
2693   class CommandOptions : public OptionGroup {
2694   public:
2695     CommandOptions()
2696         : OptionGroup(), m_show_help(false), m_language(eLanguageTypeUnknown) {}
2697
2698     ~CommandOptions() override = default;
2699
2700     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
2701       return llvm::makeArrayRef(g_type_lookup_options);
2702     }
2703
2704     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
2705                           ExecutionContext *execution_context) override {
2706       Status error;
2707
2708       const int short_option = g_type_lookup_options[option_idx].short_option;
2709
2710       switch (short_option) {
2711       case 'h':
2712         m_show_help = true;
2713         break;
2714
2715       case 'l':
2716         m_language = Language::GetLanguageTypeFromString(option_value);
2717         break;
2718
2719       default:
2720         error.SetErrorStringWithFormat("invalid short option character '%c'",
2721                                        short_option);
2722         break;
2723       }
2724
2725       return error;
2726     }
2727
2728     void OptionParsingStarting(ExecutionContext *execution_context) override {
2729       m_show_help = false;
2730       m_language = eLanguageTypeUnknown;
2731     }
2732
2733     // Options table: Required for subclasses of Options.
2734
2735     bool m_show_help;
2736     lldb::LanguageType m_language;
2737   };
2738
2739   OptionGroupOptions m_option_group;
2740   CommandOptions m_command_options;
2741
2742 public:
2743   CommandObjectTypeLookup(CommandInterpreter &interpreter)
2744       : CommandObjectRaw(interpreter, "type lookup",
2745                          "Lookup types and declarations in the current target, "
2746                          "following language-specific naming conventions.",
2747                          "type lookup <type-specifier>",
2748                          eCommandRequiresTarget),
2749         m_option_group(), m_command_options() {
2750     m_option_group.Append(&m_command_options);
2751     m_option_group.Finalize();
2752   }
2753
2754   ~CommandObjectTypeLookup() override = default;
2755
2756   Options *GetOptions() override { return &m_option_group; }
2757
2758   llvm::StringRef GetHelpLong() override {
2759     if (!m_cmd_help_long.empty())
2760       return m_cmd_help_long;
2761
2762     StreamString stream;
2763     Language::ForEach([&](Language *lang) {
2764       if (const char *help = lang->GetLanguageSpecificTypeLookupHelp())
2765         stream.Printf("%s\n", help);
2766       return true;
2767     });
2768
2769     m_cmd_help_long = stream.GetString();
2770     return m_cmd_help_long;
2771   }
2772
2773   bool DoExecute(llvm::StringRef raw_command_line,
2774                  CommandReturnObject &result) override {
2775     if (raw_command_line.empty()) {
2776       result.SetError(
2777           "type lookup cannot be invoked without a type name as argument");
2778       return false;
2779     }
2780
2781     auto exe_ctx = GetCommandInterpreter().GetExecutionContext();
2782     m_option_group.NotifyOptionParsingStarting(&exe_ctx);
2783
2784     OptionsWithRaw args(raw_command_line);
2785     const char *name_of_type = args.GetRawPart().c_str();
2786
2787     if (args.HasArgs())
2788       if (!ParseOptionsAndNotify(args.GetArgs(), result, m_option_group,
2789                                  exe_ctx))
2790         return false;
2791
2792     ExecutionContextScope *best_scope = exe_ctx.GetBestExecutionContextScope();
2793
2794     bool any_found = false;
2795
2796     std::vector<Language *> languages;
2797
2798     bool is_global_search = false;
2799     LanguageType guessed_language = lldb::eLanguageTypeUnknown;
2800
2801     if ((is_global_search =
2802              (m_command_options.m_language == eLanguageTypeUnknown))) {
2803       Language::ForEach([&](Language *lang) {
2804         languages.push_back(lang);
2805         return true;
2806       });
2807     } else {
2808       languages.push_back(Language::FindPlugin(m_command_options.m_language));
2809     }
2810
2811     // This is not the most efficient way to do this, but we support very few
2812     // languages so the cost of the sort is going to be dwarfed by the actual
2813     // lookup anyway
2814     if (StackFrame *frame = m_exe_ctx.GetFramePtr()) {
2815       guessed_language = GuessLanguage(frame);
2816       if (guessed_language != eLanguageTypeUnknown) {
2817         llvm::sort(
2818             languages.begin(), languages.end(),
2819             [guessed_language](Language *lang1, Language *lang2) -> bool {
2820               if (!lang1 || !lang2)
2821                 return false;
2822               LanguageType lt1 = lang1->GetLanguageType();
2823               LanguageType lt2 = lang2->GetLanguageType();
2824               if (lt1 == guessed_language)
2825                 return true; // make the selected frame's language come first
2826               if (lt2 == guessed_language)
2827                 return false; // make the selected frame's language come first
2828               return (lt1 < lt2); // normal comparison otherwise
2829             });
2830       }
2831     }
2832
2833     bool is_first_language = true;
2834
2835     for (Language *language : languages) {
2836       if (!language)
2837         continue;
2838
2839       if (auto scavenger = language->GetTypeScavenger()) {
2840         Language::TypeScavenger::ResultSet search_results;
2841         if (scavenger->Find(best_scope, name_of_type, search_results) > 0) {
2842           for (const auto &search_result : search_results) {
2843             if (search_result && search_result->IsValid()) {
2844               any_found = true;
2845               search_result->DumpToStream(result.GetOutputStream(),
2846                                           this->m_command_options.m_show_help);
2847             }
2848           }
2849         }
2850       }
2851       // this is "type lookup SomeName" and we did find a match, so get out
2852       if (any_found && is_global_search)
2853         break;
2854       else if (is_first_language && is_global_search &&
2855                guessed_language != lldb::eLanguageTypeUnknown) {
2856         is_first_language = false;
2857         result.GetOutputStream().Printf(
2858             "no type was found in the current language %s matching '%s'; "
2859             "performing a global search across all languages\n",
2860             Language::GetNameForLanguageType(guessed_language), name_of_type);
2861       }
2862     }
2863
2864     if (!any_found)
2865       result.AppendMessageWithFormat("no type was found matching '%s'\n",
2866                                      name_of_type);
2867
2868     result.SetStatus(any_found ? lldb::eReturnStatusSuccessFinishResult
2869                                : lldb::eReturnStatusSuccessFinishNoResult);
2870     return true;
2871   }
2872 };
2873
2874 template <typename FormatterType>
2875 class CommandObjectFormatterInfo : public CommandObjectRaw {
2876 public:
2877   typedef std::function<typename FormatterType::SharedPointer(ValueObject &)>
2878       DiscoveryFunction;
2879   CommandObjectFormatterInfo(CommandInterpreter &interpreter,
2880                              const char *formatter_name,
2881                              DiscoveryFunction discovery_func)
2882       : CommandObjectRaw(interpreter, "", "", "",
2883                          eCommandRequiresFrame),
2884         m_formatter_name(formatter_name ? formatter_name : ""),
2885         m_discovery_function(discovery_func) {
2886     StreamString name;
2887     name.Printf("type %s info", formatter_name);
2888     SetCommandName(name.GetString());
2889     StreamString help;
2890     help.Printf("This command evaluates the provided expression and shows "
2891                 "which %s is applied to the resulting value (if any).",
2892                 formatter_name);
2893     SetHelp(help.GetString());
2894     StreamString syntax;
2895     syntax.Printf("type %s info <expr>", formatter_name);
2896     SetSyntax(syntax.GetString());
2897   }
2898
2899   ~CommandObjectFormatterInfo() override = default;
2900
2901 protected:
2902   bool DoExecute(llvm::StringRef command,
2903                  CommandReturnObject &result) override {
2904     TargetSP target_sp = GetDebugger().GetSelectedTarget();
2905     Thread *thread = GetDefaultThread();
2906     if (!thread) {
2907       result.AppendError("no default thread");
2908       result.SetStatus(lldb::eReturnStatusFailed);
2909       return false;
2910     }
2911
2912     StackFrameSP frame_sp = thread->GetSelectedFrame();
2913     ValueObjectSP result_valobj_sp;
2914     EvaluateExpressionOptions options;
2915     lldb::ExpressionResults expr_result = target_sp->EvaluateExpression(
2916         command, frame_sp.get(), result_valobj_sp, options);
2917     if (expr_result == eExpressionCompleted && result_valobj_sp) {
2918       result_valobj_sp =
2919           result_valobj_sp->GetQualifiedRepresentationIfAvailable(
2920               target_sp->GetPreferDynamicValue(),
2921               target_sp->GetEnableSyntheticValue());
2922       typename FormatterType::SharedPointer formatter_sp =
2923           m_discovery_function(*result_valobj_sp);
2924       if (formatter_sp) {
2925         std::string description(formatter_sp->GetDescription());
2926         result.GetOutputStream()
2927             << m_formatter_name << " applied to ("
2928             << result_valobj_sp->GetDisplayTypeName().AsCString("<unknown>")
2929             << ") " << command << " is: " << description << "\n";
2930         result.SetStatus(lldb::eReturnStatusSuccessFinishResult);
2931       } else {
2932         result.GetOutputStream()
2933             << "no " << m_formatter_name << " applies to ("
2934             << result_valobj_sp->GetDisplayTypeName().AsCString("<unknown>")
2935             << ") " << command << "\n";
2936         result.SetStatus(lldb::eReturnStatusSuccessFinishNoResult);
2937       }
2938       return true;
2939     } else {
2940       result.AppendError("failed to evaluate expression");
2941       result.SetStatus(lldb::eReturnStatusFailed);
2942       return false;
2943     }
2944   }
2945
2946 private:
2947   std::string m_formatter_name;
2948   DiscoveryFunction m_discovery_function;
2949 };
2950
2951 class CommandObjectTypeFormat : public CommandObjectMultiword {
2952 public:
2953   CommandObjectTypeFormat(CommandInterpreter &interpreter)
2954       : CommandObjectMultiword(
2955             interpreter, "type format",
2956             "Commands for customizing value display formats.",
2957             "type format [<sub-command-options>] ") {
2958     LoadSubCommand(
2959         "add", CommandObjectSP(new CommandObjectTypeFormatAdd(interpreter)));
2960     LoadSubCommand("clear", CommandObjectSP(
2961                                 new CommandObjectTypeFormatClear(interpreter)));
2962     LoadSubCommand("delete", CommandObjectSP(new CommandObjectTypeFormatDelete(
2963                                  interpreter)));
2964     LoadSubCommand(
2965         "list", CommandObjectSP(new CommandObjectTypeFormatList(interpreter)));
2966     LoadSubCommand(
2967         "info", CommandObjectSP(new CommandObjectFormatterInfo<TypeFormatImpl>(
2968                     interpreter, "format",
2969                     [](ValueObject &valobj) -> TypeFormatImpl::SharedPointer {
2970                       return valobj.GetValueFormat();
2971                     })));
2972   }
2973
2974   ~CommandObjectTypeFormat() override = default;
2975 };
2976
2977 #ifndef LLDB_DISABLE_PYTHON
2978
2979 class CommandObjectTypeSynth : public CommandObjectMultiword {
2980 public:
2981   CommandObjectTypeSynth(CommandInterpreter &interpreter)
2982       : CommandObjectMultiword(
2983             interpreter, "type synthetic",
2984             "Commands for operating on synthetic type representations.",
2985             "type synthetic [<sub-command-options>] ") {
2986     LoadSubCommand("add",
2987                    CommandObjectSP(new CommandObjectTypeSynthAdd(interpreter)));
2988     LoadSubCommand(
2989         "clear", CommandObjectSP(new CommandObjectTypeSynthClear(interpreter)));
2990     LoadSubCommand("delete", CommandObjectSP(new CommandObjectTypeSynthDelete(
2991                                  interpreter)));
2992     LoadSubCommand(
2993         "list", CommandObjectSP(new CommandObjectTypeSynthList(interpreter)));
2994     LoadSubCommand(
2995         "info",
2996         CommandObjectSP(new CommandObjectFormatterInfo<SyntheticChildren>(
2997             interpreter, "synthetic",
2998             [](ValueObject &valobj) -> SyntheticChildren::SharedPointer {
2999               return valobj.GetSyntheticChildren();
3000             })));
3001   }
3002
3003   ~CommandObjectTypeSynth() override = default;
3004 };
3005
3006 #endif // LLDB_DISABLE_PYTHON
3007
3008 class CommandObjectTypeFilter : public CommandObjectMultiword {
3009 public:
3010   CommandObjectTypeFilter(CommandInterpreter &interpreter)
3011       : CommandObjectMultiword(interpreter, "type filter",
3012                                "Commands for operating on type filters.",
3013                                "type synthetic [<sub-command-options>] ") {
3014     LoadSubCommand(
3015         "add", CommandObjectSP(new CommandObjectTypeFilterAdd(interpreter)));
3016     LoadSubCommand("clear", CommandObjectSP(
3017                                 new CommandObjectTypeFilterClear(interpreter)));
3018     LoadSubCommand("delete", CommandObjectSP(new CommandObjectTypeFilterDelete(
3019                                  interpreter)));
3020     LoadSubCommand(
3021         "list", CommandObjectSP(new CommandObjectTypeFilterList(interpreter)));
3022   }
3023
3024   ~CommandObjectTypeFilter() override = default;
3025 };
3026
3027 class CommandObjectTypeCategory : public CommandObjectMultiword {
3028 public:
3029   CommandObjectTypeCategory(CommandInterpreter &interpreter)
3030       : CommandObjectMultiword(interpreter, "type category",
3031                                "Commands for operating on type categories.",
3032                                "type category [<sub-command-options>] ") {
3033     LoadSubCommand(
3034         "define",
3035         CommandObjectSP(new CommandObjectTypeCategoryDefine(interpreter)));
3036     LoadSubCommand(
3037         "enable",
3038         CommandObjectSP(new CommandObjectTypeCategoryEnable(interpreter)));
3039     LoadSubCommand(
3040         "disable",
3041         CommandObjectSP(new CommandObjectTypeCategoryDisable(interpreter)));
3042     LoadSubCommand(
3043         "delete",
3044         CommandObjectSP(new CommandObjectTypeCategoryDelete(interpreter)));
3045     LoadSubCommand("list", CommandObjectSP(
3046                                new CommandObjectTypeCategoryList(interpreter)));
3047   }
3048
3049   ~CommandObjectTypeCategory() override = default;
3050 };
3051
3052 class CommandObjectTypeSummary : public CommandObjectMultiword {
3053 public:
3054   CommandObjectTypeSummary(CommandInterpreter &interpreter)
3055       : CommandObjectMultiword(
3056             interpreter, "type summary",
3057             "Commands for editing variable summary display options.",
3058             "type summary [<sub-command-options>] ") {
3059     LoadSubCommand(
3060         "add", CommandObjectSP(new CommandObjectTypeSummaryAdd(interpreter)));
3061     LoadSubCommand("clear", CommandObjectSP(new CommandObjectTypeSummaryClear(
3062                                 interpreter)));
3063     LoadSubCommand("delete", CommandObjectSP(new CommandObjectTypeSummaryDelete(
3064                                  interpreter)));
3065     LoadSubCommand(
3066         "list", CommandObjectSP(new CommandObjectTypeSummaryList(interpreter)));
3067     LoadSubCommand(
3068         "info", CommandObjectSP(new CommandObjectFormatterInfo<TypeSummaryImpl>(
3069                     interpreter, "summary",
3070                     [](ValueObject &valobj) -> TypeSummaryImpl::SharedPointer {
3071                       return valobj.GetSummaryFormat();
3072                     })));
3073   }
3074
3075   ~CommandObjectTypeSummary() override = default;
3076 };
3077
3078 // CommandObjectType
3079
3080 CommandObjectType::CommandObjectType(CommandInterpreter &interpreter)
3081     : CommandObjectMultiword(interpreter, "type",
3082                              "Commands for operating on the type system.",
3083                              "type [<sub-command-options>]") {
3084   LoadSubCommand("category",
3085                  CommandObjectSP(new CommandObjectTypeCategory(interpreter)));
3086   LoadSubCommand("filter",
3087                  CommandObjectSP(new CommandObjectTypeFilter(interpreter)));
3088   LoadSubCommand("format",
3089                  CommandObjectSP(new CommandObjectTypeFormat(interpreter)));
3090   LoadSubCommand("summary",
3091                  CommandObjectSP(new CommandObjectTypeSummary(interpreter)));
3092 #ifndef LLDB_DISABLE_PYTHON
3093   LoadSubCommand("synthetic",
3094                  CommandObjectSP(new CommandObjectTypeSynth(interpreter)));
3095 #endif // LLDB_DISABLE_PYTHON
3096   LoadSubCommand("lookup",
3097                  CommandObjectSP(new CommandObjectTypeLookup(interpreter)));
3098 }
3099
3100 CommandObjectType::~CommandObjectType() = default;