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

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