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 
9 #include "lldb/Interpreter/Property.h"
10 
11 #include "lldb/Core/UserSettingsController.h"
12 #include "lldb/Interpreter/CommandInterpreter.h"
13 #include "lldb/Interpreter/OptionArgParser.h"
14 #include "lldb/Interpreter/OptionValues.h"
15 #include "lldb/Target/Language.h"
16 
17 #include <memory>
18 
19 using namespace lldb;
20 using namespace lldb_private;
21 
22 Property::Property(const PropertyDefinition &definition)
23     : m_name(definition.name), m_description(definition.description),
24       m_is_global(definition.global) {
25   switch (definition.type) {
26   case OptionValue::eTypeInvalid:
27   case OptionValue::eTypeProperties:
28     break;
29   case OptionValue::eTypeArch:
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
33     m_value_sp =
34         std::make_shared<OptionValueArch>(definition.default_cstr_value);
35     break;
36 
37   case OptionValue::eTypeArgs:
38     // "definition.default_uint_value" is always a OptionValue::Type
39     m_value_sp = std::make_shared<OptionValueArgs>();
40     break;
41 
42   case OptionValue::eTypeArray:
43     // "definition.default_uint_value" is always a OptionValue::Type
44     m_value_sp =
45         std::make_shared<OptionValueArray>(OptionValue::ConvertTypeToMask(
46             (OptionValue::Type)definition.default_uint_value));
47     break;
48 
49   case OptionValue::eTypeBoolean:
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)
55       m_value_sp =
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 
63   case OptionValue::eTypeChar: {
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   }
69   case OptionValue::eTypeDictionary:
70     // "definition.default_uint_value" is always a OptionValue::Type
71     m_value_sp = std::make_shared<OptionValueDictionary>(
72         OptionValue::ConvertTypeToMask(
73             (OptionValue::Type)definition.default_uint_value),
74         definition.enum_values);
75     break;
76 
77   case OptionValue::eTypeEnum:
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     {
83       OptionValueEnumeration *enum_value = new OptionValueEnumeration(
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 
102   case OptionValue::eTypeFileLineColumn:
103     // "definition.default_uint_value" is not used for a
104     // OptionValue::eTypeFileSpecList
105     m_value_sp = std::make_shared<OptionValueFileColonLine>();
106     break;
107 
108   case OptionValue::eTypeFileSpec: {
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 
119   case OptionValue::eTypeFileSpecList:
120     // "definition.default_uint_value" is not used for a
121     // OptionValue::eTypeFileSpecList
122     m_value_sp = std::make_shared<OptionValueFileSpecList>();
123     break;
124 
125   case OptionValue::eTypeFormat:
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 
141   case OptionValue::eTypeLanguage:
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     {
147       LanguageType new_lang = eLanguageTypeUnknown;
148       if (definition.default_cstr_value)
149         Language::GetLanguageTypeFromString(
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 
157   case OptionValue::eTypeFormatEntity:
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 
164   case OptionValue::eTypePathMap:
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 
171   case OptionValue::eTypeRegex:
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 
179   case OptionValue::eTypeSInt64: {
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   }
192   case OptionValue::eTypeUInt64: {
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   }
205   case OptionValue::eTypeUUID:
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 
216   case OptionValue::eTypeString:
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 =
222           new OptionValueString(definition.default_cstr_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 
231 Property::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 
236 bool Property::DumpQualifiedName(Stream &strm) const {
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 
246 void 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 |
267                                         OptionValue::eDumpOptionDescription)))
268         strm.EOL();
269     }
270     m_value_sp->DumpValue(exe_ctx, strm, dump_mask);
271   }
272 }
273 
274 void Property::DumpDescription(CommandInterpreter &interpreter, Stream &strm,
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 
305 void Property::SetValueChangedCallback(std::function<void()> callback) {
306   if (m_value_sp)
307     m_value_sp->SetValueChangedCallback(std::move(callback));
308 }
309