LLDB mainline
Property.cpp
Go to the documentation of this file.
1//===-- Property.cpp ------------------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
10
16
17#include <memory>
18
19using namespace lldb;
20using namespace lldb_private;
21
23 : m_name(definition.name), m_description(definition.description),
24 m_is_global(definition.global) {
25 switch (definition.type) {
28 break;
30 // "definition.default_uint_value" is not used
31 // "definition.default_cstr_value" as a string value that represents the
32 // default string value for the architecture/triple
34 std::make_shared<OptionValueArch>(definition.default_cstr_value);
35 break;
36
38 // "definition.default_uint_value" is always a OptionValue::Type
39 m_value_sp = std::make_shared<OptionValueArgs>();
40 break;
41
43 // "definition.default_uint_value" is always a OptionValue::Type
45 std::make_shared<OptionValueArray>(OptionValue::ConvertTypeToMask(
47 break;
48
50 // "definition.default_uint_value" is the default boolean value if
51 // "definition.default_cstr_value" is NULL, otherwise interpret
52 // "definition.default_cstr_value" as a string value that represents the
53 // default value.
54 if (definition.default_cstr_value)
56 std::make_shared<OptionValueBoolean>(OptionArgParser::ToBoolean(
57 llvm::StringRef(definition.default_cstr_value), false, nullptr));
58 else
59 m_value_sp = std::make_shared<OptionValueBoolean>(
60 definition.default_uint_value != 0);
61 break;
62
64 llvm::StringRef s(definition.default_cstr_value ? definition.default_cstr_value : "");
65 m_value_sp = std::make_shared<OptionValueChar>(
66 OptionArgParser::ToChar(s, '\0', nullptr));
67 break;
68 }
70 // "definition.default_uint_value" is always a OptionValue::Type
71 m_value_sp = std::make_shared<OptionValueDictionary>(
74 definition.enum_values);
75 break;
76
78 // "definition.default_uint_value" is the default enumeration value if
79 // "definition.default_cstr_value" is NULL, otherwise interpret
80 // "definition.default_cstr_value" as a string value that represents the
81 // default value.
82 {
84 definition.enum_values, definition.default_uint_value);
85 m_value_sp.reset(enum_value);
86 if (definition.default_cstr_value) {
87 if (enum_value
88 ->SetValueFromString(
89 llvm::StringRef(definition.default_cstr_value))
90 .Success()) {
91 enum_value->SetDefaultValue(enum_value->GetCurrentValue());
92 // Call Clear() since we don't want the value to appear as having
93 // been set since we called SetValueFromString() above. Clear will
94 // set the current value to the default and clear the boolean that
95 // says that the value has been set.
96 enum_value->Clear();
97 }
98 }
99 }
100 break;
101
103 // "definition.default_uint_value" is not used for a
104 // OptionValue::eTypeFileSpecList
105 m_value_sp = std::make_shared<OptionValueFileColonLine>();
106 break;
107
109 // "definition.default_uint_value" represents if the
110 // "definition.default_cstr_value" should be resolved or not
111 const bool resolve = definition.default_uint_value != 0;
112 FileSpec file_spec = FileSpec(definition.default_cstr_value);
113 if (resolve)
114 FileSystem::Instance().Resolve(file_spec);
115 m_value_sp = std::make_shared<OptionValueFileSpec>(file_spec, resolve);
116 break;
117 }
118
120 // "definition.default_uint_value" is not used for a
121 // OptionValue::eTypeFileSpecList
122 m_value_sp = std::make_shared<OptionValueFileSpecList>();
123 break;
124
126 // "definition.default_uint_value" is the default format enumeration value
127 // if "definition.default_cstr_value" is NULL, otherwise interpret
128 // "definition.default_cstr_value" as a string value that represents the
129 // default value.
130 {
131 Format new_format = eFormatInvalid;
132 if (definition.default_cstr_value)
133 OptionArgParser::ToFormat(definition.default_cstr_value, new_format,
134 nullptr);
135 else
136 new_format = (Format)definition.default_uint_value;
137 m_value_sp = std::make_shared<OptionValueFormat>(new_format);
138 }
139 break;
140
142 // "definition.default_uint_value" is the default language enumeration
143 // value if "definition.default_cstr_value" is NULL, otherwise interpret
144 // "definition.default_cstr_value" as a string value that represents the
145 // default value.
146 {
148 if (definition.default_cstr_value)
150 llvm::StringRef(definition.default_cstr_value));
151 else
152 new_lang = (LanguageType)definition.default_uint_value;
153 m_value_sp = std::make_shared<OptionValueLanguage>(new_lang);
154 }
155 break;
156
158 // "definition.default_cstr_value" as a string value that represents the
159 // default
160 m_value_sp = std::make_shared<OptionValueFormatEntity>(
161 definition.default_cstr_value);
162 break;
163
165 // "definition.default_uint_value" tells us if notifications should occur
166 // for path mappings
167 m_value_sp = std::make_shared<OptionValuePathMappings>(
168 definition.default_uint_value != 0);
169 break;
170
172 // "definition.default_uint_value" is used to the regular expression flags
173 // "definition.default_cstr_value" the default regular expression value
174 // value.
175 m_value_sp =
176 std::make_shared<OptionValueRegex>(definition.default_cstr_value);
177 break;
178
180 // "definition.default_uint_value" is the default integer value if
181 // "definition.default_cstr_value" is NULL, otherwise interpret
182 // "definition.default_cstr_value" as a string value that represents the
183 // default value.
184 int64_t value = 0;
185 // FIXME: improve error handling for llvm::to_integer()
186 if (definition.default_cstr_value)
187 llvm::to_integer(definition.default_cstr_value, value);
188 m_value_sp = std::make_shared<OptionValueSInt64>(
189 definition.default_cstr_value ? value : definition.default_uint_value);
190 break;
191 }
193 uint64_t value = 0;
194 // FIXME: improve error handling for llvm::to_integer()
195 if (definition.default_cstr_value)
196 llvm::to_integer(definition.default_cstr_value, value);
197 // "definition.default_uint_value" is the default unsigned integer value if
198 // "definition.default_cstr_value" is NULL, otherwise interpret
199 // "definition.default_cstr_value" as a string value that represents the
200 // default value.
201 m_value_sp = std::make_shared<OptionValueUInt64>(
202 definition.default_cstr_value ? value : definition.default_uint_value);
203 break;
204 }
206 // "definition.default_uint_value" is not used for a OptionValue::eTypeUUID
207 // "definition.default_cstr_value" can contain a default UUID value
208 {
209 UUID uuid;
210 if (definition.default_cstr_value)
211 uuid.SetFromStringRef(definition.default_cstr_value);
212 m_value_sp = std::make_shared<OptionValueUUID>(uuid);
213 }
214 break;
215
217 // "definition.default_uint_value" can contain the string option flags
218 // OR'ed together "definition.default_cstr_value" can contain a default
219 // string value
220 {
221 OptionValueString *string_value =
223 if (definition.default_uint_value != 0)
224 string_value->GetOptions().Reset(definition.default_uint_value);
225 m_value_sp.reset(string_value);
226 }
227 break;
228 }
229}
230
231Property::Property(llvm::StringRef name, llvm::StringRef desc, bool is_global,
232 const lldb::OptionValueSP &value_sp)
233 : m_name(name), m_description(desc), m_value_sp(value_sp),
234 m_is_global(is_global) {}
235
237 if (!m_name.empty()) {
238 if (m_value_sp->DumpQualifiedName(strm))
239 strm.PutChar('.');
240 strm << m_name;
241 return true;
242 }
243 return false;
244}
245
246void Property::Dump(const ExecutionContext *exe_ctx, Stream &strm,
247 uint32_t dump_mask) const {
248 if (m_value_sp) {
249 const bool dump_desc = dump_mask & OptionValue::eDumpOptionDescription;
250 const bool dump_cmd = dump_mask & OptionValue::eDumpOptionCommand;
251 const bool transparent = m_value_sp->ValueIsTransparent();
252 if (dump_cmd && !transparent)
253 strm << "settings set -f ";
254 if (dump_desc || !transparent) {
255 if ((dump_mask & OptionValue::eDumpOptionName) && !m_name.empty()) {
256 DumpQualifiedName(strm);
257 if (dump_mask & ~OptionValue::eDumpOptionName)
258 strm.PutChar(' ');
259 }
260 }
261 if (dump_desc) {
262 llvm::StringRef desc = GetDescription();
263 if (!desc.empty())
264 strm << "-- " << desc;
265
266 if (transparent && (dump_mask == (OptionValue::eDumpOptionName |
268 strm.EOL();
269 }
270 m_value_sp->DumpValue(exe_ctx, strm, dump_mask);
271 }
272}
273
275 uint32_t output_width,
276 bool display_qualified_name) const {
277 if (!m_value_sp)
278 return;
279 llvm::StringRef desc = GetDescription();
280
281 if (desc.empty())
282 return;
283
284 StreamString qualified_name;
285 const OptionValueProperties *sub_properties = m_value_sp->GetAsProperties();
286 if (sub_properties) {
287 strm.EOL();
288
289 if (m_value_sp->DumpQualifiedName(qualified_name))
290 strm.Printf("'%s' variables:\n\n", qualified_name.GetData());
291 sub_properties->DumpAllDescriptions(interpreter, strm);
292 } else {
293 if (display_qualified_name) {
294 StreamString qualified_name;
295 DumpQualifiedName(qualified_name);
296 interpreter.OutputFormattedHelpText(strm, qualified_name.GetString(),
297 "--", desc, output_width);
298 } else {
299 interpreter.OutputFormattedHelpText(strm, m_name, "--", desc,
300 output_width);
301 }
302 }
303}
304
305void Property::SetValueChangedCallback(std::function<void()> callback) {
306 if (m_value_sp)
307 m_value_sp->SetValueChangedCallback(std::move(callback));
308}
void OutputFormattedHelpText(Stream &strm, llvm::StringRef prefix, llvm::StringRef help_text)
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
A file utility class.
Definition: FileSpec.h:56
void Resolve(llvm::SmallVectorImpl< char > &path)
Resolve path to make it canonical.
static FileSystem & Instance()
void Reset(ValueType flags)
Set accessor for all flags.
Definition: Flags.h:52
static lldb::LanguageType GetLanguageTypeFromString(const char *string)=delete
virtual void DumpAllDescriptions(CommandInterpreter &interpreter, Stream &strm) const
static uint32_t ConvertTypeToMask(OptionValue::Type type)
Definition: OptionValue.h:131
void DumpDescription(CommandInterpreter &interpreter, Stream &strm, uint32_t output_width, bool display_qualified_name) const
Definition: Property.cpp:274
llvm::StringRef GetDescription() const
Definition: Property.h:43
std::string m_name
Definition: Property.h:67
lldb::OptionValueSP m_value_sp
Definition: Property.h:69
void SetValueChangedCallback(std::function< void()> callback)
Definition: Property.cpp:305
void Dump(const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask) const
Definition: Property.cpp:246
Property(const PropertyDefinition &definition)
Definition: Property.cpp:22
bool DumpQualifiedName(Stream &strm) const
Definition: Property.cpp:236
const char * GetData() const
Definition: StreamString.h:43
llvm::StringRef GetString() const
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:107
size_t PutChar(char ch)
Definition: Stream.cpp:104
size_t EOL()
Output and End of Line character to the stream.
Definition: Stream.cpp:128
bool SetFromStringRef(llvm::StringRef str)
Definition: UUID.cpp:97
A class that represents a running process on the host machine.
Definition: SBAddress.h:15
Format
Display format definitions.
LanguageType
Programming language type.
@ eLanguageTypeUnknown
Unknown or invalid language value.
static char ToChar(llvm::StringRef s, char fail_value, bool *success_ptr)
static Status ToFormat(const char *s, lldb::Format &format, size_t *byte_size_ptr)
static bool ToBoolean(llvm::StringRef s, bool fail_value, bool *success_ptr)
OptionEnumValues enum_values
Definition: Property.h:29
OptionValue::Type type
Definition: Property.h:25