LLDB  mainline
OptionValue.cpp
Go to the documentation of this file.
1 //===-- OptionValue.cpp -----------------------------------------*- C++ -*-===//
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 
13 
14 using namespace lldb;
15 using namespace lldb_private;
16 
17 // Get this value as a uint64_t value if it is encoded as a boolean, uint64_t
18 // or int64_t. Other types will cause "fail_value" to be returned
19 uint64_t OptionValue::GetUInt64Value(uint64_t fail_value, bool *success_ptr) {
20  if (success_ptr)
21  *success_ptr = true;
22  switch (GetType()) {
23  case OptionValue::eTypeBoolean:
24  return static_cast<OptionValueBoolean *>(this)->GetCurrentValue();
25  case OptionValue::eTypeSInt64:
26  return static_cast<OptionValueSInt64 *>(this)->GetCurrentValue();
27  case OptionValue::eTypeUInt64:
28  return static_cast<OptionValueUInt64 *>(this)->GetCurrentValue();
29  default:
30  break;
31  }
32  if (success_ptr)
33  *success_ptr = false;
34  return fail_value;
35 }
36 
37 Status OptionValue::SetSubValue(const ExecutionContext *exe_ctx,
38  VarSetOperationType op, llvm::StringRef name,
39  llvm::StringRef value) {
40  Status error;
41  error.SetErrorStringWithFormat("SetSubValue is not supported");
42  return error;
43 }
44 
45 OptionValueBoolean *OptionValue::GetAsBoolean() {
46  if (GetType() == OptionValue::eTypeBoolean)
47  return static_cast<OptionValueBoolean *>(this);
48  return nullptr;
49 }
50 
51 const OptionValueBoolean *OptionValue::GetAsBoolean() const {
52  if (GetType() == OptionValue::eTypeBoolean)
53  return static_cast<const OptionValueBoolean *>(this);
54  return nullptr;
55 }
56 
57 const OptionValueChar *OptionValue::GetAsChar() const {
58  if (GetType() == OptionValue::eTypeChar)
59  return static_cast<const OptionValueChar *>(this);
60  return nullptr;
61 }
62 
63 OptionValueChar *OptionValue::GetAsChar() {
64  if (GetType() == OptionValue::eTypeChar)
65  return static_cast<OptionValueChar *>(this);
66  return nullptr;
67 }
68 
69 OptionValueFileSpec *OptionValue::GetAsFileSpec() {
70  if (GetType() == OptionValue::eTypeFileSpec)
71  return static_cast<OptionValueFileSpec *>(this);
72  return nullptr;
73 }
74 
75 const OptionValueFileSpec *OptionValue::GetAsFileSpec() const {
76  if (GetType() == OptionValue::eTypeFileSpec)
77  return static_cast<const OptionValueFileSpec *>(this);
78  return nullptr;
79 }
80 
81 OptionValueFileSpecList *OptionValue::GetAsFileSpecList() {
82  if (GetType() == OptionValue::eTypeFileSpecList)
83  return static_cast<OptionValueFileSpecList *>(this);
84  return nullptr;
85 }
86 
87 const OptionValueFileSpecList *OptionValue::GetAsFileSpecList() const {
88  if (GetType() == OptionValue::eTypeFileSpecList)
89  return static_cast<const OptionValueFileSpecList *>(this);
90  return nullptr;
91 }
92 
93 OptionValueArch *OptionValue::GetAsArch() {
94  if (GetType() == OptionValue::eTypeArch)
95  return static_cast<OptionValueArch *>(this);
96  return nullptr;
97 }
98 
99 const OptionValueArch *OptionValue::GetAsArch() const {
100  if (GetType() == OptionValue::eTypeArch)
101  return static_cast<const OptionValueArch *>(this);
102  return nullptr;
103 }
104 
105 OptionValueArray *OptionValue::GetAsArray() {
106  if (GetType() == OptionValue::eTypeArray)
107  return static_cast<OptionValueArray *>(this);
108  return nullptr;
109 }
110 
111 const OptionValueArray *OptionValue::GetAsArray() const {
112  if (GetType() == OptionValue::eTypeArray)
113  return static_cast<const OptionValueArray *>(this);
114  return nullptr;
115 }
116 
117 OptionValueArgs *OptionValue::GetAsArgs() {
118  if (GetType() == OptionValue::eTypeArgs)
119  return static_cast<OptionValueArgs *>(this);
120  return nullptr;
121 }
122 
123 const OptionValueArgs *OptionValue::GetAsArgs() const {
124  if (GetType() == OptionValue::eTypeArgs)
125  return static_cast<const OptionValueArgs *>(this);
126  return nullptr;
127 }
128 
129 OptionValueDictionary *OptionValue::GetAsDictionary() {
130  if (GetType() == OptionValue::eTypeDictionary)
131  return static_cast<OptionValueDictionary *>(this);
132  return nullptr;
133 }
134 
135 const OptionValueDictionary *OptionValue::GetAsDictionary() const {
136  if (GetType() == OptionValue::eTypeDictionary)
137  return static_cast<const OptionValueDictionary *>(this);
138  return nullptr;
139 }
140 
141 OptionValueEnumeration *OptionValue::GetAsEnumeration() {
142  if (GetType() == OptionValue::eTypeEnum)
143  return static_cast<OptionValueEnumeration *>(this);
144  return nullptr;
145 }
146 
147 const OptionValueEnumeration *OptionValue::GetAsEnumeration() const {
148  if (GetType() == OptionValue::eTypeEnum)
149  return static_cast<const OptionValueEnumeration *>(this);
150  return nullptr;
151 }
152 
153 OptionValueFormat *OptionValue::GetAsFormat() {
154  if (GetType() == OptionValue::eTypeFormat)
155  return static_cast<OptionValueFormat *>(this);
156  return nullptr;
157 }
158 
159 const OptionValueFormat *OptionValue::GetAsFormat() const {
160  if (GetType() == OptionValue::eTypeFormat)
161  return static_cast<const OptionValueFormat *>(this);
162  return nullptr;
163 }
164 
165 OptionValueLanguage *OptionValue::GetAsLanguage() {
166  if (GetType() == OptionValue::eTypeLanguage)
167  return static_cast<OptionValueLanguage *>(this);
168  return NULL;
169 }
170 
171 const OptionValueLanguage *OptionValue::GetAsLanguage() const {
172  if (GetType() == OptionValue::eTypeLanguage)
173  return static_cast<const OptionValueLanguage *>(this);
174  return NULL;
175 }
176 
177 OptionValueFormatEntity *OptionValue::GetAsFormatEntity() {
178  if (GetType() == OptionValue::eTypeFormatEntity)
179  return static_cast<OptionValueFormatEntity *>(this);
180  return nullptr;
181 }
182 
183 const OptionValueFormatEntity *OptionValue::GetAsFormatEntity() const {
184  if (GetType() == OptionValue::eTypeFormatEntity)
185  return static_cast<const OptionValueFormatEntity *>(this);
186  return nullptr;
187 }
188 
189 OptionValuePathMappings *OptionValue::GetAsPathMappings() {
190  if (GetType() == OptionValue::eTypePathMap)
191  return static_cast<OptionValuePathMappings *>(this);
192  return nullptr;
193 }
194 
195 const OptionValuePathMappings *OptionValue::GetAsPathMappings() const {
196  if (GetType() == OptionValue::eTypePathMap)
197  return static_cast<const OptionValuePathMappings *>(this);
198  return nullptr;
199 }
200 
201 OptionValueProperties *OptionValue::GetAsProperties() {
202  if (GetType() == OptionValue::eTypeProperties)
203  return static_cast<OptionValueProperties *>(this);
204  return nullptr;
205 }
206 
207 const OptionValueProperties *OptionValue::GetAsProperties() const {
208  if (GetType() == OptionValue::eTypeProperties)
209  return static_cast<const OptionValueProperties *>(this);
210  return nullptr;
211 }
212 
213 OptionValueRegex *OptionValue::GetAsRegex() {
214  if (GetType() == OptionValue::eTypeRegex)
215  return static_cast<OptionValueRegex *>(this);
216  return nullptr;
217 }
218 
219 const OptionValueRegex *OptionValue::GetAsRegex() const {
220  if (GetType() == OptionValue::eTypeRegex)
221  return static_cast<const OptionValueRegex *>(this);
222  return nullptr;
223 }
224 
225 OptionValueSInt64 *OptionValue::GetAsSInt64() {
226  if (GetType() == OptionValue::eTypeSInt64)
227  return static_cast<OptionValueSInt64 *>(this);
228  return nullptr;
229 }
230 
231 const OptionValueSInt64 *OptionValue::GetAsSInt64() const {
232  if (GetType() == OptionValue::eTypeSInt64)
233  return static_cast<const OptionValueSInt64 *>(this);
234  return nullptr;
235 }
236 
237 OptionValueString *OptionValue::GetAsString() {
238  if (GetType() == OptionValue::eTypeString)
239  return static_cast<OptionValueString *>(this);
240  return nullptr;
241 }
242 
243 const OptionValueString *OptionValue::GetAsString() const {
244  if (GetType() == OptionValue::eTypeString)
245  return static_cast<const OptionValueString *>(this);
246  return nullptr;
247 }
248 
249 OptionValueUInt64 *OptionValue::GetAsUInt64() {
250  if (GetType() == OptionValue::eTypeUInt64)
251  return static_cast<OptionValueUInt64 *>(this);
252  return nullptr;
253 }
254 
255 const OptionValueUInt64 *OptionValue::GetAsUInt64() const {
256  if (GetType() == OptionValue::eTypeUInt64)
257  return static_cast<const OptionValueUInt64 *>(this);
258  return nullptr;
259 }
260 
261 OptionValueUUID *OptionValue::GetAsUUID() {
262  if (GetType() == OptionValue::eTypeUUID)
263  return static_cast<OptionValueUUID *>(this);
264  return nullptr;
265 }
266 
267 const OptionValueUUID *OptionValue::GetAsUUID() const {
268  if (GetType() == OptionValue::eTypeUUID)
269  return static_cast<const OptionValueUUID *>(this);
270  return nullptr;
271 }
272 
273 bool OptionValue::GetBooleanValue(bool fail_value) const {
274  const OptionValueBoolean *option_value = GetAsBoolean();
275  if (option_value)
276  return option_value->GetCurrentValue();
277  return fail_value;
278 }
279 
280 bool OptionValue::SetBooleanValue(bool new_value) {
281  OptionValueBoolean *option_value = GetAsBoolean();
282  if (option_value) {
283  option_value->SetCurrentValue(new_value);
284  return true;
285  }
286  return false;
287 }
288 
289 char OptionValue::GetCharValue(char fail_value) const {
290  const OptionValueChar *option_value = GetAsChar();
291  if (option_value)
292  return option_value->GetCurrentValue();
293  return fail_value;
294 }
295 
296 char OptionValue::SetCharValue(char new_value) {
297  OptionValueChar *option_value = GetAsChar();
298  if (option_value) {
299  option_value->SetCurrentValue(new_value);
300  return true;
301  }
302  return false;
303 }
304 
305 int64_t OptionValue::GetEnumerationValue(int64_t fail_value) const {
306  const OptionValueEnumeration *option_value = GetAsEnumeration();
307  if (option_value)
308  return option_value->GetCurrentValue();
309  return fail_value;
310 }
311 
312 bool OptionValue::SetEnumerationValue(int64_t value) {
313  OptionValueEnumeration *option_value = GetAsEnumeration();
314  if (option_value) {
315  option_value->SetCurrentValue(value);
316  return true;
317  }
318  return false;
319 }
320 
321 FileSpec OptionValue::GetFileSpecValue() const {
322  const OptionValueFileSpec *option_value = GetAsFileSpec();
323  if (option_value)
324  return option_value->GetCurrentValue();
325  return FileSpec();
326 }
327 
328 bool OptionValue::SetFileSpecValue(const FileSpec &file_spec) {
329  OptionValueFileSpec *option_value = GetAsFileSpec();
330  if (option_value) {
331  option_value->SetCurrentValue(file_spec, false);
332  return true;
333  }
334  return false;
335 }
336 
337 FileSpecList OptionValue::GetFileSpecListValue() const {
338  const OptionValueFileSpecList *option_value = GetAsFileSpecList();
339  if (option_value)
340  return option_value->GetCurrentValue();
341  return FileSpecList();
342 }
343 
344 lldb::Format OptionValue::GetFormatValue(lldb::Format fail_value) const {
345  const OptionValueFormat *option_value = GetAsFormat();
346  if (option_value)
347  return option_value->GetCurrentValue();
348  return fail_value;
349 }
350 
351 bool OptionValue::SetFormatValue(lldb::Format new_value) {
352  OptionValueFormat *option_value = GetAsFormat();
353  if (option_value) {
354  option_value->SetCurrentValue(new_value);
355  return true;
356  }
357  return false;
358 }
359 
361 OptionValue::GetLanguageValue(lldb::LanguageType fail_value) const {
362  const OptionValueLanguage *option_value = GetAsLanguage();
363  if (option_value)
364  return option_value->GetCurrentValue();
365  return fail_value;
366 }
367 
368 bool OptionValue::SetLanguageValue(lldb::LanguageType new_language) {
369  OptionValueLanguage *option_value = GetAsLanguage();
370  if (option_value) {
371  option_value->SetCurrentValue(new_language);
372  return true;
373  }
374  return false;
375 }
376 
377 const FormatEntity::Entry *OptionValue::GetFormatEntity() const {
378  const OptionValueFormatEntity *option_value = GetAsFormatEntity();
379  if (option_value)
380  return &option_value->GetCurrentValue();
381  return nullptr;
382 }
383 
384 const RegularExpression *OptionValue::GetRegexValue() const {
385  const OptionValueRegex *option_value = GetAsRegex();
386  if (option_value)
387  return option_value->GetCurrentValue();
388  return nullptr;
389 }
390 
391 int64_t OptionValue::GetSInt64Value(int64_t fail_value) const {
392  const OptionValueSInt64 *option_value = GetAsSInt64();
393  if (option_value)
394  return option_value->GetCurrentValue();
395  return fail_value;
396 }
397 
398 bool OptionValue::SetSInt64Value(int64_t new_value) {
399  OptionValueSInt64 *option_value = GetAsSInt64();
400  if (option_value) {
401  option_value->SetCurrentValue(new_value);
402  return true;
403  }
404  return false;
405 }
406 
407 llvm::StringRef OptionValue::GetStringValue(llvm::StringRef fail_value) const {
408  const OptionValueString *option_value = GetAsString();
409  if (option_value)
410  return option_value->GetCurrentValueAsRef();
411  return fail_value;
412 }
413 
414 bool OptionValue::SetStringValue(llvm::StringRef new_value) {
415  OptionValueString *option_value = GetAsString();
416  if (option_value) {
417  option_value->SetCurrentValue(new_value);
418  return true;
419  }
420  return false;
421 }
422 
423 uint64_t OptionValue::GetUInt64Value(uint64_t fail_value) const {
424  const OptionValueUInt64 *option_value = GetAsUInt64();
425  if (option_value)
426  return option_value->GetCurrentValue();
427  return fail_value;
428 }
429 
430 bool OptionValue::SetUInt64Value(uint64_t new_value) {
431  OptionValueUInt64 *option_value = GetAsUInt64();
432  if (option_value) {
433  option_value->SetCurrentValue(new_value);
434  return true;
435  }
436  return false;
437 }
438 
439 UUID OptionValue::GetUUIDValue() const {
440  const OptionValueUUID *option_value = GetAsUUID();
441  if (option_value)
442  return option_value->GetCurrentValue();
443  return UUID();
444 }
445 
446 bool OptionValue::SetUUIDValue(const UUID &uuid) {
447  OptionValueUUID *option_value = GetAsUUID();
448  if (option_value) {
449  option_value->SetCurrentValue(uuid);
450  return true;
451  }
452  return false;
453 }
454 
455 const char *OptionValue::GetBuiltinTypeAsCString(Type t) {
456  switch (t) {
457  case eTypeInvalid:
458  return "invalid";
459  case eTypeArch:
460  return "arch";
461  case eTypeArgs:
462  return "arguments";
463  case eTypeArray:
464  return "array";
465  case eTypeBoolean:
466  return "boolean";
467  case eTypeChar:
468  return "char";
469  case eTypeDictionary:
470  return "dictionary";
471  case eTypeEnum:
472  return "enum";
473  case eTypeFileSpec:
474  return "file";
475  case eTypeFileSpecList:
476  return "file-list";
477  case eTypeFormat:
478  return "format";
479  case eTypeFormatEntity:
480  return "format-string";
481  case eTypeLanguage:
482  return "language";
483  case eTypePathMap:
484  return "path-map";
485  case eTypeProperties:
486  return "properties";
487  case eTypeRegex:
488  return "regex";
489  case eTypeSInt64:
490  return "int";
491  case eTypeString:
492  return "string";
493  case eTypeUInt64:
494  return "unsigned";
495  case eTypeUUID:
496  return "uuid";
497  }
498  return nullptr;
499 }
500 
501 lldb::OptionValueSP OptionValue::CreateValueFromCStringForTypeMask(
502  const char *value_cstr, uint32_t type_mask, Status &error) {
503  // If only 1 bit is set in the type mask for a dictionary or array then we
504  // know how to decode a value from a cstring
505  lldb::OptionValueSP value_sp;
506  switch (type_mask) {
507  case 1u << eTypeArch:
508  value_sp.reset(new OptionValueArch());
509  break;
510  case 1u << eTypeBoolean:
511  value_sp.reset(new OptionValueBoolean(false));
512  break;
513  case 1u << eTypeChar:
514  value_sp.reset(new OptionValueChar('\0'));
515  break;
516  case 1u << eTypeFileSpec:
517  value_sp.reset(new OptionValueFileSpec());
518  break;
519  case 1u << eTypeFormat:
520  value_sp.reset(new OptionValueFormat(eFormatInvalid));
521  break;
522  case 1u << eTypeFormatEntity:
523  value_sp.reset(new OptionValueFormatEntity(NULL));
524  break;
525  case 1u << eTypeLanguage:
526  value_sp.reset(new OptionValueLanguage(eLanguageTypeUnknown));
527  break;
528  case 1u << eTypeSInt64:
529  value_sp.reset(new OptionValueSInt64());
530  break;
531  case 1u << eTypeString:
532  value_sp.reset(new OptionValueString());
533  break;
534  case 1u << eTypeUInt64:
535  value_sp.reset(new OptionValueUInt64());
536  break;
537  case 1u << eTypeUUID:
538  value_sp.reset(new OptionValueUUID());
539  break;
540  }
541 
542  if (value_sp)
543  error = value_sp->SetValueFromString(
544  llvm::StringRef::withNullAsEmpty(value_cstr), eVarSetOperationAssign);
545  else
546  error.SetErrorString("unsupported type mask");
547  return value_sp;
548 }
549 
550 bool OptionValue::DumpQualifiedName(Stream &strm) const {
551  bool dumped_something = false;
552  lldb::OptionValueSP m_parent_sp(m_parent_wp.lock());
553  if (m_parent_sp) {
554  if (m_parent_sp->DumpQualifiedName(strm))
555  dumped_something = true;
556  }
557  ConstString name(GetName());
558  if (name) {
559  if (dumped_something)
560  strm.PutChar('.');
561  else
562  dumped_something = true;
563  strm << name;
564  }
565  return dumped_something;
566 }
567 
568 size_t OptionValue::AutoComplete(CommandInterpreter &interpreter,
569  CompletionRequest &request) {
570  request.SetWordComplete(false);
571  return request.GetNumberOfMatches();
572 }
573 
574 Status OptionValue::SetValueFromString(llvm::StringRef value,
575  VarSetOperationType op) {
576  Status error;
577  switch (op) {
580  "%s objects do not support the 'replace' operation",
581  GetTypeAsCString());
582  break;
585  "%s objects do not support the 'insert-before' operation",
586  GetTypeAsCString());
587  break;
590  "%s objects do not support the 'insert-after' operation",
591  GetTypeAsCString());
592  break;
595  "%s objects do not support the 'remove' operation", GetTypeAsCString());
596  break;
599  "%s objects do not support the 'append' operation", GetTypeAsCString());
600  break;
603  "%s objects do not support the 'clear' operation", GetTypeAsCString());
604  break;
607  "%s objects do not support the 'assign' operation", GetTypeAsCString());
608  break;
610  error.SetErrorStringWithFormat("invalid operation performed on a %s object",
611  GetTypeAsCString());
612  break;
613  }
614  return error;
615 }
Enumerations for broadcasting.
Definition: SBLaunchInfo.h:14
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
lldb::Format GetCurrentValue() const
llvm::StringRef GetCurrentValueAsRef() const
const RegularExpression * GetCurrentValue() const
A file utility class.
Definition: FileSpec.h:55
"lldb/Utility/RegularExpression.h" A C++ wrapper class for regex.
std::size_t GetNumberOfMatches() const
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
void SetCurrentValue(lldb::LanguageType value)
"lldb/Utility/ArgCompletionRequest.h"
LanguageType
Programming language type.
VarSetOperationType
Settable state variable types.
void SetCurrentValue(const FileSpec &value, bool set_value_was_set)
void SetErrorString(llvm::StringRef err_str)
Set the current error string to err_str.
Definition: Status.cpp:241
void SetCurrentValue(lldb::Format value)
void SetCurrentValue(uint64_t value)
bool SetCurrentValue(int64_t value)
size_t PutChar(char ch)
Definition: Stream.cpp:103
Status SetCurrentValue(const char *)=delete
A uniqued constant string class.
Definition: ConstString.h:38
Unknown or invalid language value.
lldb::LanguageType GetCurrentValue() const
Definition: SBAddress.h:15
void SetCurrentValue(char value)
int SetErrorStringWithFormat(const char *format,...) __attribute__((format(printf
Set the current error string to a formatted error string.
Definition: Status.cpp:255
An error handling class.
Definition: Status.h:44
void SetCurrentValue(const UUID &value)