llvm/lldb/source/Commands/CommandObjectMultiword.cpp

//===-- CommandObjectMultiword.cpp ----------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include "lldb/Interpreter/CommandObjectMultiword.h"
#include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Interpreter/CommandReturnObject.h"
#include "lldb/Interpreter/Options.h"
#include <optional>

usingnamespacelldb;
usingnamespacelldb_private;

// CommandObjectMultiword

CommandObjectMultiword::CommandObjectMultiword(CommandInterpreter &interpreter,
                                               const char *name,
                                               const char *help,
                                               const char *syntax,
                                               uint32_t flags)
    : … { … }

CommandObjectMultiword::~CommandObjectMultiword() = default;

CommandObjectSP
CommandObjectMultiword::GetSubcommandSPExact(llvm::StringRef sub_cmd) { … }

CommandObjectSP CommandObjectMultiword::GetSubcommandSP(llvm::StringRef sub_cmd,
                                                        StringList *matches) { … }

CommandObject *
CommandObjectMultiword::GetSubcommandObject(llvm::StringRef sub_cmd,
                                            StringList *matches) { … }

bool CommandObjectMultiword::LoadSubCommand(llvm::StringRef name,
                                            const CommandObjectSP &cmd_obj_sp) { … }

llvm::Error CommandObjectMultiword::LoadUserSubcommand(
    llvm::StringRef name, const CommandObjectSP &cmd_obj_sp, bool can_replace) { … }

llvm::Error CommandObjectMultiword::RemoveUserSubcommand(llvm::StringRef cmd_name,
                                                    bool must_be_multiword) { … }

void CommandObjectMultiword::Execute(const char *args_string,
                                     CommandReturnObject &result) { … }

void CommandObjectMultiword::GenerateHelpText(Stream &output_stream) { … }

void CommandObjectMultiword::HandleCompletion(CompletionRequest &request) { … }

std::optional<std::string>
CommandObjectMultiword::GetRepeatCommand(Args &current_command_args,
                                         uint32_t index) { … }

CommandObjectProxy::CommandObjectProxy(CommandInterpreter &interpreter,
                                       const char *name, const char *help,
                                       const char *syntax, uint32_t flags)
    : … { … }

CommandObjectProxy::~CommandObjectProxy() = default;

Options *CommandObjectProxy::GetOptions() { … }

llvm::StringRef CommandObjectProxy::GetHelp() { … }

llvm::StringRef CommandObjectProxy::GetSyntax() { … }

llvm::StringRef CommandObjectProxy::GetHelpLong() { … }

bool CommandObjectProxy::IsRemovable() const { … }

bool CommandObjectProxy::IsMultiwordObject() { … }

CommandObjectMultiword *CommandObjectProxy::GetAsMultiwordCommand() { … }

void CommandObjectProxy::GenerateHelpText(Stream &result) { … }

lldb::CommandObjectSP
CommandObjectProxy::GetSubcommandSP(llvm::StringRef sub_cmd,
                                    StringList *matches) { … }

CommandObject *CommandObjectProxy::GetSubcommandObject(llvm::StringRef sub_cmd,
                                                       StringList *matches) { … }

bool CommandObjectProxy::LoadSubCommand(
    llvm::StringRef cmd_name, const lldb::CommandObjectSP &command_sp) { … }

bool CommandObjectProxy::WantsRawCommandString() { … }

bool CommandObjectProxy::WantsCompletion() { … }

void CommandObjectProxy::HandleCompletion(CompletionRequest &request) { … }

void CommandObjectProxy::HandleArgumentCompletion(
    CompletionRequest &request, OptionElementVector &opt_element_vector) { … }

std::optional<std::string>
CommandObjectProxy::GetRepeatCommand(Args &current_command_args,
                                     uint32_t index) { … }

llvm::StringRef CommandObjectProxy::GetUnsupportedError() { … }

void CommandObjectProxy::Execute(const char *args_string,
                                 CommandReturnObject &result) { … }