/build/llvm-toolchain-snapshot-15~++20220216111134+dda3c14fd7db/lldb/source/Commands/CommandObjectType.cpp

Bug Summary

File:	build/llvm-toolchain-snapshot-15~++20220216111134+dda3c14fd7db/lldb/source/Commands/CommandObjectType.cpp
Warning:	line 2261, column 7 Potential leak of memory pointed to by 'options'
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name CommandObjectType.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/llvm-toolchain-snapshot-15~++20220216111134+dda3c14fd7db/build-llvm/tools/clang/stage2-bins -resource-dir /usr/lib/llvm-15/lib/clang/15.0.0 -isystem /usr/include/libxml2 -D HAVE_ROUND -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I tools/lldb/source/Commands -I /build/llvm-toolchain-snapshot-15~++20220216111134+dda3c14fd7db/lldb/source/Commands -I /build/llvm-toolchain-snapshot-15~++20220216111134+dda3c14fd7db/lldb/include -I tools/lldb/include -I include -I /build/llvm-toolchain-snapshot-15~++20220216111134+dda3c14fd7db/llvm/include -I /usr/include/python3.9 -I /build/llvm-toolchain-snapshot-15~++20220216111134+dda3c14fd7db/clang/include -I tools/lldb/../clang/include -I /build/llvm-toolchain-snapshot-15~++20220216111134+dda3c14fd7db/lldb/source -I tools/lldb/source -D _FORTIFY_SOURCE=2 -D NDEBUG -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-15/lib/clang/15.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fmacro-prefix-map=/build/llvm-toolchain-snapshot-15~++20220216111134+dda3c14fd7db/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fmacro-prefix-map=/build/llvm-toolchain-snapshot-15~++20220216111134+dda3c14fd7db/= -fcoverage-prefix-map=/build/llvm-toolchain-snapshot-15~++20220216111134+dda3c14fd7db/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fcoverage-prefix-map=/build/llvm-toolchain-snapshot-15~++20220216111134+dda3c14fd7db/= -O3 -Wno-unused-command-line-argument -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -Wno-deprecated-declarations -Wno-unknown-pragmas -Wno-strict-aliasing -Wno-deprecated-register -Wno-vla-extension -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/build/llvm-toolchain-snapshot-15~++20220216111134+dda3c14fd7db/build-llvm/tools/clang/stage2-bins -fdebug-prefix-map=/build/llvm-toolchain-snapshot-15~++20220216111134+dda3c14fd7db/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fdebug-prefix-map=/build/llvm-toolchain-snapshot-15~++20220216111134+dda3c14fd7db/= -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcolor-diagnostics -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2022-02-16-181416-145369-1 -x c++ /build/llvm-toolchain-snapshot-15~++20220216111134+dda3c14fd7db/lldb/source/Commands/CommandObjectType.cpp
1//===-- CommandObjectType.cpp ---------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//

9#include "CommandObjectType.h"

11#include "lldb/Core/Debugger.h"
12#include "lldb/Core/IOHandler.h"
13#include "lldb/DataFormatters/DataVisualization.h"
14#include "lldb/Host/Config.h"
15#include "lldb/Host/OptionParser.h"
16#include "lldb/Interpreter/CommandInterpreter.h"
17#include "lldb/Interpreter/CommandObject.h"
18#include "lldb/Interpreter/CommandReturnObject.h"
19#include "lldb/Interpreter/OptionArgParser.h"
20#include "lldb/Interpreter/OptionGroupFormat.h"
21#include "lldb/Interpreter/OptionValueBoolean.h"
22#include "lldb/Interpreter/OptionValueLanguage.h"
23#include "lldb/Interpreter/OptionValueString.h"
24#include "lldb/Interpreter/Options.h"
25#include "lldb/Symbol/Symbol.h"
26#include "lldb/Target/Language.h"
27#include "lldb/Target/StackFrame.h"
28#include "lldb/Target/Target.h"
29#include "lldb/Target/Thread.h"
30#include "lldb/Utility/ConstString.h"
31#include "lldb/Utility/RegularExpression.h"
32#include "lldb/Utility/StringList.h"

34#include "llvm/ADT/STLExtras.h"

36#include <algorithm>
37#include <functional>
38#include <memory>

40#define CHECK_FORMATTER_KIND_MASK(VAL)((m_formatter_kind_mask & (VAL)) == (VAL))                                         \
((m_formatter_kind_mask & (VAL)) == (VAL))

43using namespace lldb;
44using namespace lldb_private;

46class ScriptAddOptions {
47public:
TypeSummaryImpl::Flags m_flags;
StringList m_target_types;
bool m_regex;
ConstString m_name;
std::string m_category;

ScriptAddOptions(const TypeSummaryImpl::Flags &flags, bool regx,
                 ConstString name, std::string catg)
    : m_flags(flags), m_regex(regx), m_name(name), m_category(catg) {}

typedef std::shared_ptr<ScriptAddOptions> SharedPointer;
59};

61class SynthAddOptions {
62public:
bool m_skip_pointers;
bool m_skip_references;
bool m_cascade;
bool m_regex;
StringList m_target_types;
std::string m_category;

SynthAddOptions(bool sptr, bool sref, bool casc, bool regx, std::string catg)
    : m_skip_pointers(sptr), m_skip_references(sref), m_cascade(casc),
      m_regex(regx), m_category(catg) {}

typedef std::shared_ptr<SynthAddOptions> SharedPointer;
75};

77static bool WarnOnPotentialUnquotedUnsignedType(Args &command,
                                              CommandReturnObject &result) {
if (command.empty())
  return false;

for (auto entry : llvm::enumerate(command.entries().drop_back())) {
  if (entry.value().ref() != "unsigned")
    continue;
  auto next = command.entries()[entry.index() + 1].ref();
  if (next == "int" || next == "short" || next == "char" || next == "long") {
    result.AppendWarningWithFormat(
        "unsigned %s being treated as two types. if you meant the combined "
        "type "
        "name use  quotes, as in \"unsigned %s\"\n",
        next.str().c_str(), next.str().c_str());
    return true;
  }
}
return false;
96}

98#define LLDB_OPTIONS_type_summary_add
99#include "CommandOptions.inc"

101class CommandObjectTypeSummaryAdd : public CommandObjectParsed,
                                  public IOHandlerDelegateMultiline {
103private:
class CommandOptions : public Options {
public:
  CommandOptions(CommandInterpreter &interpreter) {}

  ~CommandOptions() override = default;

  Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                        ExecutionContext *execution_context) override;

  void OptionParsingStarting(ExecutionContext *execution_context) override;

  llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
    return llvm::makeArrayRef(g_type_summary_add_options);
  }

  // Instance variables to hold the values for command options.

  TypeSummaryImpl::Flags m_flags;
  bool m_regex;
  std::string m_format_string;
  ConstString m_name;
  std::string m_python_script;
  std::string m_python_function;
  bool m_is_add_script;
  std::string m_category;
};

CommandOptions m_options;

Options *GetOptions() override { return &m_options; }

bool Execute_ScriptSummary(Args &command, CommandReturnObject &result);

bool Execute_StringSummary(Args &command, CommandReturnObject &result);

139public:
enum SummaryFormatType { eRegularSummary, eRegexSummary, eNamedSummary };

CommandObjectTypeSummaryAdd(CommandInterpreter &interpreter);

~CommandObjectTypeSummaryAdd() override = default;

void IOHandlerActivated(IOHandler &io_handler, bool interactive) override {
  static const char *g_summary_addreader_instructions =
      "Enter your Python command(s). Type 'DONE' to end.\n"
      "def function (valobj,internal_dict):\n"
      "     \"\"\"valobj: an SBValue which you want to provide a summary "
      "for\n"
      "        internal_dict: an LLDB support object not to be used\"\"\"\n";

  StreamFileSP output_sp(io_handler.GetOutputStreamFileSP());
  if (output_sp && interactive) {
    output_sp->PutCString(g_summary_addreader_instructions);
    output_sp->Flush();
  }
}

void IOHandlerInputComplete(IOHandler &io_handler,
                            std::string &data) override {
  StreamFileSP error_sp = io_handler.GetErrorStreamFileSP();

165#if LLDB_ENABLE_PYTHON1
  ScriptInterpreter *interpreter = GetDebugger().GetScriptInterpreter();
  if (interpreter) {
    StringList lines;
    lines.SplitIntoLines(data);
    if (lines.GetSize() > 0) {
      ScriptAddOptions *options_ptr =
          ((ScriptAddOptions *)io_handler.GetUserData());
      if (options_ptr) {
        ScriptAddOptions::SharedPointer options(
            options_ptr); // this will ensure that we get rid of the pointer
                          // when going out of scope

        ScriptInterpreter *interpreter = GetDebugger().GetScriptInterpreter();
        if (interpreter) {
          std::string funct_name_str;
          if (interpreter->GenerateTypeScriptFunction(lines,
                                                      funct_name_str)) {
            if (funct_name_str.empty()) {
              error_sp->Printf("unable to obtain a valid function name from "
                               "the script interpreter.\n");
              error_sp->Flush();
            } else {
              // now I have a valid function name, let's add this as script
              // for every type in the list

              TypeSummaryImplSP script_format;
              script_format = std::make_shared<ScriptSummaryFormat>(
                  options->m_flags, funct_name_str.c_str(),
                  lines.CopyList("    ").c_str());

              Status error;

              for (const std::string &type_name : options->m_target_types) {
                CommandObjectTypeSummaryAdd::AddSummary(
                    ConstString(type_name), script_format,
                    (options->m_regex
                         ? CommandObjectTypeSummaryAdd::eRegexSummary
                         : CommandObjectTypeSummaryAdd::eRegularSummary),
                    options->m_category, &error);
                if (error.Fail()) {
                  error_sp->Printf("error: %s", error.AsCString());
                  error_sp->Flush();
                }
              }

              if (options->m_name) {
                CommandObjectTypeSummaryAdd::AddSummary(
                    options->m_name, script_format,
                    CommandObjectTypeSummaryAdd::eNamedSummary,
                    options->m_category, &error);
                if (error.Fail()) {
                  CommandObjectTypeSummaryAdd::AddSummary(
                      options->m_name, script_format,
                      CommandObjectTypeSummaryAdd::eNamedSummary,
                      options->m_category, &error);
                  if (error.Fail()) {
                    error_sp->Printf("error: %s", error.AsCString());
                    error_sp->Flush();
                  }
                } else {
                  error_sp->Printf("error: %s", error.AsCString());
                  error_sp->Flush();
                }
              } else {
                if (error.AsCString()) {
                  error_sp->Printf("error: %s", error.AsCString());
                  error_sp->Flush();
                }
              }
            }
          } else {
            error_sp->Printf("error: unable to generate a function.\n");
            error_sp->Flush();
          }
        } else {
          error_sp->Printf("error: no script interpreter.\n");
          error_sp->Flush();
        }
      } else {
        error_sp->Printf("error: internal synchronization information "
                         "missing or invalid.\n");
        error_sp->Flush();
      }
    } else {
      error_sp->Printf("error: empty function, didn't add python command.\n");
      error_sp->Flush();
    }
  } else {
    error_sp->Printf(
        "error: script interpreter missing, didn't add python command.\n");
    error_sp->Flush();
  }
258#endif
  io_handler.SetIsDone(true);
}

static bool AddSummary(ConstString type_name, lldb::TypeSummaryImplSP entry,
                       SummaryFormatType type, std::string category,
                       Status *error = nullptr);

266protected:
bool DoExecute(Args &command, CommandReturnObject &result) override;
268};

270static const char *g_synth_addreader_instructions =
  "Enter your Python command(s). Type 'DONE' to end.\n"
  "You must define a Python class with these methods:\n"
  "    def __init__(self, valobj, internal_dict):\n"
  "    def num_children(self):\n"
  "    def get_child_at_index(self, index):\n"
  "    def get_child_index(self, name):\n"
  "    def update(self):\n"
  "        '''Optional'''\n"
  "class synthProvider:\n";

281#define LLDB_OPTIONS_type_synth_add
282#include "CommandOptions.inc"

