Language.cpp | Explore in Territory

//===-- Language.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 <functional>
#include <map>
#include <mutex>

#include "lldb/Target/Language.h"

#include "lldb/Core/PluginManager.h"
#include "lldb/Interpreter/OptionValueProperties.h"
#include "lldb/Symbol/SymbolFile.h"
#include "lldb/Symbol/TypeList.h"
#include "lldb/Target/Target.h"
#include "lldb/Utility/Stream.h"

#include "llvm/BinaryFormat/Dwarf.h"
#include "llvm/Support/Threading.h"

usingnamespacelldb;
usingnamespacelldb_private;
usingnamespacelldb_private::formatters;

LanguageUP;
LanguagesMap;

#define LLDB_PROPERTIES_language
#include "TargetProperties.inc"

enum { … };

LanguageProperties &Language::GetGlobalLanguageProperties() { … }

llvm::StringRef LanguageProperties::GetSettingName() { … }

LanguageProperties::LanguageProperties() { … }

bool LanguageProperties::GetEnableFilterForLineBreakpoints() const { … }

static LanguagesMap &GetLanguagesMap() { … }
static std::mutex &GetLanguagesMutex() { … }

Language *Language::FindPlugin(lldb::LanguageType language) { … }

Language *Language::FindPlugin(llvm::StringRef file_path) { … }

Language *Language::FindPlugin(LanguageType language,
                               llvm::StringRef file_path) { … }

void Language::ForEach(std::function<bool(Language *)> callback) { … }

bool Language::IsTopLevelFunction(Function &function) { … }

lldb::TypeCategoryImplSP Language::GetFormatters() { … }

HardcodedFormatters::HardcodedFormatFinder Language::GetHardcodedFormats() { … }

HardcodedFormatters::HardcodedSummaryFinder Language::GetHardcodedSummaries() { … }

HardcodedFormatters::HardcodedSyntheticFinder
Language::GetHardcodedSynthetics() { … }

std::vector<FormattersMatchCandidate>
Language::GetPossibleFormattersMatches(ValueObject &valobj,
                                       lldb::DynamicValueType use_dynamic) { … }

struct language_name_pair { … };

struct language_name_pair language_names[] = …;

static uint32_t num_languages = …;

LanguageType Language::GetLanguageTypeFromString(llvm::StringRef string) { … }

const char *Language::GetNameForLanguageType(LanguageType language) { … }

void Language::PrintSupportedLanguagesForExpressions(Stream &s,
                                                     llvm::StringRef prefix,
                                                     llvm::StringRef suffix) { … }

void Language::PrintAllLanguages(Stream &s, const char *prefix,
                                 const char *suffix) { … }

void Language::ForAllLanguages(
    std::function<bool(lldb::LanguageType)> callback) { … }

bool Language::LanguageIsCPlusPlus(LanguageType language) { … }

bool Language::LanguageIsObjC(LanguageType language) { … }

bool Language::LanguageIsC(LanguageType language) { … }

bool Language::LanguageIsCFamily(LanguageType language) { … }

bool Language::LanguageIsPascal(LanguageType language) { … }

LanguageType Language::GetPrimaryLanguage(LanguageType language) { … }

std::set<lldb::LanguageType> Language::GetSupportedLanguages() { … }

LanguageSet Language::GetLanguagesSupportingTypeSystems() { … }

LanguageSet Language::GetLanguagesSupportingTypeSystemsForExpressions() { … }

LanguageSet Language::GetLanguagesSupportingREPLs() { … }

std::unique_ptr<Language::TypeScavenger> Language::GetTypeScavenger() { … }

const char *Language::GetLanguageSpecificTypeLookupHelp() { … }

size_t Language::TypeScavenger::Find(ExecutionContextScope *exe_scope,
                                     const char *key, ResultSet &results,
                                     bool append) { … }

bool Language::ImageListTypeScavenger::Find_Impl(
    ExecutionContextScope *exe_scope, const char *key, ResultSet &results) { … }

std::pair<llvm::StringRef, llvm::StringRef>
Language::GetFormatterPrefixSuffix(llvm::StringRef type_hint) { … }

bool Language::DemangledNameContainsPath(llvm::StringRef path,
                                         ConstString demangled) const { … }

DumpValueObjectOptions::DeclPrintingHelper Language::GetDeclPrintingHelper() { … }

LazyBool Language::IsLogicalTrue(ValueObject &valobj, Status &error) { … }

bool Language::IsNilReference(ValueObject &valobj) { … }

bool Language::IsUninitializedReference(ValueObject &valobj) { … }

bool Language::GetFunctionDisplayName(const SymbolContext *sc,
                                      const ExecutionContext *exe_ctx,
                                      FunctionNameRepresentation representation,
                                      Stream &s) { … }

void Language::GetExceptionResolverDescription(bool catch_on, bool throw_on,
                                               Stream &s) { … }

void Language::GetDefaultExceptionResolverDescription(bool catch_on,
                                                      bool throw_on,
                                                      Stream &s) { … }
// Constructor
Language::Language() = default;

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

SourceLanguage::SourceLanguage(lldb::LanguageType language_type) { … }

lldb::LanguageType SourceLanguage::AsLanguageType() const { … }

llvm::StringRef SourceLanguage::GetDescription() const { … }
bool SourceLanguage::IsC() const { … }

bool SourceLanguage::IsObjC() const { … }

bool SourceLanguage::IsCPlusPlus() const { … }
llvm/lldb/source/Target/Language.cpp
