1 //===-- Language.h ---------------------------------------------------*- C++
4 // The LLVM Compiler Infrastructure
6 // This file is distributed under the University of Illinois Open Source
7 // License. See LICENSE.TXT for details.
9 //===----------------------------------------------------------------------===//
11 #ifndef liblldb_Language_h_
12 #define liblldb_Language_h_
21 // Other libraries and framework includes
23 #include "lldb/Core/PluginInterface.h"
24 #include "lldb/DataFormatters/DumpValueObjectOptions.h"
25 #include "lldb/DataFormatters/FormatClasses.h"
26 #include "lldb/DataFormatters/StringPrinter.h"
27 #include "lldb/lldb-private.h"
28 #include "lldb/lldb-public.h"
30 namespace lldb_private {
32 class Language : public PluginInterface {
38 virtual bool IsValid() = 0;
40 virtual bool DumpToStream(Stream &stream,
41 bool print_help_if_available) = 0;
43 virtual ~Result() = default;
46 typedef std::set<std::unique_ptr<Result>> ResultSet;
48 virtual ~TypeScavenger() = default;
50 size_t Find(ExecutionContextScope *exe_scope, const char *key,
51 ResultSet &results, bool append = true);
54 TypeScavenger() = default;
56 virtual bool Find_Impl(ExecutionContextScope *exe_scope, const char *key,
57 ResultSet &results) = 0;
60 class ImageListTypeScavenger : public TypeScavenger {
61 class Result : public Language::TypeScavenger::Result {
63 Result(CompilerType type)
64 : Language::TypeScavenger::Result(), m_compiler_type(type) {}
66 bool IsValid() override { return m_compiler_type.IsValid(); }
68 bool DumpToStream(Stream &stream, bool print_help_if_available) override {
70 m_compiler_type.DumpTypeDescription(&stream);
77 ~Result() override = default;
80 CompilerType m_compiler_type;
84 ImageListTypeScavenger() = default;
86 ~ImageListTypeScavenger() override = default;
88 // is this type something we should accept? it's usually going to be a
89 // filter by language + maybe some sugar tweaking
90 // returning an empty type means rejecting this candidate entirely;
91 // any other result will be accepted as a valid match
92 virtual CompilerType AdjustForInclusion(CompilerType &candidate) = 0;
94 bool Find_Impl(ExecutionContextScope *exe_scope, const char *key,
95 ResultSet &results) override;
98 template <typename... ScavengerTypes>
99 class EitherTypeScavenger : public TypeScavenger {
101 EitherTypeScavenger() : TypeScavenger(), m_scavengers() {
102 for (std::shared_ptr<TypeScavenger> scavenger : { std::shared_ptr<TypeScavenger>(new ScavengerTypes())... }) {
104 m_scavengers.push_back(scavenger);
108 bool Find_Impl(ExecutionContextScope *exe_scope, const char *key,
109 ResultSet &results) override {
110 const bool append = false;
111 for (auto& scavenger : m_scavengers) {
112 if (scavenger && scavenger->Find(exe_scope, key, results, append))
118 std::vector<std::shared_ptr<TypeScavenger>> m_scavengers;
121 template <typename... ScavengerTypes>
122 class UnionTypeScavenger : public TypeScavenger {
124 UnionTypeScavenger() : TypeScavenger(), m_scavengers() {
125 for (std::shared_ptr<TypeScavenger> scavenger : { std::shared_ptr<TypeScavenger>(new ScavengerTypes())... }) {
127 m_scavengers.push_back(scavenger);
131 bool Find_Impl(ExecutionContextScope *exe_scope, const char *key,
132 ResultSet &results) override {
133 const bool append = true;
134 bool success = false;
135 for (auto& scavenger : m_scavengers) {
137 success = scavenger->Find(exe_scope, key, results, append) || success;
142 std::vector<std::shared_ptr<TypeScavenger>> m_scavengers;
145 enum class FunctionNameRepresentation {
151 ~Language() override;
153 static Language *FindPlugin(lldb::LanguageType language);
155 // return false from callback to stop iterating
156 static void ForEach(std::function<bool(Language *)> callback);
158 virtual lldb::LanguageType GetLanguageType() const = 0;
160 virtual bool IsTopLevelFunction(Function &function);
162 virtual lldb::TypeCategoryImplSP GetFormatters();
164 virtual HardcodedFormatters::HardcodedFormatFinder GetHardcodedFormats();
166 virtual HardcodedFormatters::HardcodedSummaryFinder GetHardcodedSummaries();
168 virtual HardcodedFormatters::HardcodedSyntheticFinder
169 GetHardcodedSynthetics();
171 virtual HardcodedFormatters::HardcodedValidatorFinder
172 GetHardcodedValidators();
174 virtual std::vector<ConstString>
175 GetPossibleFormattersMatches(ValueObject &valobj,
176 lldb::DynamicValueType use_dynamic);
178 virtual lldb_private::formatters::StringPrinter::EscapingHelper
179 GetStringPrinterEscapingHelper(
180 lldb_private::formatters::StringPrinter::GetPrintableElementType);
182 virtual std::unique_ptr<TypeScavenger> GetTypeScavenger();
184 virtual const char *GetLanguageSpecificTypeLookupHelp();
186 // if an individual data formatter can apply to several types and cross a
188 // it makes sense for individual languages to want to customize the printing
190 // type by appending proper prefix/suffix information in language-specific
192 virtual bool GetFormatterPrefixSuffix(ValueObject &valobj,
193 ConstString type_hint,
195 std::string &suffix);
197 // if a language has a custom format for printing variable declarations that
198 // it wants LLDB to honor
199 // it should return an appropriate closure here
200 virtual DumpValueObjectOptions::DeclPrintingHelper GetDeclPrintingHelper();
202 virtual LazyBool IsLogicalTrue(ValueObject &valobj, Status &error);
204 // for a ValueObject of some "reference type", if the value points to the
205 // nil/null object, this method returns true
206 virtual bool IsNilReference(ValueObject &valobj);
208 // for a ValueObject of some "reference type", if the language provides a
210 // to decide whether the reference has ever been assigned to some object, this
212 // will return true if such detection is possible, and if the reference has
213 // never been assigned
214 virtual bool IsUninitializedReference(ValueObject &valobj);
216 virtual bool GetFunctionDisplayName(const SymbolContext *sc,
217 const ExecutionContext *exe_ctx,
218 FunctionNameRepresentation representation,
221 virtual void GetExceptionResolverDescription(bool catch_on, bool throw_on,
224 static void GetDefaultExceptionResolverDescription(bool catch_on,
225 bool throw_on, Stream &s);
227 // These are accessors for general information about the Languages lldb knows
230 static lldb::LanguageType
231 GetLanguageTypeFromString(const char *string) = delete;
232 static lldb::LanguageType GetLanguageTypeFromString(llvm::StringRef string);
234 static const char *GetNameForLanguageType(lldb::LanguageType language);
236 static void PrintAllLanguages(Stream &s, const char *prefix,
239 // return false from callback to stop iterating
240 static void ForAllLanguages(std::function<bool(lldb::LanguageType)> callback);
242 static bool LanguageIsCPlusPlus(lldb::LanguageType language);
244 static bool LanguageIsObjC(lldb::LanguageType language);
246 static bool LanguageIsC(lldb::LanguageType language);
248 static bool LanguageIsPascal(lldb::LanguageType language);
250 // return the primary language, so if LanguageIsC(l), return eLanguageTypeC,
252 static lldb::LanguageType GetPrimaryLanguage(lldb::LanguageType language);
254 static void GetLanguagesSupportingTypeSystems(
255 std::set<lldb::LanguageType> &languages,
256 std::set<lldb::LanguageType> &languages_for_expressions);
259 GetLanguagesSupportingREPLs(std::set<lldb::LanguageType> &languages);
262 //------------------------------------------------------------------
263 // Classes that inherit from Language can see and modify these
264 //------------------------------------------------------------------
269 DISALLOW_COPY_AND_ASSIGN(Language);
272 } // namespace lldb_private
274 #endif // liblldb_Language_h_