284class CommandObjectTypeSynthAdd : public CommandObjectParsed,
                                public IOHandlerDelegateMultiline {
286private:
class CommandOptions : public Options {
public:
  CommandOptions() {}

  ~CommandOptions() override = default;

  Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                        ExecutionContext *execution_context) override {
    Status error;
    const int short_option = m_getopt_table[option_idx].val;
    bool success;

    switch (short_option) {
    case 'C':
      m_cascade = OptionArgParser::ToBoolean(option_arg, true, &success);
      if (!success)
        error.SetErrorStringWithFormat("invalid value for cascade: %s",
                                       option_arg.str().c_str());
      break;
    case 'P':
      handwrite_python = true;
      break;
    case 'l':
      m_class_name = std::string(option_arg);
      is_class_based = true;
      break;
    case 'p':
      m_skip_pointers = true;
      break;
    case 'r':
      m_skip_references = true;
      break;
    case 'w':
      m_category = std::string(option_arg);
      break;
    case 'x':
      m_regex = true;
      break;
    default:
      llvm_unreachable("Unimplemented option")::llvm::llvm_unreachable_internal("Unimplemented option", "lldb/source/Commands/CommandObjectType.cpp"
, 326);
    }

    return error;
  }

  void OptionParsingStarting(ExecutionContext *execution_context) override {
    m_cascade = true;
    m_class_name = "";
    m_skip_pointers = false;
    m_skip_references = false;
    m_category = "default";
    is_class_based = false;
    handwrite_python = false;
    m_regex = false;
  }

  llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
    return llvm::makeArrayRef(g_type_synth_add_options);
  }

  // Instance variables to hold the values for command options.

  bool m_cascade;
  bool m_skip_references;
  bool m_skip_pointers;
  std::string m_class_name;
  bool m_input_python;
  std::string m_category;
  bool is_class_based;
  bool handwrite_python;
  bool m_regex;
};

CommandOptions m_options;

Options *GetOptions() override { return &m_options; }

bool Execute_HandwritePython(Args &command, CommandReturnObject &result);

bool Execute_PythonClass(Args &command, CommandReturnObject &result);

368protected:
bool DoExecute(Args &command, CommandReturnObject &result) override {
  WarnOnPotentialUnquotedUnsignedType(command, result);

  if (m_options.handwrite_python)
1
Assuming field 'handwrite_python' is true→
2
←
Taking true branch→
    return Execute_HandwritePython(command, result);
3
←
Calling 'CommandObjectTypeSynthAdd::Execute_HandwritePython'→
  else if (m_options.is_class_based)
    return Execute_PythonClass(command, result);
  else {
    result.AppendError("must either provide a children list, a Python class "
                       "name, or use -P and type a Python class "
                       "line-by-line");
    return false;
  }
}

void IOHandlerActivated(IOHandler &io_handler, bool interactive) override {
  StreamFileSP output_sp(io_handler.GetOutputStreamFileSP());
  if (output_sp && interactive) {
    output_sp->PutCString(g_synth_addreader_instructions);
    output_sp->Flush();
  }
}

void IOHandlerInputComplete(IOHandler &io_handler,
                            std::string &data) override {
  StreamFileSP error_sp = io_handler.GetErrorStreamFileSP();

396#if LLDB_ENABLE_PYTHON1
  ScriptInterpreter *interpreter = GetDebugger().GetScriptInterpreter();
  if (interpreter) {
    StringList lines;
    lines.SplitIntoLines(data);
    if (lines.GetSize() > 0) {
      SynthAddOptions *options_ptr =
          ((SynthAddOptions *)io_handler.GetUserData());
      if (options_ptr) {
        SynthAddOptions::SharedPointer options(
            options_ptr); // this will ensure that we get rid of the pointer
                          // when going out of scope

        ScriptInterpreter *interpreter = GetDebugger().GetScriptInterpreter();
        if (interpreter) {
          std::string class_name_str;
          if (interpreter->GenerateTypeSynthClass(lines, class_name_str)) {
            if (class_name_str.empty()) {
              error_sp->Printf(
                  "error: unable to obtain a proper name for the class.\n");
              error_sp->Flush();
            } else {
              // everything should be fine now, let's add the synth provider
              // class

              SyntheticChildrenSP synth_provider;
              synth_provider = std::make_shared<ScriptedSyntheticChildren>(
                  SyntheticChildren::Flags()
                      .SetCascades(options->m_cascade)
                      .SetSkipPointers(options->m_skip_pointers)
                      .SetSkipReferences(options->m_skip_references),
                  class_name_str.c_str());

              lldb::TypeCategoryImplSP category;
              DataVisualization::Categories::GetCategory(
                  ConstString(options->m_category.c_str()), category);

              Status error;

              for (const std::string &type_name : options->m_target_types) {
                if (!type_name.empty()) {
                  if (!CommandObjectTypeSynthAdd::AddSynth(
                          ConstString(type_name), synth_provider,
                          options->m_regex
                              ? CommandObjectTypeSynthAdd::eRegexSynth
                              : CommandObjectTypeSynthAdd::eRegularSynth,
                          options->m_category, &error)) {
                    error_sp->Printf("error: %s\n", error.AsCString());
                    error_sp->Flush();
                    break;
                  }
                } else {
                  error_sp->Printf("error: invalid type name.\n");
                  error_sp->Flush();
                  break;
                }
              }
            }
          } else {
            error_sp->Printf("error: unable to generate a class.\n");
            error_sp->Flush();
          }
        } else {
          error_sp->Printf("error: no script interpreter.\n");
          error_sp->Flush();
        }
      } else {
        error_sp->Printf("error: internal synchronization data missing.\n");
        error_sp->Flush();
      }
    } else {
      error_sp->Printf("error: empty function, didn't add python command.\n");
      error_sp->Flush();
    }
  } else {
    error_sp->Printf(
        "error: script interpreter missing, didn't add python command.\n");
    error_sp->Flush();
  }

476#endif
  io_handler.SetIsDone(true);
}

480public:
enum SynthFormatType { eRegularSynth, eRegexSynth };

CommandObjectTypeSynthAdd(CommandInterpreter &interpreter);

~CommandObjectTypeSynthAdd() override = default;

static bool AddSynth(ConstString type_name, lldb::SyntheticChildrenSP entry,
                     SynthFormatType type, std::string category_name,
                     Status *error);
490};

492// CommandObjectTypeFormatAdd

494#define LLDB_OPTIONS_type_format_add
495#include "CommandOptions.inc"

497class CommandObjectTypeFormatAdd : public CommandObjectParsed {
498private:
class CommandOptions : public OptionGroup {
public:
  CommandOptions() {}

  ~CommandOptions() override = default;

  llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
    return llvm::makeArrayRef(g_type_format_add_options);
  }

  void OptionParsingStarting(ExecutionContext *execution_context) override {
    m_cascade = true;
    m_skip_pointers = false;
    m_skip_references = false;
    m_regex = false;
    m_category.assign("default");
    m_custom_type_name.clear();
  }

  Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
                        ExecutionContext *execution_context) override {
    Status error;
    const int short_option =
        g_type_format_add_options[option_idx].short_option;
    bool success;

    switch (short_option) {
    case 'C':
      m_cascade = OptionArgParser::ToBoolean(option_value, true, &success);
      if (!success)
        error.SetErrorStringWithFormat("invalid value for cascade: %s",
                                       option_value.str().c_str());
      break;
    case 'p':
      m_skip_pointers = true;
      break;
    case 'w':
      m_category.assign(std::string(option_value));
      break;
    case 'r':
      m_skip_references = true;
      break;
    case 'x':
      m_regex = true;
      break;
    case 't':
      m_custom_type_name.assign(std::string(option_value));
      break;
    default:
      llvm_unreachable("Unimplemented option")::llvm::llvm_unreachable_internal("Unimplemented option", "lldb/source/Commands/CommandObjectType.cpp"
, 548);
    }

    return error;
  }

  // Instance variables to hold the values for command options.

  bool m_cascade;
  bool m_skip_references;
  bool m_skip_pointers;
  bool m_regex;
  std::string m_category;
  std::string m_custom_type_name;
};

OptionGroupOptions m_option_group;
OptionGroupFormat m_format_options;
CommandOptions m_command_options;

Options *GetOptions() override { return &m_option_group; }

570public:
CommandObjectTypeFormatAdd(CommandInterpreter &interpreter)
    : CommandObjectParsed(interpreter, "type format add",
                          "Add a new formatting style for a type.", nullptr),
      m_format_options(eFormatInvalid) {
  CommandArgumentEntry type_arg;
  CommandArgumentData type_style_arg;

  type_style_arg.arg_type = eArgTypeName;
  type_style_arg.arg_repetition = eArgRepeatPlus;

  type_arg.push_back(type_style_arg);

  m_arguments.push_back(type_arg);

  SetHelpLong(
      R"(
587The following examples of 'type format add' refer to this code snippet for context:

  typedef int Aint;
  typedef float Afloat;
  typedef Aint Bint;
  typedef Afloat Bfloat;

  Aint ix = 5;
  Bint iy = 5;

  Afloat fx = 3.14;
  BFloat fy = 3.14;

600Adding default formatting:

602(lldb) type format add -f hex AInt
603(lldb) frame variable iy

605)"
      "    Produces hexadecimal display of iy, because no formatter is available for Bint and \
607the one for Aint is used instead."
      R"(

610To prevent this use the cascade option '-C no' to prevent evaluation of typedef chains:


613(lldb) type format add -f hex -C no AInt

615Similar reasoning applies to this:

617(lldb) type format add -f hex -C no float -p

619)"
      "    All float values and float references are now formatted as hexadecimal, but not \
621pointers to floats.  Nor will it change the default display for Afloat and Bfloat objects.");

  // Add the "--format" to all options groups
  m_option_group.Append(&m_format_options,
                        OptionGroupFormat::OPTION_GROUP_FORMAT,
                        LLDB_OPT_SET_1(1U << 0));
  m_option_group.Append(&m_command_options);
  m_option_group.Finalize();
}

~CommandObjectTypeFormatAdd() override = default;

633protected:
bool DoExecute(Args &command, CommandReturnObject &result) override {
  const size_t argc = command.GetArgumentCount();

  if (argc < 1) {
    result.AppendErrorWithFormat("%s takes one or more args.\n",
                                 m_cmd_name.c_str());
    return false;
  }

  const Format format = m_format_options.GetFormat();
  if (format == eFormatInvalid &&
      m_command_options.m_custom_type_name.empty()) {
    result.AppendErrorWithFormat("%s needs a valid format.\n",
                                 m_cmd_name.c_str());
    return false;
  }

  TypeFormatImplSP entry;

  if (m_command_options.m_custom_type_name.empty())
    entry = std::make_shared<TypeFormatImpl_Format>(
        format, TypeFormatImpl::Flags()
                    .SetCascades(m_command_options.m_cascade)
                    .SetSkipPointers(m_command_options.m_skip_pointers)
                    .SetSkipReferences(m_command_options.m_skip_references));
  else
    entry = std::make_shared<TypeFormatImpl_EnumType>(
        ConstString(m_command_options.m_custom_type_name.c_str()),
        TypeFormatImpl::Flags()
            .SetCascades(m_command_options.m_cascade)
            .SetSkipPointers(m_command_options.m_skip_pointers)
            .SetSkipReferences(m_command_options.m_skip_references));

  // now I have a valid format, let's add it to every type

  TypeCategoryImplSP category_sp;
  DataVisualization::Categories::GetCategory(
      ConstString(m_command_options.m_category), category_sp);
  if (!category_sp)
    return false;

  WarnOnPotentialUnquotedUnsignedType(command, result);

  for (auto &arg_entry : command.entries()) {
    if (arg_entry.ref().empty()) {
      result.AppendError("empty typenames not allowed");
      return false;
    }

    ConstString typeCS(arg_entry.ref());
    if (m_command_options.m_regex) {
      RegularExpression typeRX(arg_entry.ref());
      if (!typeRX.IsValid()) {
        result.AppendError(
            "regex format error (maybe this is not really a regex?)");
        return false;
      }
      category_sp->GetRegexTypeSummariesContainer()->Delete(typeCS);
      category_sp->GetRegexTypeFormatsContainer()->Add(std::move(typeRX),
                                                       entry);
    } else
      category_sp->GetTypeFormatsContainer()->Add(std::move(typeCS), entry);
  }

  result.SetStatus(eReturnStatusSuccessFinishNoResult);
  return result.Succeeded();
}
701};

703#define LLDB_OPTIONS_type_formatter_delete
704#include "CommandOptions.inc"

706class CommandObjectTypeFormatterDelete : public CommandObjectParsed {
707protected:
class CommandOptions : public Options {
public:
  CommandOptions() {}

  ~CommandOptions() override = default;

  Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                        ExecutionContext *execution_context) override {
    Status error;
    const int short_option = m_getopt_table[option_idx].val;

    switch (short_option) {
    case 'a':
      m_delete_all = true;
      break;
    case 'w':
      m_category = std::string(option_arg);
      break;
    case 'l':
      m_language = Language::GetLanguageTypeFromString(option_arg);
      break;
    default:
      llvm_unreachable("Unimplemented option")::llvm::llvm_unreachable_internal("Unimplemented option", "lldb/source/Commands/CommandObjectType.cpp"
, 730);
    }

    return error;
  }

  void OptionParsingStarting(ExecutionContext *execution_context) override {
    m_delete_all = false;
    m_category = "default";
    m_language = lldb::eLanguageTypeUnknown;
  }

  llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
    return llvm::makeArrayRef(g_type_formatter_delete_options);
  }

  // Instance variables to hold the values for command options.

  bool m_delete_all;
  std::string m_category;
  lldb::LanguageType m_language;
};

