SBCommandInterpreter.cpp | Explore in Territory

//===-- SBCommandInterpreter.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/Utility/StructuredData.h"
#include "lldb/lldb-types.h"

#include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Interpreter/CommandObjectMultiword.h"
#include "lldb/Interpreter/CommandReturnObject.h"
#include "lldb/Target/Target.h"
#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/Listener.h"

#include "lldb/API/SBBroadcaster.h"
#include "lldb/API/SBCommandInterpreter.h"
#include "lldb/API/SBCommandInterpreterRunOptions.h"
#include "lldb/API/SBCommandReturnObject.h"
#include "lldb/API/SBEvent.h"
#include "lldb/API/SBExecutionContext.h"
#include "lldb/API/SBListener.h"
#include "lldb/API/SBProcess.h"
#include "lldb/API/SBStream.h"
#include "lldb/API/SBStringList.h"
#include "lldb/API/SBTarget.h"

#include <memory>
#include <optional>

usingnamespacelldb;
usingnamespacelldb_private;

namespace lldb_private {
class CommandPluginInterfaceImplementation : public CommandObjectParsed { … };
} // namespace lldb_private

SBCommandInterpreter::SBCommandInterpreter() : … { … }

SBCommandInterpreter::SBCommandInterpreter(CommandInterpreter *interpreter)
    : … { … }

SBCommandInterpreter::SBCommandInterpreter(const SBCommandInterpreter &rhs)
    : … { … }

SBCommandInterpreter::~SBCommandInterpreter() = default;

const SBCommandInterpreter &SBCommandInterpreter::
operator=(const SBCommandInterpreter &rhs) { … }

bool SBCommandInterpreter::IsValid() const { … }
operator bool()

bool SBCommandInterpreter::CommandExists(const char *cmd) { … }

bool SBCommandInterpreter::UserCommandExists(const char *cmd) { … }

bool SBCommandInterpreter::AliasExists(const char *cmd) { … }

bool SBCommandInterpreter::IsActive() { … }

bool SBCommandInterpreter::WasInterrupted() const { … }

bool SBCommandInterpreter::InterruptCommand() { … }

const char *SBCommandInterpreter::GetIOHandlerControlSequence(char ch) { … }

lldb::ReturnStatus
SBCommandInterpreter::HandleCommand(const char *command_line,
                                    SBCommandReturnObject &result,
                                    bool add_to_history) { … }

lldb::ReturnStatus SBCommandInterpreter::HandleCommand(
    const char *command_line, SBExecutionContext &override_context,
    SBCommandReturnObject &result, bool add_to_history) { … }

void SBCommandInterpreter::HandleCommandsFromFile(
    lldb::SBFileSpec &file, lldb::SBExecutionContext &override_context,
    lldb::SBCommandInterpreterRunOptions &options,
    lldb::SBCommandReturnObject result) { … }

int SBCommandInterpreter::HandleCompletion(
    const char *current_line, const char *cursor, const char *last_char,
    int match_start_point, int max_return_elements, SBStringList &matches) { … }

int SBCommandInterpreter::HandleCompletionWithDescriptions(
    const char *current_line, const char *cursor, const char *last_char,
    int match_start_point, int max_return_elements, SBStringList &matches,
    SBStringList &descriptions) { … }

int SBCommandInterpreter::HandleCompletionWithDescriptions(
    const char *current_line, uint32_t cursor_pos, int match_start_point,
    int max_return_elements, SBStringList &matches,
    SBStringList &descriptions) { … }

int SBCommandInterpreter::HandleCompletion(const char *current_line,
                                           uint32_t cursor_pos,
                                           int match_start_point,
                                           int max_return_elements,
                                           lldb::SBStringList &matches) { … }

bool SBCommandInterpreter::HasCommands() { … }

bool SBCommandInterpreter::HasAliases() { … }

bool SBCommandInterpreter::HasAliasOptions() { … }

bool SBCommandInterpreter::IsInteractive() { … }

SBProcess SBCommandInterpreter::GetProcess() { … }

SBDebugger SBCommandInterpreter::GetDebugger() { … }

