llvm/lldb/source/Breakpoint/BreakpointOptions.cpp

//===-- BreakpointOptions.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/Breakpoint/BreakpointOptions.h"

#include "lldb/Breakpoint/StoppointCallbackContext.h"
#include "lldb/Core/Value.h"
#include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Interpreter/CommandReturnObject.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/Target.h"
#include "lldb/Target/ThreadSpec.h"
#include "lldb/Utility/Stream.h"
#include "lldb/Utility/StringList.h"

#include "llvm/ADT/STLExtras.h"

usingnamespacelldb;
usingnamespacelldb_private;

const char
    *BreakpointOptions::CommandData::g_option_names[static_cast<uint32_t>(
        BreakpointOptions::CommandData::OptionNames::LastOptionName)]{ … };

StructuredData::ObjectSP
BreakpointOptions::CommandData::SerializeToStructuredData() { … }

std::unique_ptr<BreakpointOptions::CommandData>
BreakpointOptions::CommandData::CreateFromStructuredData(
    const StructuredData::Dictionary &options_dict, Status &error) { … }

const char *BreakpointOptions::g_option_names[(
    size_t)BreakpointOptions::OptionNames::LastOptionName]{ … };

// BreakpointOptions constructor
BreakpointOptions::BreakpointOptions(bool all_flags_set)
    : … { … }

BreakpointOptions::BreakpointOptions(const char *condition, bool enabled,
                                     int32_t ignore, bool one_shot, 
                                     bool auto_continue)
    : … { … }

// BreakpointOptions copy constructor
BreakpointOptions::BreakpointOptions(const BreakpointOptions &rhs)
    : … { … }

// BreakpointOptions assignment operator
const BreakpointOptions &BreakpointOptions::
operator=(const BreakpointOptions &rhs) { … }

void BreakpointOptions::CopyOverSetOptions(const BreakpointOptions &incoming)
{ … }

// Destructor
BreakpointOptions::~BreakpointOptions() = default;

std::unique_ptr<BreakpointOptions> BreakpointOptions::CreateFromStructuredData(
    Target &target, const StructuredData::Dictionary &options_dict,
    Status &error) { … }

StructuredData::ObjectSP BreakpointOptions::SerializeToStructuredData() { … }

// Callbacks
void BreakpointOptions::SetCallback(BreakpointHitCallback callback,
                                    const lldb::BatonSP &callback_baton_sp,
                                    bool callback_is_synchronous) { … }

void BreakpointOptions::SetCallback(
    BreakpointHitCallback callback,
    const BreakpointOptions::CommandBatonSP &callback_baton_sp,
    bool callback_is_synchronous) { … }

void BreakpointOptions::ClearCallback() { … }

Baton *BreakpointOptions::GetBaton() { … }

const Baton *BreakpointOptions::GetBaton() const { … }

bool BreakpointOptions::InvokeCallback(StoppointCallbackContext *context,
                                       lldb::user_id_t break_id,
                                       lldb::user_id_t break_loc_id) { … }

bool BreakpointOptions::HasCallback() const { … }

bool BreakpointOptions::GetCommandLineCallbacks(StringList &command_list) { … }

void BreakpointOptions::SetCondition(const char *condition) { … }

const char *BreakpointOptions::GetConditionText(size_t *hash) const { … }

const ThreadSpec *BreakpointOptions::GetThreadSpecNoCreate() const { … }

ThreadSpec *BreakpointOptions::GetThreadSpec() { … }

void BreakpointOptions::SetThreadID(lldb::tid_t thread_id) { … }

void BreakpointOptions::SetThreadSpec(
    std::unique_ptr<ThreadSpec> &thread_spec_up) { … }

void BreakpointOptions::GetDescription(Stream *s,
                                       lldb::DescriptionLevel level) const { … }

void BreakpointOptions::CommandBaton::GetDescription(
    llvm::raw_ostream &s, lldb::DescriptionLevel level,
    unsigned indentation) const { … }

void BreakpointOptions::SetCommandDataCallback(
    std::unique_ptr<CommandData> &cmd_data) { … }

bool BreakpointOptions::BreakpointOptionsCallbackFunction(
    void *baton, StoppointCallbackContext *context, lldb::user_id_t break_id,
    lldb::user_id_t break_loc_id) { … }

void BreakpointOptions::Clear()
{ … }