CommandOptions m_options;
uint32_t m_formatter_kind_mask;

Options *GetOptions() override { return &m_options; }

758public:
CommandObjectTypeFormatterDelete(CommandInterpreter &interpreter,
                                 uint32_t formatter_kind_mask,
                                 const char *name, const char *help)
    : CommandObjectParsed(interpreter, name, help, nullptr),
      m_formatter_kind_mask(formatter_kind_mask) {
  CommandArgumentEntry type_arg;
  CommandArgumentData type_style_arg;

  type_style_arg.arg_type = eArgTypeName;
  type_style_arg.arg_repetition = eArgRepeatPlain;

  type_arg.push_back(type_style_arg);

  m_arguments.push_back(type_arg);
}

~CommandObjectTypeFormatterDelete() override = default;

void
HandleArgumentCompletion(CompletionRequest &request,
                         OptionElementVector &opt_element_vector) override {
  if (request.GetCursorIndex())
    return;

  DataVisualization::Categories::ForEach(
      [this, &request](const lldb::TypeCategoryImplSP &category_sp) {
        if (CHECK_FORMATTER_KIND_MASK(eFormatCategoryItemValue)((m_formatter_kind_mask & (eFormatCategoryItemValue)) == (
eFormatCategoryItemValue)))
          category_sp->GetTypeFormatsContainer()->AutoComplete(request);
        if (CHECK_FORMATTER_KIND_MASK(eFormatCategoryItemRegexValue)((m_formatter_kind_mask & (eFormatCategoryItemRegexValue)
) == (eFormatCategoryItemRegexValue)))
          category_sp->GetRegexTypeFormatsContainer()->AutoComplete(request);

        if (CHECK_FORMATTER_KIND_MASK(eFormatCategoryItemSummary)((m_formatter_kind_mask & (eFormatCategoryItemSummary)) ==
 (eFormatCategoryItemSummary)))
          category_sp->GetTypeSummariesContainer()->AutoComplete(request);
        if (CHECK_FORMATTER_KIND_MASK(eFormatCategoryItemRegexSummary)((m_formatter_kind_mask & (eFormatCategoryItemRegexSummary
)) == (eFormatCategoryItemRegexSummary)))
          category_sp->GetRegexTypeSummariesContainer()->AutoComplete(
              request);

        if (CHECK_FORMATTER_KIND_MASK(eFormatCategoryItemFilter)((m_formatter_kind_mask & (eFormatCategoryItemFilter)) ==
 (eFormatCategoryItemFilter)))
          category_sp->GetTypeFiltersContainer()->AutoComplete(request);
        if (CHECK_FORMATTER_KIND_MASK(eFormatCategoryItemRegexFilter)((m_formatter_kind_mask & (eFormatCategoryItemRegexFilter
)) == (eFormatCategoryItemRegexFilter)))
          category_sp->GetRegexTypeFiltersContainer()->AutoComplete(request);

        if (CHECK_FORMATTER_KIND_MASK(eFormatCategoryItemSynth)((m_formatter_kind_mask & (eFormatCategoryItemSynth)) == (
eFormatCategoryItemSynth)))
          category_sp->GetTypeSyntheticsContainer()->AutoComplete(request);
        if (CHECK_FORMATTER_KIND_MASK(eFormatCategoryItemRegexSynth)((m_formatter_kind_mask & (eFormatCategoryItemRegexSynth)
) == (eFormatCategoryItemRegexSynth)))
          category_sp->GetRegexTypeSyntheticsContainer()->AutoComplete(
              request);
        return true;
      });
}

810protected:
virtual bool FormatterSpecificDeletion(ConstString typeCS) { return false; }

bool DoExecute(Args &command, CommandReturnObject &result) override {
  const size_t argc = command.GetArgumentCount();

  if (argc != 1) {
    result.AppendErrorWithFormat("%s takes 1 arg.\n", m_cmd_name.c_str());
    return false;
  }

  const char *typeA = command.GetArgumentAtIndex(0);
  ConstString typeCS(typeA);

  if (!typeCS) {
    result.AppendError("empty typenames not allowed");
    return false;
  }

  if (m_options.m_delete_all) {
    DataVisualization::Categories::ForEach(
        [this, typeCS](const lldb::TypeCategoryImplSP &category_sp) -> bool {
          category_sp->Delete(typeCS, m_formatter_kind_mask);
          return true;
        });
    result.SetStatus(eReturnStatusSuccessFinishNoResult);
    return result.Succeeded();
  }

  bool delete_category = false;
  bool extra_deletion = false;

  if (m_options.m_language != lldb::eLanguageTypeUnknown) {
    lldb::TypeCategoryImplSP category;
    DataVisualization::Categories::GetCategory(m_options.m_language,
                                               category);
    if (category)
      delete_category = category->Delete(typeCS, m_formatter_kind_mask);
    extra_deletion = FormatterSpecificDeletion(typeCS);
  } else {
    lldb::TypeCategoryImplSP category;
    DataVisualization::Categories::GetCategory(
        ConstString(m_options.m_category.c_str()), category);
    if (category)
      delete_category = category->Delete(typeCS, m_formatter_kind_mask);
    extra_deletion = FormatterSpecificDeletion(typeCS);
  }

  if (delete_category || extra_deletion) {
    result.SetStatus(eReturnStatusSuccessFinishNoResult);
    return result.Succeeded();
  } else {
    result.AppendErrorWithFormat("no custom formatter for %s.\n", typeA);
    return false;
  }
}
866};

868#define LLDB_OPTIONS_type_formatter_clear
869#include "CommandOptions.inc"

871class CommandObjectTypeFormatterClear : public CommandObjectParsed {
872private:
class CommandOptions : public Options {
public:
  CommandOptions() {}

  ~CommandOptions() override = default;

  Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                        ExecutionContext *execution_context) override {
    Status error;
    const int short_option = m_getopt_table[option_idx].val;

    switch (short_option) {
    case 'a':
      m_delete_all = true;
      break;
    default:
      llvm_unreachable("Unimplemented option")::llvm::llvm_unreachable_internal("Unimplemented option", "lldb/source/Commands/CommandObjectType.cpp"
, 889);
    }

    return error;
  }

  void OptionParsingStarting(ExecutionContext *execution_context) override {
    m_delete_all = false;
  }

  llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
    return llvm::makeArrayRef(g_type_formatter_clear_options);
  }

  // Instance variables to hold the values for command options.
  bool m_delete_all;
};

CommandOptions m_options;
uint32_t m_formatter_kind_mask;

Options *GetOptions() override { return &m_options; }

912public:
CommandObjectTypeFormatterClear(CommandInterpreter &interpreter,
                                uint32_t formatter_kind_mask,
                                const char *name, const char *help)
    : CommandObjectParsed(interpreter, name, help, nullptr),
      m_formatter_kind_mask(formatter_kind_mask) {}

~CommandObjectTypeFormatterClear() override = default;

921protected:
virtual void FormatterSpecificDeletion() {}

bool DoExecute(Args &command, CommandReturnObject &result) override {
  if (m_options.m_delete_all) {
    DataVisualization::Categories::ForEach(
        [this](const TypeCategoryImplSP &category_sp) -> bool {
          category_sp->Clear(m_formatter_kind_mask);
          return true;
        });
  } else {
    lldb::TypeCategoryImplSP category;
    if (command.GetArgumentCount() > 0) {
      const char *cat_name = command.GetArgumentAtIndex(0);
      ConstString cat_nameCS(cat_name);
      DataVisualization::Categories::GetCategory(cat_nameCS, category);
    } else {
      DataVisualization::Categories::GetCategory(ConstString(nullptr),
                                                 category);
    }
    category->Clear(m_formatter_kind_mask);
  }

  FormatterSpecificDeletion();

  result.SetStatus(eReturnStatusSuccessFinishResult);
  return result.Succeeded();
}
949};

951// CommandObjectTypeFormatDelete

953class CommandObjectTypeFormatDelete : public CommandObjectTypeFormatterDelete {
954public:
CommandObjectTypeFormatDelete(CommandInterpreter &interpreter)
    : CommandObjectTypeFormatterDelete(
          interpreter,
          eFormatCategoryItemValue | eFormatCategoryItemRegexValue,
          "type format delete",
          "Delete an existing formatting style for a type.") {}

~CommandObjectTypeFormatDelete() override = default;
963};

965// CommandObjectTypeFormatClear

967class CommandObjectTypeFormatClear : public CommandObjectTypeFormatterClear {
968public:
CommandObjectTypeFormatClear(CommandInterpreter &interpreter)
    : CommandObjectTypeFormatterClear(
          interpreter,
          eFormatCategoryItemValue | eFormatCategoryItemRegexValue,
          "type format clear", "Delete all existing format styles.") {}
974};

976#define LLDB_OPTIONS_type_formatter_list
977#include "CommandOptions.inc"

979template <typename FormatterType>
980class CommandObjectTypeFormatterList : public CommandObjectParsed {
typedef typename FormatterType::SharedPointer FormatterSharedPointer;

class CommandOptions : public Options {
public:
  CommandOptions()
      : Options(), m_category_regex("", ""),
        m_category_language(lldb::eLanguageTypeUnknown,
                            lldb::eLanguageTypeUnknown) {}

  ~CommandOptions() override = default;

  Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                        ExecutionContext *execution_context) override {
    Status error;
    const int short_option = m_getopt_table[option_idx].val;
    switch (short_option) {
    case 'w':
      m_category_regex.SetCurrentValue(option_arg);
      m_category_regex.SetOptionWasSet();
      break;
    case 'l':
      error = m_category_language.SetValueFromString(option_arg);
      if (error.Success())
        m_category_language.SetOptionWasSet();
      break;
    default:
      llvm_unreachable("Unimplemented option")::llvm::llvm_unreachable_internal("Unimplemented option", "lldb/source/Commands/CommandObjectType.cpp"
, 1007);
    }

    return error;
  }

  void OptionParsingStarting(ExecutionContext *execution_context) override {
    m_category_regex.Clear();
    m_category_language.Clear();
  }

  llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
    return llvm::makeArrayRef(g_type_formatter_list_options);
  }

  // Instance variables to hold the values for command options.

  OptionValueString m_category_regex;
  OptionValueLanguage m_category_language;
};

CommandOptions m_options;

Options *GetOptions() override { return &m_options; }

1032public:
CommandObjectTypeFormatterList(CommandInterpreter &interpreter,
                               const char *name, const char *help)
    : CommandObjectParsed(interpreter, name, help, nullptr), m_options() {
  CommandArgumentEntry type_arg;
  CommandArgumentData type_style_arg;

  type_style_arg.arg_type = eArgTypeName;
  type_style_arg.arg_repetition = eArgRepeatOptional;

  type_arg.push_back(type_style_arg);

  m_arguments.push_back(type_arg);
}

~CommandObjectTypeFormatterList() override = default;

1049protected:
virtual bool FormatterSpecificList(CommandReturnObject &result) {
  return false;
}

