llvm/lldb/source/DataFormatters/TypeSynthetic.cpp

//===-- TypeSynthetic.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/lldb-enumerations.h"
#include "lldb/lldb-public.h"

#include "lldb/Core/Debugger.h"
#include "lldb/DataFormatters/TypeSynthetic.h"
#include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Interpreter/ScriptInterpreter.h"
#include "lldb/Symbol/CompilerType.h"
#include "lldb/Target/Target.h"
#include "lldb/Utility/StreamString.h"

usingnamespacelldb;
usingnamespacelldb_private;

void TypeFilterImpl::AddExpressionPath(const std::string &path) { … }

bool TypeFilterImpl::SetExpressionPathAtIndex(size_t i,
                                              const std::string &path) { … }

size_t
TypeFilterImpl::FrontEnd::GetIndexOfChildWithName(ConstString name) { … }

std::string TypeFilterImpl::GetDescription() { … }

SyntheticChildren::SyntheticChildren(const Flags &flags) : … { … }

SyntheticChildren::~SyntheticChildren() = default;

CXXSyntheticChildren::CXXSyntheticChildren(
    const SyntheticChildren::Flags &flags, const char *description,
    CreateFrontEndCallback callback)
    : … { … }

CXXSyntheticChildren::~CXXSyntheticChildren() = default;

bool SyntheticChildren::IsScripted() { … }

std::string SyntheticChildren::GetDescription() { … }

SyntheticChildrenFrontEnd::AutoPointer
SyntheticChildren::GetFrontEnd(ValueObject &backend) { … }

std::string CXXSyntheticChildren::GetDescription() { … }

uint32_t
SyntheticChildrenFrontEnd::CalculateNumChildrenIgnoringErrors(uint32_t max) { … }

lldb::ValueObjectSP SyntheticChildrenFrontEnd::CreateValueObjectFromExpression(
    llvm::StringRef name, llvm::StringRef expression,
    const ExecutionContext &exe_ctx) { … }

lldb::ValueObjectSP SyntheticChildrenFrontEnd::CreateValueObjectFromAddress(
    llvm::StringRef name, uint64_t address, const ExecutionContext &exe_ctx,
    CompilerType type) { … }

lldb::ValueObjectSP SyntheticChildrenFrontEnd::CreateValueObjectFromData(
    llvm::StringRef name, const DataExtractor &data,
    const ExecutionContext &exe_ctx, CompilerType type) { … }

ScriptedSyntheticChildren::FrontEnd::FrontEnd(std::string pclass,
                                              ValueObject &backend)
    : … { … }

ScriptedSyntheticChildren::FrontEnd::~FrontEnd() = default;

lldb::ValueObjectSP
ScriptedSyntheticChildren::FrontEnd::GetChildAtIndex(uint32_t idx) { … }

bool ScriptedSyntheticChildren::FrontEnd::IsValid() { … }

llvm::Expected<uint32_t>
ScriptedSyntheticChildren::FrontEnd::CalculateNumChildren() { … }

llvm::Expected<uint32_t>
ScriptedSyntheticChildren::FrontEnd::CalculateNumChildren(uint32_t max) { … }

lldb::ChildCacheState ScriptedSyntheticChildren::FrontEnd::Update() { … }

bool ScriptedSyntheticChildren::FrontEnd::MightHaveChildren() { … }

size_t ScriptedSyntheticChildren::FrontEnd::GetIndexOfChildWithName(
    ConstString name) { … }

lldb::ValueObjectSP ScriptedSyntheticChildren::FrontEnd::GetSyntheticValue() { … }

ConstString ScriptedSyntheticChildren::FrontEnd::GetSyntheticTypeName() { … }

std::string ScriptedSyntheticChildren::GetDescription() { … }