bool SBCommandInterpreter::GetPromptOnQuit() { … }

void SBCommandInterpreter::SetPromptOnQuit(bool b) { … }

void SBCommandInterpreter::AllowExitCodeOnQuit(bool allow) { … }

bool SBCommandInterpreter::HasCustomQuitExitCode() { … }

int SBCommandInterpreter::GetQuitStatus() { … }

void SBCommandInterpreter::ResolveCommand(const char *command_line,
                                          SBCommandReturnObject &result) { … }

CommandInterpreter *SBCommandInterpreter::get() { … }

CommandInterpreter &SBCommandInterpreter::ref() { … }

void SBCommandInterpreter::reset(
    lldb_private::CommandInterpreter *interpreter) { … }

void SBCommandInterpreter::SourceInitFileInGlobalDirectory(
    SBCommandReturnObject &result) { … }

void SBCommandInterpreter::SourceInitFileInHomeDirectory(
    SBCommandReturnObject &result) { … }

void SBCommandInterpreter::SourceInitFileInHomeDirectory(
    SBCommandReturnObject &result, bool is_repl) { … }

void SBCommandInterpreter::SourceInitFileInCurrentWorkingDirectory(
    SBCommandReturnObject &result) { … }

SBBroadcaster SBCommandInterpreter::GetBroadcaster() { … }

const char *SBCommandInterpreter::GetBroadcasterClass() { … }

const char *SBCommandInterpreter::GetArgumentTypeAsCString(
    const lldb::CommandArgumentType arg_type) { … }

const char *SBCommandInterpreter::GetArgumentDescriptionAsCString(
    const lldb::CommandArgumentType arg_type) { … }

bool SBCommandInterpreter::EventIsCommandInterpreterEvent(
    const lldb::SBEvent &event) { … }

bool SBCommandInterpreter::SetCommandOverrideCallback(
    const char *command_name, lldb::CommandOverrideCallback callback,
    void *baton) { … }

SBStructuredData SBCommandInterpreter::GetStatistics() { … }

SBStructuredData SBCommandInterpreter::GetTranscript() { … }

lldb::SBCommand SBCommandInterpreter::AddMultiwordCommand(const char *name,
                                                          const char *help) { … }

lldb::SBCommand SBCommandInterpreter::AddCommand(
    const char *name, lldb::SBCommandPluginInterface *impl, const char *help) { … }

lldb::SBCommand
SBCommandInterpreter::AddCommand(const char *name,
                                 lldb::SBCommandPluginInterface *impl,
                                 const char *help, const char *syntax) { … }

lldb::SBCommand SBCommandInterpreter::AddCommand(
    const char *name, lldb::SBCommandPluginInterface *impl, const char *help,
    const char *syntax, const char *auto_repeat_command) { … }

SBCommand::SBCommand() { … }

SBCommand::SBCommand(lldb::CommandObjectSP cmd_sp) : … { … }

bool SBCommand::IsValid() { … }
operator bool()

const char *SBCommand::GetName() { … }

const char *SBCommand::GetHelp() { … }

const char *SBCommand::GetHelpLong() { … }

void SBCommand::SetHelp(const char *help) { … }

void SBCommand::SetHelpLong(const char *help) { … }

lldb::SBCommand SBCommand::AddMultiwordCommand(const char *name,
                                               const char *help) { … }

lldb::SBCommand SBCommand::AddCommand(const char *name,
                                      lldb::SBCommandPluginInterface *impl,
                                      const char *help) { … }

lldb::SBCommand SBCommand::AddCommand(const char *name,
                                      lldb::SBCommandPluginInterface *impl,
                                      const char *help, const char *syntax) { … }

lldb::SBCommand SBCommand::AddCommand(const char *name,
                                      lldb::SBCommandPluginInterface *impl,
                                      const char *help, const char *syntax,
                                      const char *auto_repeat_command) { … }

uint32_t SBCommand::GetFlags() { … }

void SBCommand::SetFlags(uint32_t flags) { … }
llvm/lldb/source/API/SBCommandInterpreter.cpp