bool DoExecute(Args &command, CommandReturnObject &result) override {
  const size_t argc = command.GetArgumentCount();

  std::unique_ptr<RegularExpression> category_regex;
  std::unique_ptr<RegularExpression> formatter_regex;

  if (m_options.m_category_regex.OptionWasSet()) {
    category_regex = std::make_unique<RegularExpression>(
        m_options.m_category_regex.GetCurrentValueAsRef());
    if (!category_regex->IsValid()) {
      result.AppendErrorWithFormat(
          "syntax error in category regular expression '%s'",
          m_options.m_category_regex.GetCurrentValueAsRef().str().c_str());
      return false;
    }
  }

  if (argc == 1) {
    const char *arg = command.GetArgumentAtIndex(0);
    formatter_regex = std::make_unique<RegularExpression>(arg);
    if (!formatter_regex->IsValid()) {
      result.AppendErrorWithFormat("syntax error in regular expression '%s'",
                                   arg);
      return false;
    }
  }

  bool any_printed = false;

  auto category_closure =
      [&result, &formatter_regex,
       &any_printed](const lldb::TypeCategoryImplSP &category) -> void {
    result.GetOutputStream().Printf(
        "-----------------------\nCategory: %s%s\n-----------------------\n",
        category->GetName(), category->IsEnabled() ? "" : " (disabled)");

    TypeCategoryImpl::ForEachCallbacks<FormatterType> foreach;
    foreach
      .SetExact([&result, &formatter_regex, &any_printed](
                    const TypeMatcher &type_matcher,
                    const FormatterSharedPointer &format_sp) -> bool {
        if (formatter_regex) {
          bool escape = true;
          if (type_matcher.CreatedBySameMatchString(
                  ConstString(formatter_regex->GetText()))) {
            escape = false;
          } else if (formatter_regex->Execute(
                         type_matcher.GetMatchString().GetStringRef())) {
            escape = false;
          }

          if (escape)
            return true;
        }

        any_printed = true;
        result.GetOutputStream().Printf(
            "%s: %s\n", type_matcher.GetMatchString().GetCString(),
            format_sp->GetDescription().c_str());
        return true;
      });

    foreach
      .SetWithRegex([&result, &formatter_regex, &any_printed](
                        const TypeMatcher &type_matcher,
                        const FormatterSharedPointer &format_sp) -> bool {
        if (formatter_regex) {
          bool escape = true;
          if (type_matcher.CreatedBySameMatchString(
                  ConstString(formatter_regex->GetText()))) {
            escape = false;
          } else if (formatter_regex->Execute(
                         type_matcher.GetMatchString().GetStringRef())) {
            escape = false;
          }

          if (escape)
            return true;
        }

        any_printed = true;
        result.GetOutputStream().Printf(
            "%s: %s\n", type_matcher.GetMatchString().GetCString(),
            format_sp->GetDescription().c_str());
        return true;
      });

    category->ForEach(foreach);
  };

  if (m_options.m_category_language.OptionWasSet()) {
    lldb::TypeCategoryImplSP category_sp;
    DataVisualization::Categories::GetCategory(
        m_options.m_category_language.GetCurrentValue(), category_sp);
    if (category_sp)
      category_closure(category_sp);
  } else {
    DataVisualization::Categories::ForEach(
        [&category_regex, &category_closure](
            const lldb::TypeCategoryImplSP &category) -> bool {
          if (category_regex) {
            bool escape = true;
            if (category->GetName() == category_regex->GetText()) {
              escape = false;
            } else if (category_regex->Execute(category->GetName())) {
              escape = false;
            }

            if (escape)
              return true;
          }

          category_closure(category);

          return true;
        });

    any_printed = FormatterSpecificList(result) | any_printed;
  }

  if (any_printed)
    result.SetStatus(eReturnStatusSuccessFinishResult);
  else {
    result.GetOutputStream().PutCString("no matching results found.\n");
    result.SetStatus(eReturnStatusSuccessFinishNoResult);
  }
  return result.Succeeded();
}
1182};

1184// CommandObjectTypeFormatList

1186class CommandObjectTypeFormatList
  : public CommandObjectTypeFormatterList<TypeFormatImpl> {
1188public:
CommandObjectTypeFormatList(CommandInterpreter &interpreter)
    : CommandObjectTypeFormatterList(interpreter, "type format list",
                                     "Show a list of current formats.") {}
1192};

1194Status CommandObjectTypeSummaryAdd::CommandOptions::SetOptionValue(
  uint32_t option_idx, llvm::StringRef option_arg,
  ExecutionContext *execution_context) {
Status error;
const int short_option = m_getopt_table[option_idx].val;
bool success;

switch (short_option) {
case 'C':
  m_flags.SetCascades(OptionArgParser::ToBoolean(option_arg, true, &success));
  if (!success)
    error.SetErrorStringWithFormat("invalid value for cascade: %s",
                                   option_arg.str().c_str());
  break;
case 'e':
  m_flags.SetDontShowChildren(false);
  break;
case 'h':
  m_flags.SetHideEmptyAggregates(true);
  break;
case 'v':
  m_flags.SetDontShowValue(true);
  break;
case 'c':
  m_flags.SetShowMembersOneLiner(true);
  break;
case 's':
  m_format_string = std::string(option_arg);
  break;
case 'p':
  m_flags.SetSkipPointers(true);
  break;
case 'r':
  m_flags.SetSkipReferences(true);
  break;
case 'x':
  m_regex = true;
  break;
case 'n':
  m_name.SetString(option_arg);
  break;
case 'o':
  m_python_script = std::string(option_arg);
  m_is_add_script = true;
  break;
case 'F':
  m_python_function = std::string(option_arg);
  m_is_add_script = true;
  break;
case 'P':
  m_is_add_script = true;
  break;
case 'w':
  m_category = std::string(option_arg);
  break;
case 'O':
  m_flags.SetHideItemNames(true);
  break;
default:
  llvm_unreachable("Unimplemented option")::llvm::llvm_unreachable_internal("Unimplemented option", "lldb/source/Commands/CommandObjectType.cpp"
, 1253);
}

return error;
1257}

1259void CommandObjectTypeSummaryAdd::CommandOptions::OptionParsingStarting(
  ExecutionContext *execution_context) {
m_flags.Clear().SetCascades().SetDontShowChildren().SetDontShowValue(false);
m_flags.SetShowMembersOneLiner(false)
    .SetSkipPointers(false)
    .SetSkipReferences(false)
    .SetHideItemNames(false);

m_regex = false;
m_name.Clear();
m_python_script = "";
m_python_function = "";
m_format_string = "";
m_is_add_script = false;
m_category = "default";
1274}

1276#if LLDB_ENABLE_PYTHON1

1278bool CommandObjectTypeSummaryAdd::Execute_ScriptSummary(
  Args &command, CommandReturnObject &result) {
const size_t argc = command.GetArgumentCount();

if (argc < 1 && !m_options.m_name) {
  result.AppendErrorWithFormat("%s takes one or more args.\n",
                               m_cmd_name.c_str());
  return false;
}

TypeSummaryImplSP script_format;

if (!m_options.m_python_function
         .empty()) // we have a Python function ready to use
{
  const char *funct_name = m_options.m_python_function.c_str();
  if (!funct_name || !funct_name[0]) {
    result.AppendError("function name empty.\n");
    return false;
  }

  std::string code =
      ("    " + m_options.m_python_function + "(valobj,internal_dict)");

  script_format = std::make_shared<ScriptSummaryFormat>(
      m_options.m_flags, funct_name, code.c_str());

  ScriptInterpreter *interpreter = GetDebugger().GetScriptInterpreter();

  if (interpreter && !interpreter->CheckObjectExists(funct_name))
    result.AppendWarningWithFormat(
        "The provided function \"%s\" does not exist - "
        "please define it before attempting to use this summary.\n",
        funct_name);
} else if (!m_options.m_python_script
                .empty()) // we have a quick 1-line script, just use it
{
  ScriptInterpreter *interpreter = GetDebugger().GetScriptInterpreter();
  if (!interpreter) {
    result.AppendError("script interpreter missing - unable to generate "
                       "function wrapper.\n");
    return false;
  }
  StringList funct_sl;
  funct_sl << m_options.m_python_script.c_str();
  std::string funct_name_str;
  if (!interpreter->GenerateTypeScriptFunction(funct_sl, funct_name_str)) {
    result.AppendError("unable to generate function wrapper.\n");
    return false;
  }
  if (funct_name_str.empty()) {
    result.AppendError(
        "script interpreter failed to generate a valid function name.\n");
    return false;
  }

  std::string code = "    " + m_options.m_python_script;

  script_format = std::make_shared<ScriptSummaryFormat>(
      m_options.m_flags, funct_name_str.c_str(), code.c_str());
} else {
  // Use an IOHandler to grab Python code from the user
  ScriptAddOptions *options =
      new ScriptAddOptions(m_options.m_flags, m_options.m_regex,
                           m_options.m_name, m_options.m_category);

  for (auto &entry : command.entries()) {
    if (entry.ref().empty()) {
      result.AppendError("empty typenames not allowed");
      return false;
    }

    options->m_target_types << std::string(entry.ref());
  }

  m_interpreter.GetPythonCommandsFromIOHandler(
      "    ",   // Prompt
      *this,    // IOHandlerDelegate
      options); // Baton for the "io_handler" that will be passed back into
                // our IOHandlerDelegate functions
  result.SetStatus(eReturnStatusSuccessFinishNoResult);

  return result.Succeeded();
}

// if I am here, script_format must point to something good, so I can add
// that as a script summary to all interested parties

Status error;

for (auto &entry : command.entries()) {
  CommandObjectTypeSummaryAdd::AddSummary(
      ConstString(entry.ref()), script_format,
      (m_options.m_regex ? eRegexSummary : eRegularSummary),
      m_options.m_category, &error);
  if (error.Fail()) {
    result.AppendError(error.AsCString());
    return false;
  }
}

if (m_options.m_name) {
  AddSummary(m_options.m_name, script_format, eNamedSummary,
             m_options.m_category, &error);
  if (error.Fail()) {
    result.AppendError(error.AsCString());
    result.AppendError("added to types, but not given a name");
    return false;
  }
}

return result.Succeeded();
1390}

1392#endif

1394bool CommandObjectTypeSummaryAdd::Execute_StringSummary(
  Args &command, CommandReturnObject &result) {
const size_t argc = command.GetArgumentCount();

if (argc < 1 && !m_options.m_name) {
  result.AppendErrorWithFormat("%s takes one or more args.\n",
                               m_cmd_name.c_str());
  return false;
}

if (!m_options.m_flags.GetShowMembersOneLiner() &&
    m_options.m_format_string.empty()) {
  result.AppendError("empty summary strings not allowed");
  return false;
}

const char *format_cstr = (m_options.m_flags.GetShowMembersOneLiner()
                               ? ""
                               : m_options.m_format_string.c_str());

// ${var%S} is an endless recursion, prevent it
if (strcmp(format_cstr, "${var%S}") == 0) {
  result.AppendError("recursive summary not allowed");
  return false;
}

std::unique_ptr<StringSummaryFormat> string_format(
    new StringSummaryFormat(m_options.m_flags, format_cstr));
if (!string_format) {
  result.AppendError("summary creation failed");
  return false;
}
if (string_format->m_error.Fail()) {
  result.AppendErrorWithFormat("syntax error: %s",
                               string_format->m_error.AsCString("<unknown>"));
  return false;
}
lldb::TypeSummaryImplSP entry(string_format.release());

// now I have a valid format, let's add it to every type
Status error;
for (auto &arg_entry : command.entries()) {
  if (arg_entry.ref().empty()) {
    result.AppendError("empty typenames not allowed");
    return false;
  }
  ConstString typeCS(arg_entry.ref());

  AddSummary(typeCS, entry,
             (m_options.m_regex ? eRegexSummary : eRegularSummary),
             m_options.m_category, &error);

  if (error.Fail()) {
    result.AppendError(error.AsCString());
    return false;
  }
}

if (m_options.m_name) {
  AddSummary(m_options.m_name, entry, eNamedSummary, m_options.m_category,
             &error);
  if (error.Fail()) {
    result.AppendError(error.AsCString());
    result.AppendError("added to types, but not given a name");
    return false;
  }
}

result.SetStatus(eReturnStatusSuccessFinishNoResult);
return result.Succeeded();
1464}

1466CommandObjectTypeSummaryAdd::CommandObjectTypeSummaryAdd(
  CommandInterpreter &interpreter)
  : CommandObjectParsed(interpreter, "type summary add",
                        "Add a new summary style for a type.", nullptr),
    IOHandlerDelegateMultiline("DONE"), m_options(interpreter) {
CommandArgumentEntry type_arg;
CommandArgumentData type_style_arg;

type_style_arg.arg_type = eArgTypeName;
type_style_arg.arg_repetition = eArgRepeatPlus;

type_arg.push_back(type_style_arg);

m_arguments.push_back(type_arg);

SetHelpLong(
    R"(
1483The following examples of 'type summary add' refer to this code snippet for context:

  struct JustADemo
  {
      int* ptr;
      float value;
      JustADemo(int p = 1, float v = 0.1) : ptr(new int(p)), value(v) {}
  };
  JustADemo demo_instance(42, 3.14);

  typedef JustADemo NewDemo;
  NewDemo new_demo_instance(42, 3.14);

1496(lldb) type summary add --summary-string "the answer is ${*var.ptr}" JustADemo

  Subsequently displaying demo_instance with 'frame variable' or 'expression' will display "the answer is 42"

1500(lldb) type summary add --summary-string "the answer is ${*var.ptr}, and the question is ${var.value}" JustADemo

  Subsequently displaying demo_instance with 'frame variable' or 'expression' will display "the answer is 42 and the question is 3.14"

1504)"
    "Alternatively, you could define formatting for all pointers to integers and \
1506rely on that when formatting JustADemo to obtain the same result:"
    R"(

1509(lldb) type summary add --summary-string "${var%V} -> ${*var}" "int *"
1510(lldb) type summary add --summary-string "the answer is ${var.ptr}, and the question is ${var.value}" JustADemo

1512)"
    "Type summaries are automatically applied to derived typedefs, so the examples \
1514above apply to both JustADemo and NewDemo.  The cascade option can be used to \
1515suppress this behavior:"
    R"(

