SBBreakpointName.cpp | Explore in Territory

//===-- SBBreakpointName.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/API/SBBreakpointName.h"
#include "lldb/API/SBDebugger.h"
#include "lldb/API/SBError.h"
#include "lldb/API/SBStream.h"
#include "lldb/API/SBStringList.h"
#include "lldb/API/SBStructuredData.h"
#include "lldb/API/SBTarget.h"
#include "lldb/Utility/Instrumentation.h"

#include "lldb/Breakpoint/BreakpointName.h"
#include "lldb/Breakpoint/StoppointCallbackContext.h"
#include "lldb/Core/Debugger.h"
#include "lldb/Core/StructuredDataImpl.h"
#include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Interpreter/ScriptInterpreter.h"
#include "lldb/Target/Target.h"
#include "lldb/Target/ThreadSpec.h"
#include "lldb/Utility/Stream.h"

#include "SBBreakpointOptionCommon.h"

usingnamespacelldb;
usingnamespacelldb_private;

namespace lldb
{
class SBBreakpointNameImpl { … };

SBBreakpointNameImpl::SBBreakpointNameImpl(SBTarget &sb_target,
                                           const char *name) { … }

bool SBBreakpointNameImpl::operator==(const SBBreakpointNameImpl &rhs) { … }

bool SBBreakpointNameImpl::operator!=(const SBBreakpointNameImpl &rhs) { … }

lldb_private::BreakpointName *SBBreakpointNameImpl::GetBreakpointName() const { … }

} // namespace lldb

SBBreakpointName::SBBreakpointName() { … }

SBBreakpointName::SBBreakpointName(SBTarget &sb_target, const char *name) { … }

SBBreakpointName::SBBreakpointName(SBBreakpoint &sb_bkpt, const char *name) { … }

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

SBBreakpointName::~SBBreakpointName() = default;

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

bool SBBreakpointName::operator==(const lldb::SBBreakpointName &rhs) { … }

bool SBBreakpointName::operator!=(const lldb::SBBreakpointName &rhs) { … }

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

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

void SBBreakpointName::SetEnabled(bool enable) { … }

void SBBreakpointName::UpdateName(BreakpointName &bp_name) { … }

bool SBBreakpointName::IsEnabled() { … }

void SBBreakpointName::SetOneShot(bool one_shot) { … }

bool SBBreakpointName::IsOneShot() const { … }

void SBBreakpointName::SetIgnoreCount(uint32_t count) { … }

uint32_t SBBreakpointName::GetIgnoreCount() const { … }

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

const char *SBBreakpointName::GetCondition() { … }

void SBBreakpointName::SetAutoContinue(bool auto_continue) { … }

bool SBBreakpointName::GetAutoContinue() { … }

void SBBreakpointName::SetThreadID(lldb::tid_t tid) { … }

lldb::tid_t SBBreakpointName::GetThreadID() { … }

void SBBreakpointName::SetThreadIndex(uint32_t index) { … }

uint32_t SBBreakpointName::GetThreadIndex() const { … }

void SBBreakpointName::SetThreadName(const char *thread_name) { … }

const char *SBBreakpointName::GetThreadName() const { … }

void SBBreakpointName::SetQueueName(const char *queue_name) { … }

const char *SBBreakpointName::GetQueueName() const { … }

void SBBreakpointName::SetCommandLineCommands(SBStringList &commands) { … }

bool SBBreakpointName::GetCommandLineCommands(SBStringList &commands) { … }

const char *SBBreakpointName::GetHelpString() const { … }

void SBBreakpointName::SetHelpString(const char *help_string) { … }

bool SBBreakpointName::GetDescription(SBStream &s) { … }

void SBBreakpointName::SetCallback(SBBreakpointHitCallback callback,
                                   void *baton) { … }

void SBBreakpointName::SetScriptCallbackFunction(
  const char *callback_function_name) { … }

SBError SBBreakpointName::SetScriptCallbackFunction(
    const char *callback_function_name, 
    SBStructuredData &extra_args) { … }

SBError
SBBreakpointName::SetScriptCallbackBody(const char *callback_body_text) { … }

bool SBBreakpointName::GetAllowList() const { … }

void SBBreakpointName::SetAllowList(bool value) { … }

bool SBBreakpointName::GetAllowDelete() { … }

void SBBreakpointName::SetAllowDelete(bool value) { … }

bool SBBreakpointName::GetAllowDisable() { … }

void SBBreakpointName::SetAllowDisable(bool value) { … }

lldb_private::BreakpointName *SBBreakpointName::GetBreakpointName() const
{ … }
llvm/lldb/source/API/SBBreakpointName.cpp