1518(lldb) type summary add --summary-string "${var.ptr}, ${var.value},{${var.byte}}" JustADemo -C no

  The summary will now be used for values of JustADemo but not NewDemo.

1522)"
    "By default summaries are shown for pointers and references to values of the \
1524specified type.  To suppress formatting for pointers use the -p option, or apply \
1525the corresponding -r option to suppress formatting for references:"
    R"(

1528(lldb) type summary add -p -r --summary-string "${var.ptr}, ${var.value},{${var.byte}}" JustADemo

1530)"
    "One-line summaries including all fields in a type can be inferred without supplying an \
1532explicit summary string by passing the -c option:"
    R"(

1535(lldb) type summary add -c JustADemo
1536(lldb) frame variable demo_instance
1537(ptr=<address>, value=3.14)

1539)"
    "Type summaries normally suppress the nested display of individual fields.  To \
1541supply a summary to supplement the default structure add the -e option:"
    R"(

1544(lldb) type summary add -e --summary-string "*ptr = ${*var.ptr}" JustADemo

1546)"
    "Now when displaying JustADemo values the int* is displayed, followed by the \
1548standard LLDB sequence of children, one per line:"
    R"(

1551*ptr = 42 {
ptr = <address>
value = 3.14
1554}

1556)"
    "You can also add summaries written in Python.  These scripts use lldb public API to \
1558gather information from your variables and produce a meaningful summary.  To start a \
1559multi-line script use the -P option.  The function declaration will be displayed along with \
1560a comment describing the two arguments.  End your script with the  word 'DONE' on a line by \
1561itself:"
    R"(

1564(lldb) type summary add JustADemo -P
1565def function (valobj,internal_dict):
1566"""valobj: an SBValue which you want to provide a summary for
1567internal_dict: an LLDB support object not to be used"""
  value = valobj.GetChildMemberWithName('value');
  return 'My value is ' + value.GetValue();
  DONE

1572Alternatively, the -o option can be used when providing a simple one-line Python script:

1574(lldb) type summary add JustADemo -o "value = valobj.GetChildMemberWithName('value'); return 'My value is ' + value.GetValue();")");
1575}

1577bool CommandObjectTypeSummaryAdd::DoExecute(Args &command,
                                          CommandReturnObject &result) {
WarnOnPotentialUnquotedUnsignedType(command, result);

if (m_options.m_is_add_script) {
1582#if LLDB_ENABLE_PYTHON1
  return Execute_ScriptSummary(command, result);
1584#else
  result.AppendError("python is disabled");
  return false;
1587#endif
}

return Execute_StringSummary(command, result);
1591}

1593static bool FixArrayTypeNameWithRegex(ConstString &type_name) {
llvm::StringRef type_name_ref(type_name.GetStringRef());

if (type_name_ref.endswith("[]")) {
  std::string type_name_str(type_name.GetCString());
  type_name_str.resize(type_name_str.length() - 2);
  if (type_name_str.back() != ' ')
    type_name_str.append(" ?\\[[0-9]+\\]");
  else
    type_name_str.append("\\[[0-9]+\\]");
  type_name.SetCString(type_name_str.c_str());
  return true;
}
return false;
1607}

1609bool CommandObjectTypeSummaryAdd::AddSummary(ConstString type_name,
                                           TypeSummaryImplSP entry,
                                           SummaryFormatType type,
                                           std::string category_name,
                                           Status *error) {
lldb::TypeCategoryImplSP category;
DataVisualization::Categories::GetCategory(ConstString(category_name.c_str()),
                                           category);

if (type == eRegularSummary) {
  if (FixArrayTypeNameWithRegex(type_name))
    type = eRegexSummary;
}

if (type == eRegexSummary) {
  RegularExpression typeRX(type_name.GetStringRef());
  if (!typeRX.IsValid()) {
    if (error)
      error->SetErrorString(
          "regex format error (maybe this is not really a regex?)");
    return false;
  }

  category->GetRegexTypeSummariesContainer()->Delete(type_name);
  category->GetRegexTypeSummariesContainer()->Add(std::move(typeRX), entry);

  return true;
} else if (type == eNamedSummary) {
  // system named summaries do not exist (yet?)
  DataVisualization::NamedSummaryFormats::Add(type_name, entry);
  return true;
} else {
  category->GetTypeSummariesContainer()->Add(std::move(type_name), entry);
  return true;
}
1644}

1646// CommandObjectTypeSummaryDelete

1648class CommandObjectTypeSummaryDelete : public CommandObjectTypeFormatterDelete {
1649public:
CommandObjectTypeSummaryDelete(CommandInterpreter &interpreter)
    : CommandObjectTypeFormatterDelete(
          interpreter,
          eFormatCategoryItemSummary | eFormatCategoryItemRegexSummary,
          "type summary delete", "Delete an existing summary for a type.") {}

~CommandObjectTypeSummaryDelete() override = default;

1658protected:
bool FormatterSpecificDeletion(ConstString typeCS) override {
  if (m_options.m_language != lldb::eLanguageTypeUnknown)
    return false;
  return DataVisualization::NamedSummaryFormats::Delete(typeCS);
}
1664};

1666class CommandObjectTypeSummaryClear : public CommandObjectTypeFormatterClear {
1667public:
CommandObjectTypeSummaryClear(CommandInterpreter &interpreter)
    : CommandObjectTypeFormatterClear(
          interpreter,
          eFormatCategoryItemSummary | eFormatCategoryItemRegexSummary,
          "type summary clear", "Delete all existing summaries.") {}

1674protected:
void FormatterSpecificDeletion() override {
  DataVisualization::NamedSummaryFormats::Clear();
}
1678};

1680// CommandObjectTypeSummaryList

1682class CommandObjectTypeSummaryList
  : public CommandObjectTypeFormatterList<TypeSummaryImpl> {
1684public:
CommandObjectTypeSummaryList(CommandInterpreter &interpreter)
    : CommandObjectTypeFormatterList(interpreter, "type summary list",
                                     "Show a list of current summaries.") {}

1689protected:
bool FormatterSpecificList(CommandReturnObject &result) override {
  if (DataVisualization::NamedSummaryFormats::GetCount() > 0) {
    result.GetOutputStream().Printf("Named summaries:\n");
    DataVisualization::NamedSummaryFormats::ForEach(
        [&result](const TypeMatcher &type_matcher,
                  const TypeSummaryImplSP &summary_sp) -> bool {
          result.GetOutputStream().Printf(
              "%s: %s\n", type_matcher.GetMatchString().GetCString(),
              summary_sp->GetDescription().c_str());
          return true;
        });
    return true;
  }
  return false;
}
1705};

1707// CommandObjectTypeCategoryDefine
1708#define LLDB_OPTIONS_type_category_define
1709#include "CommandOptions.inc"

1711class CommandObjectTypeCategoryDefine : public CommandObjectParsed {
class CommandOptions : public Options {
public:
  CommandOptions()
      : m_define_enabled(false, false),
        m_cate_language(eLanguageTypeUnknown, eLanguageTypeUnknown) {}

  ~CommandOptions() override = default;

  Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                        ExecutionContext *execution_context) override {
    Status error;
    const int short_option = m_getopt_table[option_idx].val;

    switch (short_option) {
    case 'e':
      m_define_enabled.SetValueFromString(llvm::StringRef("true"));
      break;
    case 'l':
      error = m_cate_language.SetValueFromString(option_arg);
      break;
    default:
      llvm_unreachable("Unimplemented option")::llvm::llvm_unreachable_internal("Unimplemented option", "lldb/source/Commands/CommandObjectType.cpp"
, 1733);
    }

    return error;
  }

  void OptionParsingStarting(ExecutionContext *execution_context) override {
    m_define_enabled.Clear();
    m_cate_language.Clear();
  }

  llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
    return llvm::makeArrayRef(g_type_category_define_options);
  }

  // Instance variables to hold the values for command options.

  OptionValueBoolean m_define_enabled;
  OptionValueLanguage m_cate_language;
};

CommandOptions m_options;

Options *GetOptions() override { return &m_options; }

1758public:
CommandObjectTypeCategoryDefine(CommandInterpreter &interpreter)
    : CommandObjectParsed(interpreter, "type category define",
                          "Define a new category as a source of formatters.",
                          nullptr) {
  CommandArgumentEntry type_arg;
  CommandArgumentData type_style_arg;

  type_style_arg.arg_type = eArgTypeName;
  type_style_arg.arg_repetition = eArgRepeatPlus;

  type_arg.push_back(type_style_arg);

  m_arguments.push_back(type_arg);
}

~CommandObjectTypeCategoryDefine() override = default;

void
HandleArgumentCompletion(CompletionRequest &request,
                         OptionElementVector &opt_element_vector) override {
  CommandCompletions::InvokeCommonCompletionCallbacks(
      GetCommandInterpreter(),
      CommandCompletions::eTypeCategoryNameCompletion, request, nullptr);
}

1784protected:
bool DoExecute(Args &command, CommandReturnObject &result) override {
  const size_t argc = command.GetArgumentCount();

  if (argc < 1) {
    result.AppendErrorWithFormat("%s takes 1 or more args.\n",
                                 m_cmd_name.c_str());
    return false;
  }

  for (auto &entry : command.entries()) {
    TypeCategoryImplSP category_sp;
    if (DataVisualization::Categories::GetCategory(ConstString(entry.ref()),
                                                   category_sp) &&
        category_sp) {
      category_sp->AddLanguage(m_options.m_cate_language.GetCurrentValue());
      if (m_options.m_define_enabled.GetCurrentValue())
        DataVisualization::Categories::Enable(category_sp,
                                              TypeCategoryMap::Default);
    }
  }

  result.SetStatus(eReturnStatusSuccessFinishResult);
  return result.Succeeded();
}
1809};

1811// CommandObjectTypeCategoryEnable
1812#define LLDB_OPTIONS_type_category_enable
1813#include "CommandOptions.inc"

1815class CommandObjectTypeCategoryEnable : public CommandObjectParsed {
class CommandOptions : public Options {
public:
  CommandOptions() {}

  ~CommandOptions() override = default;

  Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                        ExecutionContext *execution_context) override {
    Status error;
    const int short_option = m_getopt_table[option_idx].val;

    switch (short_option) {
    case 'l':
      if (!option_arg.empty()) {
        m_language = Language::GetLanguageTypeFromString(option_arg);
        if (m_language == lldb::eLanguageTypeUnknown)
          error.SetErrorStringWithFormat("unrecognized language '%s'",
                                         option_arg.str().c_str());
      }
      break;
    default:
      llvm_unreachable("Unimplemented option")::llvm::llvm_unreachable_internal("Unimplemented option", "lldb/source/Commands/CommandObjectType.cpp"
, 1837);
    }

    return error;
  }

  void OptionParsingStarting(ExecutionContext *execution_context) override {
    m_language = lldb::eLanguageTypeUnknown;
  }

  llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
    return llvm::makeArrayRef(g_type_category_enable_options);
  }

  // Instance variables to hold the values for command options.

  lldb::LanguageType m_language;
};

CommandOptions m_options;

Options *GetOptions() override { return &m_options; }

1860public:
CommandObjectTypeCategoryEnable(CommandInterpreter &interpreter)
    : CommandObjectParsed(interpreter, "type category enable",
                          "Enable a category as a source of formatters.",
                          nullptr) {
  CommandArgumentEntry type_arg;
  CommandArgumentData type_style_arg;

  type_style_arg.arg_type = eArgTypeName;
  type_style_arg.arg_repetition = eArgRepeatPlus;

  type_arg.push_back(type_style_arg);

  m_arguments.push_back(type_arg);
}

~CommandObjectTypeCategoryEnable() override = default;

void
HandleArgumentCompletion(CompletionRequest &request,
                         OptionElementVector &opt_element_vector) override {
  CommandCompletions::InvokeCommonCompletionCallbacks(
      GetCommandInterpreter(),
      CommandCompletions::eTypeCategoryNameCompletion, request, nullptr);
}

1886protected:
bool DoExecute(Args &command, CommandReturnObject &result) override {
  const size_t argc = command.GetArgumentCount();

  if (argc < 1 && m_options.m_language == lldb::eLanguageTypeUnknown) {
    result.AppendErrorWithFormat("%s takes arguments and/or a language",
                                 m_cmd_name.c_str());
    return false;
  }

  if (argc == 1 && strcmp(command.GetArgumentAtIndex(0), "*") == 0) {
    DataVisualization::Categories::EnableStar();
  } else if (argc > 0) {
    for (int i = argc - 1; i >= 0; i--) {
      const char *typeA = command.GetArgumentAtIndex(i);
      ConstString typeCS(typeA);

      if (!typeCS) {
        result.AppendError("empty category name not allowed");
        return false;
      }
      DataVisualization::Categories::Enable(typeCS);
      lldb::TypeCategoryImplSP cate;
      if (DataVisualization::Categories::GetCategory(typeCS, cate) && cate) {
        if (cate->GetCount() == 0) {
          result.AppendWarning("empty category enabled (typo?)");
        }
      }
    }
  }

  if (m_options.m_language != lldb::eLanguageTypeUnknown)
    DataVisualization::Categories::Enable(m_options.m_language);

  result.SetStatus(eReturnStatusSuccessFinishResult);
  return result.Succeeded();
}
1923};

1925// CommandObjectTypeCategoryDelete

1927class CommandObjectTypeCategoryDelete : public CommandObjectParsed {
1928public:
CommandObjectTypeCategoryDelete(CommandInterpreter &interpreter)
    : CommandObjectParsed(interpreter, "type category delete",
                          "Delete a category and all associated formatters.",
                          nullptr) {
  CommandArgumentEntry type_arg;
  CommandArgumentData type_style_arg;

  type_style_arg.arg_type = eArgTypeName;
  type_style_arg.arg_repetition = eArgRepeatPlus;

  type_arg.push_back(type_style_arg);

  m_arguments.push_back(type_arg);
}

~CommandObjectTypeCategoryDelete() override = default;

void
HandleArgumentCompletion(CompletionRequest &request,
                         OptionElementVector &opt_element_vector) override {
  CommandCompletions::InvokeCommonCompletionCallbacks(
      GetCommandInterpreter(),
      CommandCompletions::eTypeCategoryNameCompletion, request, nullptr);
}

1954protected:
bool DoExecute(Args &command, CommandReturnObject &result) override {
  const size_t argc = command.GetArgumentCount();

  if (argc < 1) {
    result.AppendErrorWithFormat("%s takes 1 or more arg.\n",
                                 m_cmd_name.c_str());
    return false;
  }

  bool success = true;

  // the order is not relevant here
  for (int i = argc - 1; i >= 0; i--) {
    const char *typeA = command.GetArgumentAtIndex(i);
    ConstString typeCS(typeA);

    if (!typeCS) {
      result.AppendError("empty category name not allowed");
      return false;
    }
    if (!DataVisualization::Categories::Delete(typeCS))
      success = false; // keep deleting even if we hit an error
  }
  if (success) {
    result.SetStatus(eReturnStatusSuccessFinishResult);
    return result.Succeeded();
  } else {
    result.AppendError("cannot delete one or more categories\n");
    return false;
  }
}
1986};

1988// CommandObjectTypeCategoryDisable
1989#define LLDB_OPTIONS_type_category_disable
1990#include "CommandOptions.inc"

1992class CommandObjectTypeCategoryDisable : public CommandObjectParsed {
class CommandOptions : public Options {
public:
  CommandOptions() {}

  ~CommandOptions() override = default;

  Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                        ExecutionContext *execution_context) override {
    Status error;
    const int short_option = m_getopt_table[option_idx].val;

    switch (short_option) {
    case 'l':
      if (!option_arg.empty()) {
        m_language = Language::GetLanguageTypeFromString(option_arg);
        if (m_language == lldb::eLanguageTypeUnknown)
          error.SetErrorStringWithFormat("unrecognized language '%s'",
                                         option_arg.str().c_str());
      }
      break;
    default:
      llvm_unreachable("Unimplemented option")::llvm::llvm_unreachable_internal("Unimplemented option", "lldb/source/Commands/CommandObjectType.cpp"
, 2014);
    }

    return error;
  }

  void OptionParsingStarting(ExecutionContext *execution_context) override {
    m_language = lldb::eLanguageTypeUnknown;
  }

  llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
    return llvm::makeArrayRef(g_type_category_disable_options);
  }

  // Instance variables to hold the values for command options.

  lldb::LanguageType m_language;
};

CommandOptions m_options;

Options *GetOptions() override { return &m_options; }

2037public:
CommandObjectTypeCategoryDisable(CommandInterpreter &interpreter)
    : CommandObjectParsed(interpreter, "type category disable",
                          "Disable a category as a source of formatters.",
                          nullptr) {
  CommandArgumentEntry type_arg;
  CommandArgumentData type_style_arg;

  type_style_arg.arg_type = eArgTypeName;
  type_style_arg.arg_repetition = eArgRepeatPlus;

  type_arg.push_back(type_style_arg);

  m_arguments.push_back(type_arg);
}

~CommandObjectTypeCategoryDisable() override = default;

void
HandleArgumentCompletion(CompletionRequest &request,
                         OptionElementVector &opt_element_vector) override {
  CommandCompletions::InvokeCommonCompletionCallbacks(
      GetCommandInterpreter(),
      CommandCompletions::eTypeCategoryNameCompletion, request, nullptr);
}

2063protected:
bool DoExecute(Args &command, CommandReturnObject &result) override {
  const size_t argc = command.GetArgumentCount();

  if (argc < 1 && m_options.m_language == lldb::eLanguageTypeUnknown) {
    result.AppendErrorWithFormat("%s takes arguments and/or a language",
                                 m_cmd_name.c_str());
    return false;
  }

  if (argc == 1 && strcmp(command.GetArgumentAtIndex(0), "*") == 0) {
    DataVisualization::Categories::DisableStar();
  } else if (argc > 0) {
    // the order is not relevant here
    for (int i = argc - 1; i >= 0; i--) {
      const char *typeA = command.GetArgumentAtIndex(i);
      ConstString typeCS(typeA);

      if (!typeCS) {
        result.AppendError("empty category name not allowed");
        return false;
      }
      DataVisualization::Categories::Disable(typeCS);
    }
  }

  if (m_options.m_language != lldb::eLanguageTypeUnknown)
    DataVisualization::Categories::Disable(m_options.m_language);

  result.SetStatus(eReturnStatusSuccessFinishResult);
  return result.Succeeded();
}
2095};

2097// CommandObjectTypeCategoryList

2099class CommandObjectTypeCategoryList : public CommandObjectParsed {
2100public:
CommandObjectTypeCategoryList(CommandInterpreter &interpreter)
    : CommandObjectParsed(interpreter, "type category list",
                          "Provide a list of all existing categories.",
                          nullptr) {
  CommandArgumentEntry type_arg;
  CommandArgumentData type_style_arg;

  type_style_arg.arg_type = eArgTypeName;
  type_style_arg.arg_repetition = eArgRepeatOptional;

  type_arg.push_back(type_style_arg);

  m_arguments.push_back(type_arg);
}

~CommandObjectTypeCategoryList() override = default;

void
HandleArgumentCompletion(CompletionRequest &request,
                         OptionElementVector &opt_element_vector) override {
  if (request.GetCursorIndex())
    return;
  CommandCompletions::InvokeCommonCompletionCallbacks(
      GetCommandInterpreter(),
      CommandCompletions::eTypeCategoryNameCompletion, request, nullptr);
}

2128protected:
bool DoExecute(Args &command, CommandReturnObject &result) override {
  const size_t argc = command.GetArgumentCount();

  std::unique_ptr<RegularExpression> regex;

  if (argc == 1) {
    const char *arg = command.GetArgumentAtIndex(0);
    regex = std::make_unique<RegularExpression>(arg);
    if (!regex->IsValid()) {
      result.AppendErrorWithFormat(
          "syntax error in category regular expression '%s'", arg);
      return false;
    }
  } else if (argc != 0) {
    result.AppendErrorWithFormat("%s takes 0 or one arg.\n",
                                 m_cmd_name.c_str());
    return false;
  }

  DataVisualization::Categories::ForEach(
      [&regex, &result](const lldb::TypeCategoryImplSP &category_sp) -> bool {
        if (regex) {
          bool escape = true;
          if (regex->GetText() == category_sp->GetName()) {
            escape = false;
          } else if (regex->Execute(category_sp->GetName())) {
            escape = false;
          }

          if (escape)
            return true;
        }

        result.GetOutputStream().Printf(
            "Category: %s\n", category_sp->GetDescription().c_str());

        return true;
      });

  result.SetStatus(eReturnStatusSuccessFinishResult);
  return result.Succeeded();
}
2171};

2173// CommandObjectTypeFilterList

2175class CommandObjectTypeFilterList
  : public CommandObjectTypeFormatterList<TypeFilterImpl> {
2177public:
CommandObjectTypeFilterList(CommandInterpreter &interpreter)
    : CommandObjectTypeFormatterList(interpreter, "type filter list",
                                     "Show a list of current filters.") {}
2181};

2183#if LLDB_ENABLE_PYTHON1

2185// CommandObjectTypeSynthList

2187class CommandObjectTypeSynthList
  : public CommandObjectTypeFormatterList<SyntheticChildren> {
2189public:
CommandObjectTypeSynthList(CommandInterpreter &interpreter)
    : CommandObjectTypeFormatterList(
          interpreter, "type synthetic list",
          "Show a list of current synthetic providers.") {}
2194};

2196#endif

2198// CommandObjectTypeFilterDelete

2200class CommandObjectTypeFilterDelete : public CommandObjectTypeFormatterDelete {
2201public:
CommandObjectTypeFilterDelete(CommandInterpreter &interpreter)
    : CommandObjectTypeFormatterDelete(
          interpreter,
          eFormatCategoryItemFilter | eFormatCategoryItemRegexFilter,
          "type filter delete", "Delete an existing filter for a type.") {}

~CommandObjectTypeFilterDelete() override = default;
2209};

2211#if LLDB_ENABLE_PYTHON1

2213// CommandObjectTypeSynthDelete

2215class CommandObjectTypeSynthDelete : public CommandObjectTypeFormatterDelete {
2216public:
CommandObjectTypeSynthDelete(CommandInterpreter &interpreter)
    : CommandObjectTypeFormatterDelete(
          interpreter,
          eFormatCategoryItemSynth | eFormatCategoryItemRegexSynth,
          "type synthetic delete",
          "Delete an existing synthetic provider for a type.") {}

~CommandObjectTypeSynthDelete() override = default;
2225};

2227#endif

2229// CommandObjectTypeFilterClear

2231class CommandObjectTypeFilterClear : public CommandObjectTypeFormatterClear {
2232public:
CommandObjectTypeFilterClear(CommandInterpreter &interpreter)
    : CommandObjectTypeFormatterClear(
          interpreter,
          eFormatCategoryItemFilter | eFormatCategoryItemRegexFilter,
          "type filter clear", "Delete all existing filter.") {}
2238};

2240#if LLDB_ENABLE_PYTHON1
2241// CommandObjectTypeSynthClear

2243class CommandObjectTypeSynthClear : public CommandObjectTypeFormatterClear {
2244public:
CommandObjectTypeSynthClear(CommandInterpreter &interpreter)
    : CommandObjectTypeFormatterClear(
          interpreter,
          eFormatCategoryItemSynth | eFormatCategoryItemRegexSynth,
          "type synthetic clear",
          "Delete all existing synthetic providers.") {}
2251};

2253bool CommandObjectTypeSynthAdd::Execute_HandwritePython(
  Args &command, CommandReturnObject &result) {
SynthAddOptions *options = new SynthAddOptions(
4
←
Memory is allocated→
    m_options.m_skip_pointers, m_options.m_skip_references,
    m_options.m_cascade, m_options.m_regex, m_options.m_category);

for (auto &entry : command.entries()) {
5
←
Assuming '__begin1' is not equal to '__end1'→
  if (entry.ref().empty()) {
6
←
Assuming the condition is true→
7
←
Taking true branch→
    result.AppendError("empty typenames not allowed");
8
←
Potential leak of memory pointed to by 'options'
    return false;
  }

  options->m_target_types << std::string(entry.ref());
}

m_interpreter.GetPythonCommandsFromIOHandler(
    "    ",   // Prompt
    *this,    // IOHandlerDelegate
    options); // Baton for the "io_handler" that will be passed back into our
              // IOHandlerDelegate functions
result.SetStatus(eReturnStatusSuccessFinishNoResult);
return result.Succeeded();
2275}

2277bool CommandObjectTypeSynthAdd::Execute_PythonClass(
  Args &command, CommandReturnObject &result) {
const size_t argc = command.GetArgumentCount();

if (argc < 1) {
  result.AppendErrorWithFormat("%s takes one or more args.\n",
                               m_cmd_name.c_str());
  return false;
}

if (m_options.m_class_name.empty() && !m_options.m_input_python) {
  result.AppendErrorWithFormat("%s needs either a Python class name or -P to "
                               "directly input Python code.\n",
                               m_cmd_name.c_str());
  return false;
}

SyntheticChildrenSP entry;

ScriptedSyntheticChildren *impl = new ScriptedSyntheticChildren(
    SyntheticChildren::Flags()
        .SetCascades(m_options.m_cascade)
        .SetSkipPointers(m_options.m_skip_pointers)
        .SetSkipReferences(m_options.m_skip_references),
    m_options.m_class_name.c_str());

entry.reset(impl);

ScriptInterpreter *interpreter = GetDebugger().GetScriptInterpreter();

if (interpreter &&
    !interpreter->CheckObjectExists(impl->GetPythonClassName()))
  result.AppendWarning("The provided class does not exist - please define it "
                       "before attempting to use this synthetic provider");

// now I have a valid provider, let's add it to every type

lldb::TypeCategoryImplSP category;
DataVisualization::Categories::GetCategory(
    ConstString(m_options.m_category.c_str()), category);

Status error;

for (auto &arg_entry : command.entries()) {
  if (arg_entry.ref().empty()) {
    result.AppendError("empty typenames not allowed");
    return false;
  }

  ConstString typeCS(arg_entry.ref());
  if (!AddSynth(typeCS, entry,
                m_options.m_regex ? eRegexSynth : eRegularSynth,
                m_options.m_category, &error)) {
    result.AppendError(error.AsCString());
    return false;
  }
}

result.SetStatus(eReturnStatusSuccessFinishNoResult);
return result.Succeeded();
2337}

2339CommandObjectTypeSynthAdd::CommandObjectTypeSynthAdd(
  CommandInterpreter &interpreter)
  : CommandObjectParsed(interpreter, "type synthetic add",
                        "Add a new synthetic provider for a type.", nullptr),
    IOHandlerDelegateMultiline("DONE"), m_options() {
CommandArgumentEntry type_arg;
CommandArgumentData type_style_arg;

type_style_arg.arg_type = eArgTypeName;
type_style_arg.arg_repetition = eArgRepeatPlus;

type_arg.push_back(type_style_arg);

m_arguments.push_back(type_arg);
2353}

2355bool CommandObjectTypeSynthAdd::AddSynth(ConstString type_name,
                                       SyntheticChildrenSP entry,
                                       SynthFormatType type,
                                       std::string category_name,
                                       Status *error) {
lldb::TypeCategoryImplSP category;
DataVisualization::Categories::GetCategory(ConstString(category_name.c_str()),
                                           category);

if (type == eRegularSynth) {
  if (FixArrayTypeNameWithRegex(type_name))
    type = eRegexSynth;
}

if (category->AnyMatches(
        type_name, eFormatCategoryItemFilter | eFormatCategoryItemRegexFilter,
        false)) {
  if (error)
    error->SetErrorStringWithFormat("cannot add synthetic for type %s when "
                                    "filter is defined in same category!",
                                    type_name.AsCString());
  return false;
}

if (type == eRegexSynth) {
  RegularExpression typeRX(type_name.GetStringRef());
  if (!typeRX.IsValid()) {
    if (error)
      error->SetErrorString(
          "regex format error (maybe this is not really a regex?)");
    return false;
  }

  category->GetRegexTypeSyntheticsContainer()->Delete(type_name);
  category->GetRegexTypeSyntheticsContainer()->Add(std::move(typeRX), entry);

  return true;
} else {
  category->GetTypeSyntheticsContainer()->Add(std::move(type_name), entry);
  return true;
}
2396}

2398#endif
2399#define LLDB_OPTIONS_type_filter_add
2400#include "CommandOptions.inc"

2402class CommandObjectTypeFilterAdd : public CommandObjectParsed {
2403private:
class CommandOptions : public Options {
  typedef std::vector<std::string> option_vector;

public:
  CommandOptions() {}

  ~CommandOptions() override = default;

  Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                        ExecutionContext *execution_context) override {
    Status error;
    const int short_option = m_getopt_table[option_idx].val;
    bool success;

    switch (short_option) {
    case 'C':
      m_cascade = OptionArgParser::ToBoolean(option_arg, true, &success);
      if (!success)
        error.SetErrorStringWithFormat("invalid value for cascade: %s",
                                       option_arg.str().c_str());
      break;
    case 'c':
      m_expr_paths.push_back(std::string(option_arg));
      has_child_list = true;
      break;
    case 'p':
      m_skip_pointers = true;
      break;
    case 'r':
      m_skip_references = true;
      break;
    case 'w':
      m_category = std::string(option_arg);
      break;
    case 'x':
      m_regex = true;
      break;
    default:
      llvm_unreachable("Unimplemented option")::llvm::llvm_unreachable_internal("Unimplemented option", "lldb/source/Commands/CommandObjectType.cpp"
, 2442);
    }

    return error;
  }

  void OptionParsingStarting(ExecutionContext *execution_context) override {
    m_cascade = true;
    m_skip_pointers = false;
    m_skip_references = false;
    m_category = "default";
    m_expr_paths.clear();
    has_child_list = false;
    m_regex = false;
  }

  llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
    return llvm::makeArrayRef(g_type_filter_add_options);
  }

  // Instance variables to hold the values for command options.

  bool m_cascade;
  bool m_skip_references;
  bool m_skip_pointers;
  bool m_input_python;
  option_vector m_expr_paths;
  std::string m_category;
  bool has_child_list;
  bool m_regex;

  typedef option_vector::iterator ExpressionPathsIterator;
};

CommandOptions m_options;

Options *GetOptions() override { return &m_options; }

enum FilterFormatType { eRegularFilter, eRegexFilter };

bool AddFilter(ConstString type_name, TypeFilterImplSP entry,
               FilterFormatType type, std::string category_name,
               Status *error) {
  lldb::TypeCategoryImplSP category;
  DataVisualization::Categories::GetCategory(
      ConstString(category_name.c_str()), category);

  if (type == eRegularFilter) {
    if (FixArrayTypeNameWithRegex(type_name))
      type = eRegexFilter;
  }

  if (category->AnyMatches(
          type_name, eFormatCategoryItemSynth | eFormatCategoryItemRegexSynth,
          false)) {
    if (error)
      error->SetErrorStringWithFormat("cannot add filter for type %s when "
                                      "synthetic is defined in same "
                                      "category!",
                                      type_name.AsCString());
    return false;
  }

  if (type == eRegexFilter) {
    RegularExpression typeRX(type_name.GetStringRef());
    if (!typeRX.IsValid()) {
      if (error)
        error->SetErrorString(
            "regex format error (maybe this is not really a regex?)");
      return false;
    }

    category->GetRegexTypeFiltersContainer()->Delete(type_name);
    category->GetRegexTypeFiltersContainer()->Add(std::move(typeRX), entry);

    return true;
  } else {
    category->GetTypeFiltersContainer()->Add(std::move(type_name), entry);
    return true;
  }
}

2524public:
CommandObjectTypeFilterAdd(CommandInterpreter &interpreter)
    : CommandObjectParsed(interpreter, "type filter add",
                          "Add a new filter for a type.", nullptr) {
  CommandArgumentEntry type_arg;
  CommandArgumentData type_style_arg;

  type_style_arg.arg_type = eArgTypeName;
  type_style_arg.arg_repetition = eArgRepeatPlus;

  type_arg.push_back(type_style_arg);

  m_arguments.push_back(type_arg);

  SetHelpLong(
      R"(
2540The following examples of 'type filter add' refer to this code snippet for context:

  class Foo {
      int a;
      int b;
      int c;
      int d;
      int e;
      int f;
      int g;
      int h;
      int i;
  }
  Foo my_foo;

2555Adding a simple filter:

2557(lldb) type filter add --child a --child g Foo
2558(lldb) frame variable my_foo

2560)"
      "Produces output where only a and g are displayed.  Other children of my_foo \
2562(b, c, d, e, f, h and i) are available by asking for them explicitly:"
      R"(

2565(lldb) frame variable my_foo.b my_foo.c my_foo.i

2567)"
      "The formatting option --raw on frame variable bypasses the filter, showing \
2569all children of my_foo as if no filter was defined:"
      R"(

2572(lldb) frame variable my_foo --raw)");
}

~CommandObjectTypeFilterAdd() override = default;

2577protected:
bool DoExecute(Args &command, CommandReturnObject &result) override {
  const size_t argc = command.GetArgumentCount();

  if (argc < 1) {
    result.AppendErrorWithFormat("%s takes one or more args.\n",
                                 m_cmd_name.c_str());
    return false;
  }

  if (m_options.m_expr_paths.empty()) {
    result.AppendErrorWithFormat("%s needs one or more children.\n",
                                 m_cmd_name.c_str());
    return false;
  }

  TypeFilterImplSP entry(new TypeFilterImpl(
      SyntheticChildren::Flags()
          .SetCascades(m_options.m_cascade)
          .SetSkipPointers(m_options.m_skip_pointers)
          .SetSkipReferences(m_options.m_skip_references)));

  // go through the expression paths
  CommandOptions::ExpressionPathsIterator begin,
      end = m_options.m_expr_paths.end();

  for (begin = m_options.m_expr_paths.begin(); begin != end; begin++)
    entry->AddExpressionPath(*begin);

  // now I have a valid provider, let's add it to every type

  lldb::TypeCategoryImplSP category;
  DataVisualization::Categories::GetCategory(
      ConstString(m_options.m_category.c_str()), category);

  Status error;

  WarnOnPotentialUnquotedUnsignedType(command, result);

  for (auto &arg_entry : command.entries()) {
    if (arg_entry.ref().empty()) {
      result.AppendError("empty typenames not allowed");
      return false;
    }

    ConstString typeCS(arg_entry.ref());
    if (!AddFilter(typeCS, entry,
                   m_options.m_regex ? eRegexFilter : eRegularFilter,
                   m_options.m_category, &error)) {
      result.AppendError(error.AsCString());
      return false;
    }
  }

  result.SetStatus(eReturnStatusSuccessFinishNoResult);
  return result.Succeeded();
}
2634};

2636// "type lookup"
2637#define LLDB_OPTIONS_type_lookup
2638#include "CommandOptions.inc"

2640class CommandObjectTypeLookup : public CommandObjectRaw {
2641protected:
// this function is allowed to do a more aggressive job at guessing languages
// than the expression parser is comfortable with - so leave the original
// call alone and add one that is specific to type lookup
lldb::LanguageType GuessLanguage(StackFrame *frame) {
  lldb::LanguageType lang_type = lldb::eLanguageTypeUnknown;

  if (!frame)
    return lang_type;

  lang_type = frame->GuessLanguage();
  if (lang_type != lldb::eLanguageTypeUnknown)
    return lang_type;

  Symbol *s = frame->GetSymbolContext(eSymbolContextSymbol).symbol;
  if (s)
    lang_type = s->GetMangled().GuessLanguage();

  return lang_type;
}

class CommandOptions : public OptionGroup {
public:
  CommandOptions() {}

  ~CommandOptions() override = default;

  llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
    return llvm::makeArrayRef(g_type_lookup_options);
  }

  Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
                        ExecutionContext *execution_context) override {
    Status error;

    const int short_option = g_type_lookup_options[option_idx].short_option;

    switch (short_option) {
    case 'h':
      m_show_help = true;
      break;

    case 'l':
      m_language = Language::GetLanguageTypeFromString(option_value);
      break;

    default:
      llvm_unreachable("Unimplemented option")::llvm::llvm_unreachable_internal("Unimplemented option", "lldb/source/Commands/CommandObjectType.cpp"
, 2688);
    }

    return error;
  }

  void OptionParsingStarting(ExecutionContext *execution_context) override {
    m_show_help = false;
    m_language = eLanguageTypeUnknown;
  }

  // Options table: Required for subclasses of Options.

  bool m_show_help = false;
  lldb::LanguageType m_language = eLanguageTypeUnknown;
};

OptionGroupOptions m_option_group;
CommandOptions m_command_options;

2708public:
CommandObjectTypeLookup(CommandInterpreter &interpreter)
    : CommandObjectRaw(interpreter, "type lookup",
                       "Lookup types and declarations in the current target, "
                       "following language-specific naming conventions.",
                       "type lookup <type-specifier>",
                       eCommandRequiresTarget) {
  m_option_group.Append(&m_command_options);
  m_option_group.Finalize();
}

~CommandObjectTypeLookup() override = default;

Options *GetOptions() override { return &m_option_group; }

llvm::StringRef GetHelpLong() override {
  if (!m_cmd_help_long.empty())
    return m_cmd_help_long;

  StreamString stream;
  Language::ForEach([&](Language *lang) {
    if (const char *help = lang->GetLanguageSpecificTypeLookupHelp())
      stream.Printf("%s\n", help);
    return true;
  });

  m_cmd_help_long = std::string(stream.GetString());
  return m_cmd_help_long;
}

bool DoExecute(llvm::StringRef raw_command_line,
               CommandReturnObject &result) override {
  if (raw_command_line.empty()) {
    result.AppendError(
        "type lookup cannot be invoked without a type name as argument");
    return false;
  }

  auto exe_ctx = GetCommandInterpreter().GetExecutionContext();
  m_option_group.NotifyOptionParsingStarting(&exe_ctx);

  OptionsWithRaw args(raw_command_line);
  const char *name_of_type = args.GetRawPart().c_str();

  if (args.HasArgs())
    if (!ParseOptionsAndNotify(args.GetArgs(), result, m_option_group,
                               exe_ctx))
      return false;

  ExecutionContextScope *best_scope = exe_ctx.GetBestExecutionContextScope();

  bool any_found = false;

  std::vector<Language *> languages;

  bool is_global_search = false;
  LanguageType guessed_language = lldb::eLanguageTypeUnknown;

  if ((is_global_search =
           (m_command_options.m_language == eLanguageTypeUnknown))) {
    Language::ForEach([&](Language *lang) {
      languages.push_back(lang);
      return true;
    });
  } else {
    languages.push_back(Language::FindPlugin(m_command_options.m_language));
  }

  // This is not the most efficient way to do this, but we support very few
  // languages so the cost of the sort is going to be dwarfed by the actual
  // lookup anyway
  if (StackFrame *frame = m_exe_ctx.GetFramePtr()) {
    guessed_language = GuessLanguage(frame);
    if (guessed_language != eLanguageTypeUnknown) {
      llvm::sort(
          languages.begin(), languages.end(),
          [guessed_language](Language *lang1, Language *lang2) -> bool {
            if (!lang1 || !lang2)
              return false;
            LanguageType lt1 = lang1->GetLanguageType();
            LanguageType lt2 = lang2->GetLanguageType();
            if (lt1 == guessed_language)
              return true; // make the selected frame's language come first
            if (lt2 == guessed_language)
              return false; // make the selected frame's language come first
            return (lt1 < lt2); // normal comparison otherwise
          });
    }
  }

  bool is_first_language = true;

  for (Language *language : languages) {
    if (!language)
      continue;

    if (auto scavenger = language->GetTypeScavenger()) {
      Language::TypeScavenger::ResultSet search_results;
      if (scavenger->Find(best_scope, name_of_type, search_results) > 0) {
        for (const auto &search_result : search_results) {
          if (search_result && search_result->IsValid()) {
            any_found = true;
            search_result->DumpToStream(result.GetOutputStream(),
                                        this->m_command_options.m_show_help);
          }
        }
      }
    }
    // this is "type lookup SomeName" and we did find a match, so get out
    if (any_found && is_global_search)
      break;
    else if (is_first_language && is_global_search &&
             guessed_language != lldb::eLanguageTypeUnknown) {
      is_first_language = false;
      result.GetOutputStream().Printf(
          "no type was found in the current language %s matching '%s'; "
          "performing a global search across all languages\n",
          Language::GetNameForLanguageType(guessed_language), name_of_type);
    }
  }

  if (!any_found)
    result.AppendMessageWithFormat("no type was found matching '%s'\n",
                                   name_of_type);

  result.SetStatus(any_found ? lldb::eReturnStatusSuccessFinishResult
                             : lldb::eReturnStatusSuccessFinishNoResult);
  return true;
}
2837};

2839template <typename FormatterType>
2840class CommandObjectFormatterInfo : public CommandObjectRaw {
2841public:
typedef std::function<typename FormatterType::SharedPointer(ValueObject &)>
    DiscoveryFunction;
CommandObjectFormatterInfo(CommandInterpreter &interpreter,
                           const char *formatter_name,
                           DiscoveryFunction discovery_func)
    : CommandObjectRaw(interpreter, "", "", "", eCommandRequiresFrame),
      m_formatter_name(formatter_name ? formatter_name : ""),
      m_discovery_function(discovery_func) {
  StreamString name;
  name.Printf("type %s info", formatter_name);
  SetCommandName(name.GetString());
  StreamString help;
  help.Printf("This command evaluates the provided expression and shows "
              "which %s is applied to the resulting value (if any).",
              formatter_name);
  SetHelp(help.GetString());
  StreamString syntax;
  syntax.Printf("type %s info <expr>", formatter_name);
  SetSyntax(syntax.GetString());
}

~CommandObjectFormatterInfo() override = default;

2865protected:
bool DoExecute(llvm::StringRef command,
               CommandReturnObject &result) override {
  TargetSP target_sp = GetDebugger().GetSelectedTarget();
  Thread *thread = GetDefaultThread();
  if (!thread) {
    result.AppendError("no default thread");
    return false;
  }

  StackFrameSP frame_sp = thread->GetSelectedFrame();
  ValueObjectSP result_valobj_sp;
  EvaluateExpressionOptions options;
  lldb::ExpressionResults expr_result = target_sp->EvaluateExpression(
      command, frame_sp.get(), result_valobj_sp, options);
  if (expr_result == eExpressionCompleted && result_valobj_sp) {
    result_valobj_sp =
        result_valobj_sp->GetQualifiedRepresentationIfAvailable(
            target_sp->GetPreferDynamicValue(),
            target_sp->GetEnableSyntheticValue());
    typename FormatterType::SharedPointer formatter_sp =
        m_discovery_function(*result_valobj_sp);
    if (formatter_sp) {
      std::string description(formatter_sp->GetDescription());
      result.GetOutputStream()
          << m_formatter_name << " applied to ("
          << result_valobj_sp->GetDisplayTypeName().AsCString("<unknown>")
          << ") " << command << " is: " << description << "\n";
      result.SetStatus(lldb::eReturnStatusSuccessFinishResult);
    } else {
      result.GetOutputStream()
          << "no " << m_formatter_name << " applies to ("
          << result_valobj_sp->GetDisplayTypeName().AsCString("<unknown>")
          << ") " << command << "\n";
      result.SetStatus(lldb::eReturnStatusSuccessFinishNoResult);
    }
    return true;
  } else {
    result.AppendError("failed to evaluate expression");
    return false;
  }
}

2908private:
std::string m_formatter_name;
DiscoveryFunction m_discovery_function;
2911};

2913class CommandObjectTypeFormat : public CommandObjectMultiword {
2914public:
CommandObjectTypeFormat(CommandInterpreter &interpreter)
    : CommandObjectMultiword(
          interpreter, "type format",
          "Commands for customizing value display formats.",
          "type format [<sub-command-options>] ") {
  LoadSubCommand(
      "add", CommandObjectSP(new CommandObjectTypeFormatAdd(interpreter)));
  LoadSubCommand("clear", CommandObjectSP(
                              new CommandObjectTypeFormatClear(interpreter)));
  LoadSubCommand("delete", CommandObjectSP(new CommandObjectTypeFormatDelete(
                               interpreter)));
  LoadSubCommand(
      "list", CommandObjectSP(new CommandObjectTypeFormatList(interpreter)));
  LoadSubCommand(
      "info", CommandObjectSP(new CommandObjectFormatterInfo<TypeFormatImpl>(
                  interpreter, "format",
                  [](ValueObject &valobj) -> TypeFormatImpl::SharedPointer {
                    return valobj.GetValueFormat();
                  })));
}

~CommandObjectTypeFormat() override = default;
2937};

2939#if LLDB_ENABLE_PYTHON1

2941class CommandObjectTypeSynth : public CommandObjectMultiword {
2942public:
CommandObjectTypeSynth(CommandInterpreter &interpreter)
    : CommandObjectMultiword(
          interpreter, "type synthetic",
          "Commands for operating on synthetic type representations.",
          "type synthetic [<sub-command-options>] ") {
  LoadSubCommand("add",
                 CommandObjectSP(new CommandObjectTypeSynthAdd(interpreter)));
  LoadSubCommand(
      "clear", CommandObjectSP(new CommandObjectTypeSynthClear(interpreter)));
  LoadSubCommand("delete", CommandObjectSP(new CommandObjectTypeSynthDelete(
                               interpreter)));
  LoadSubCommand(
      "list", CommandObjectSP(new CommandObjectTypeSynthList(interpreter)));
  LoadSubCommand(
      "info",
      CommandObjectSP(new CommandObjectFormatterInfo<SyntheticChildren>(
          interpreter, "synthetic",
          [](ValueObject &valobj) -> SyntheticChildren::SharedPointer {
            return valobj.GetSyntheticChildren();
          })));
}

~CommandObjectTypeSynth() override = default;
2966};

2968#endif

2970class CommandObjectTypeFilter : public CommandObjectMultiword {
2971public:
CommandObjectTypeFilter(CommandInterpreter &interpreter)
    : CommandObjectMultiword(interpreter, "type filter",
                             "Commands for operating on type filters.",
                             "type filter [<sub-command-options>] ") {
  LoadSubCommand(
      "add", CommandObjectSP(new CommandObjectTypeFilterAdd(interpreter)));
  LoadSubCommand("clear", CommandObjectSP(
                              new CommandObjectTypeFilterClear(interpreter)));
  LoadSubCommand("delete", CommandObjectSP(new CommandObjectTypeFilterDelete(
                               interpreter)));
  LoadSubCommand(
      "list", CommandObjectSP(new CommandObjectTypeFilterList(interpreter)));
}

~CommandObjectTypeFilter() override = default;
2987};

2989class CommandObjectTypeCategory : public CommandObjectMultiword {
2990public:
CommandObjectTypeCategory(CommandInterpreter &interpreter)
    : CommandObjectMultiword(interpreter, "type category",
                             "Commands for operating on type categories.",
                             "type category [<sub-command-options>] ") {
  LoadSubCommand(
      "define",
      CommandObjectSP(new CommandObjectTypeCategoryDefine(interpreter)));
  LoadSubCommand(
      "enable",
      CommandObjectSP(new CommandObjectTypeCategoryEnable(interpreter)));
  LoadSubCommand(
      "disable",
      CommandObjectSP(new CommandObjectTypeCategoryDisable(interpreter)));
  LoadSubCommand(
      "delete",
      CommandObjectSP(new CommandObjectTypeCategoryDelete(interpreter)));
  LoadSubCommand("list", CommandObjectSP(
                             new CommandObjectTypeCategoryList(interpreter)));
}

~CommandObjectTypeCategory() override = default;
3012};

3014class CommandObjectTypeSummary : public CommandObjectMultiword {
3015public:
CommandObjectTypeSummary(CommandInterpreter &interpreter)
    : CommandObjectMultiword(
          interpreter, "type summary",
          "Commands for editing variable summary display options.",
          "type summary [<sub-command-options>] ") {
  LoadSubCommand(
      "add", CommandObjectSP(new CommandObjectTypeSummaryAdd(interpreter)));
  LoadSubCommand("clear", CommandObjectSP(new CommandObjectTypeSummaryClear(
                              interpreter)));
  LoadSubCommand("delete", CommandObjectSP(new CommandObjectTypeSummaryDelete(
                               interpreter)));
  LoadSubCommand(
      "list", CommandObjectSP(new CommandObjectTypeSummaryList(interpreter)));
  LoadSubCommand(
      "info", CommandObjectSP(new CommandObjectFormatterInfo<TypeSummaryImpl>(
                  interpreter, "summary",
                  [](ValueObject &valobj) -> TypeSummaryImpl::SharedPointer {
                    return valobj.GetSummaryFormat();
                  })));
}

~CommandObjectTypeSummary() override = default;
3038};

3040// CommandObjectType

3042CommandObjectType::CommandObjectType(CommandInterpreter &interpreter)
  : CommandObjectMultiword(interpreter, "type",
                           "Commands for operating on the type system.",
                           "type [<sub-command-options>]") {
LoadSubCommand("category",
               CommandObjectSP(new CommandObjectTypeCategory(interpreter)));
LoadSubCommand("filter",
               CommandObjectSP(new CommandObjectTypeFilter(interpreter)));
LoadSubCommand("format",
               CommandObjectSP(new CommandObjectTypeFormat(interpreter)));
LoadSubCommand("summary",
               CommandObjectSP(new CommandObjectTypeSummary(interpreter)));
3054#if LLDB_ENABLE_PYTHON1
LoadSubCommand("synthetic",
               CommandObjectSP(new CommandObjectTypeSynth(interpreter)));
3057#endif
LoadSubCommand("lookup",
               CommandObjectSP(new CommandObjectTypeLookup(interpreter)));
3060}

3062CommandObjectType::~CommandObjectType() = default;