1 //===-- OptionValue.cpp -----------------------------------------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 #include "lldb/Interpreter/OptionValue.h"
11
12 // C Includes
13 // C++ Includes
14 // Other libraries and framework includes
15 // Project includes
16 #include "lldb/Core/StringList.h"
17 #include "lldb/Interpreter/OptionValues.h"
18
19 using namespace lldb;
20 using namespace lldb_private;
21
22
23 //-------------------------------------------------------------------------
24 // Get this value as a uint64_t value if it is encoded as a boolean,
25 // uint64_t or int64_t. Other types will cause "fail_value" to be
26 // returned
27 //-------------------------------------------------------------------------
28 uint64_t
GetUInt64Value(uint64_t fail_value,bool * success_ptr)29 OptionValue::GetUInt64Value (uint64_t fail_value, bool *success_ptr)
30 {
31 if (success_ptr)
32 *success_ptr = true;
33 switch (GetType())
34 {
35 case OptionValue::eTypeBoolean: return static_cast<OptionValueBoolean *>(this)->GetCurrentValue();
36 case OptionValue::eTypeSInt64: return static_cast<OptionValueSInt64 *>(this)->GetCurrentValue();
37 case OptionValue::eTypeUInt64: return static_cast<OptionValueUInt64 *>(this)->GetCurrentValue();
38 default:
39 break;
40 }
41 if (success_ptr)
42 *success_ptr = false;
43 return fail_value;
44 }
45
46 Error
SetSubValue(const ExecutionContext * exe_ctx,VarSetOperationType op,const char * name,const char * value)47 OptionValue::SetSubValue (const ExecutionContext *exe_ctx,
48 VarSetOperationType op,
49 const char *name,
50 const char *value)
51 {
52 Error error;
53 error.SetErrorStringWithFormat("SetSubValue is not supported");
54 return error;
55 }
56
57
58 OptionValueBoolean *
GetAsBoolean()59 OptionValue::GetAsBoolean ()
60 {
61 if (GetType () == OptionValue::eTypeBoolean)
62 return static_cast<OptionValueBoolean *>(this);
63 return nullptr;
64 }
65
66 const OptionValueBoolean *
GetAsBoolean() const67 OptionValue::GetAsBoolean () const
68 {
69 if (GetType () == OptionValue::eTypeBoolean)
70 return static_cast<const OptionValueBoolean *>(this);
71 return nullptr;
72 }
73
74 const OptionValueChar *
GetAsChar() const75 OptionValue::GetAsChar () const
76 {
77 if (GetType () == OptionValue::eTypeChar)
78 return static_cast<const OptionValueChar *>(this);
79 return nullptr;
80 }
81
82 OptionValueChar *
GetAsChar()83 OptionValue::GetAsChar ()
84 {
85 if (GetType () == OptionValue::eTypeChar)
86 return static_cast<OptionValueChar *>(this);
87 return nullptr;
88 }
89
90 OptionValueFileSpec *
GetAsFileSpec()91 OptionValue::GetAsFileSpec ()
92 {
93 if (GetType () == OptionValue::eTypeFileSpec)
94 return static_cast<OptionValueFileSpec *>(this);
95 return nullptr;
96
97 }
98
99 const OptionValueFileSpec *
GetAsFileSpec() const100 OptionValue::GetAsFileSpec () const
101 {
102 if (GetType () == OptionValue::eTypeFileSpec)
103 return static_cast<const OptionValueFileSpec *>(this);
104 return nullptr;
105
106 }
107
108 OptionValueFileSpecList *
GetAsFileSpecList()109 OptionValue::GetAsFileSpecList ()
110 {
111 if (GetType () == OptionValue::eTypeFileSpecList)
112 return static_cast<OptionValueFileSpecList *>(this);
113 return nullptr;
114
115 }
116
117 const OptionValueFileSpecList *
GetAsFileSpecList() const118 OptionValue::GetAsFileSpecList () const
119 {
120 if (GetType () == OptionValue::eTypeFileSpecList)
121 return static_cast<const OptionValueFileSpecList *>(this);
122 return nullptr;
123
124 }
125
126 OptionValueArch *
GetAsArch()127 OptionValue::GetAsArch ()
128 {
129 if (GetType () == OptionValue::eTypeArch)
130 return static_cast<OptionValueArch *>(this);
131 return nullptr;
132 }
133
134
135 const OptionValueArch *
GetAsArch() const136 OptionValue::GetAsArch () const
137 {
138 if (GetType () == OptionValue::eTypeArch)
139 return static_cast<const OptionValueArch *>(this);
140 return nullptr;
141 }
142
143 OptionValueArray *
GetAsArray()144 OptionValue::GetAsArray ()
145 {
146 if (GetType () == OptionValue::eTypeArray)
147 return static_cast<OptionValueArray *>(this);
148 return nullptr;
149 }
150
151
152 const OptionValueArray *
GetAsArray() const153 OptionValue::GetAsArray () const
154 {
155 if (GetType () == OptionValue::eTypeArray)
156 return static_cast<const OptionValueArray *>(this);
157 return nullptr;
158 }
159
160 OptionValueArgs *
GetAsArgs()161 OptionValue::GetAsArgs ()
162 {
163 if (GetType () == OptionValue::eTypeArgs)
164 return static_cast<OptionValueArgs *>(this);
165 return nullptr;
166 }
167
168
169 const OptionValueArgs *
GetAsArgs() const170 OptionValue::GetAsArgs () const
171 {
172 if (GetType () == OptionValue::eTypeArgs)
173 return static_cast<const OptionValueArgs *>(this);
174 return nullptr;
175 }
176
177 OptionValueDictionary *
GetAsDictionary()178 OptionValue::GetAsDictionary ()
179 {
180 if (GetType () == OptionValue::eTypeDictionary)
181 return static_cast<OptionValueDictionary *>(this);
182 return nullptr;
183 }
184
185 const OptionValueDictionary *
GetAsDictionary() const186 OptionValue::GetAsDictionary () const
187 {
188 if (GetType () == OptionValue::eTypeDictionary)
189 return static_cast<const OptionValueDictionary *>(this);
190 return nullptr;
191 }
192
193 OptionValueEnumeration *
GetAsEnumeration()194 OptionValue::GetAsEnumeration ()
195 {
196 if (GetType () == OptionValue::eTypeEnum)
197 return static_cast<OptionValueEnumeration *>(this);
198 return nullptr;
199 }
200
201 const OptionValueEnumeration *
GetAsEnumeration() const202 OptionValue::GetAsEnumeration () const
203 {
204 if (GetType () == OptionValue::eTypeEnum)
205 return static_cast<const OptionValueEnumeration *>(this);
206 return nullptr;
207 }
208
209 OptionValueFormat *
GetAsFormat()210 OptionValue::GetAsFormat ()
211 {
212 if (GetType () == OptionValue::eTypeFormat)
213 return static_cast<OptionValueFormat *>(this);
214 return nullptr;
215 }
216
217 const OptionValueFormat *
GetAsFormat() const218 OptionValue::GetAsFormat () const
219 {
220 if (GetType () == OptionValue::eTypeFormat)
221 return static_cast<const OptionValueFormat *>(this);
222 return nullptr;
223 }
224
225 OptionValueLanguage *
GetAsLanguage()226 OptionValue::GetAsLanguage ()
227 {
228 if (GetType () == OptionValue::eTypeLanguage)
229 return static_cast<OptionValueLanguage *>(this);
230 return NULL;
231 }
232
233 const OptionValueLanguage *
GetAsLanguage() const234 OptionValue::GetAsLanguage () const
235 {
236 if (GetType () == OptionValue::eTypeLanguage)
237 return static_cast<const OptionValueLanguage *>(this);
238 return NULL;
239 }
240
241 OptionValueFormatEntity *
GetAsFormatEntity()242 OptionValue::GetAsFormatEntity ()
243 {
244 if (GetType () == OptionValue::eTypeFormatEntity)
245 return static_cast<OptionValueFormatEntity *>(this);
246 return nullptr;
247 }
248
249 const OptionValueFormatEntity *
GetAsFormatEntity() const250 OptionValue::GetAsFormatEntity () const
251 {
252 if (GetType () == OptionValue::eTypeFormatEntity)
253 return static_cast<const OptionValueFormatEntity *>(this);
254 return nullptr;
255 }
256
257 OptionValuePathMappings *
GetAsPathMappings()258 OptionValue::GetAsPathMappings ()
259 {
260 if (GetType () == OptionValue::eTypePathMap)
261 return static_cast<OptionValuePathMappings *>(this);
262 return nullptr;
263 }
264
265 const OptionValuePathMappings *
GetAsPathMappings() const266 OptionValue::GetAsPathMappings () const
267 {
268 if (GetType () == OptionValue::eTypePathMap)
269 return static_cast<const OptionValuePathMappings *>(this);
270 return nullptr;
271 }
272
273 OptionValueProperties *
GetAsProperties()274 OptionValue::GetAsProperties ()
275 {
276 if (GetType () == OptionValue::eTypeProperties)
277 return static_cast<OptionValueProperties *>(this);
278 return nullptr;
279 }
280
281 const OptionValueProperties *
GetAsProperties() const282 OptionValue::GetAsProperties () const
283 {
284 if (GetType () == OptionValue::eTypeProperties)
285 return static_cast<const OptionValueProperties *>(this);
286 return nullptr;
287 }
288
289 OptionValueRegex *
GetAsRegex()290 OptionValue::GetAsRegex ()
291 {
292 if (GetType () == OptionValue::eTypeRegex)
293 return static_cast<OptionValueRegex *>(this);
294 return nullptr;
295 }
296
297 const OptionValueRegex *
GetAsRegex() const298 OptionValue::GetAsRegex () const
299 {
300 if (GetType () == OptionValue::eTypeRegex)
301 return static_cast<const OptionValueRegex *>(this);
302 return nullptr;
303 }
304
305 OptionValueSInt64 *
GetAsSInt64()306 OptionValue::GetAsSInt64 ()
307 {
308 if (GetType () == OptionValue::eTypeSInt64)
309 return static_cast<OptionValueSInt64 *>(this);
310 return nullptr;
311 }
312
313 const OptionValueSInt64 *
GetAsSInt64() const314 OptionValue::GetAsSInt64 () const
315 {
316 if (GetType () == OptionValue::eTypeSInt64)
317 return static_cast<const OptionValueSInt64 *>(this);
318 return nullptr;
319 }
320
321 OptionValueString *
GetAsString()322 OptionValue::GetAsString ()
323 {
324 if (GetType () == OptionValue::eTypeString)
325 return static_cast<OptionValueString *>(this);
326 return nullptr;
327 }
328
329 const OptionValueString *
GetAsString() const330 OptionValue::GetAsString () const
331 {
332 if (GetType () == OptionValue::eTypeString)
333 return static_cast<const OptionValueString *>(this);
334 return nullptr;
335 }
336
337 OptionValueUInt64 *
GetAsUInt64()338 OptionValue::GetAsUInt64 ()
339 {
340 if (GetType () == OptionValue::eTypeUInt64)
341 return static_cast<OptionValueUInt64 *>(this);
342 return nullptr;
343 }
344
345 const OptionValueUInt64 *
GetAsUInt64() const346 OptionValue::GetAsUInt64 () const
347 {
348 if (GetType () == OptionValue::eTypeUInt64)
349 return static_cast<const OptionValueUInt64 *>(this);
350 return nullptr;
351 }
352
353 OptionValueUUID *
GetAsUUID()354 OptionValue::GetAsUUID ()
355 {
356 if (GetType () == OptionValue::eTypeUUID)
357 return static_cast<OptionValueUUID *>(this);
358 return nullptr;
359
360 }
361
362 const OptionValueUUID *
GetAsUUID() const363 OptionValue::GetAsUUID () const
364 {
365 if (GetType () == OptionValue::eTypeUUID)
366 return static_cast<const OptionValueUUID *>(this);
367 return nullptr;
368
369 }
370
371 bool
GetBooleanValue(bool fail_value) const372 OptionValue::GetBooleanValue (bool fail_value) const
373 {
374 const OptionValueBoolean *option_value = GetAsBoolean ();
375 if (option_value)
376 return option_value->GetCurrentValue();
377 return fail_value;
378 }
379
380 bool
SetBooleanValue(bool new_value)381 OptionValue::SetBooleanValue (bool new_value)
382 {
383 OptionValueBoolean *option_value = GetAsBoolean ();
384 if (option_value)
385 {
386 option_value->SetCurrentValue(new_value);
387 return true;
388 }
389 return false;
390 }
391
392 char
GetCharValue(char fail_value) const393 OptionValue::GetCharValue(char fail_value) const
394 {
395 const OptionValueChar *option_value = GetAsChar();
396 if (option_value)
397 return option_value->GetCurrentValue();
398 return fail_value;
399 }
400
401 char
SetCharValue(char new_value)402 OptionValue::SetCharValue(char new_value)
403 {
404 OptionValueChar *option_value = GetAsChar();
405 if (option_value)
406 {
407 option_value->SetCurrentValue(new_value);
408 return true;
409 }
410 return false;
411 }
412
413 int64_t
GetEnumerationValue(int64_t fail_value) const414 OptionValue::GetEnumerationValue (int64_t fail_value) const
415 {
416 const OptionValueEnumeration *option_value = GetAsEnumeration();
417 if (option_value)
418 return option_value->GetCurrentValue();
419 return fail_value;
420 }
421
422 bool
SetEnumerationValue(int64_t value)423 OptionValue::SetEnumerationValue (int64_t value)
424 {
425 OptionValueEnumeration *option_value = GetAsEnumeration();
426 if (option_value)
427 {
428 option_value->SetCurrentValue(value);
429 return true;
430 }
431 return false;
432 }
433
434 FileSpec
GetFileSpecValue() const435 OptionValue::GetFileSpecValue () const
436 {
437 const OptionValueFileSpec *option_value = GetAsFileSpec ();
438 if (option_value)
439 return option_value->GetCurrentValue();
440 return FileSpec();
441 }
442
443
444 bool
SetFileSpecValue(const FileSpec & file_spec)445 OptionValue::SetFileSpecValue (const FileSpec &file_spec)
446 {
447 OptionValueFileSpec *option_value = GetAsFileSpec ();
448 if (option_value)
449 {
450 option_value->SetCurrentValue(file_spec, false);
451 return true;
452 }
453 return false;
454 }
455
456 FileSpecList
GetFileSpecListValue() const457 OptionValue::GetFileSpecListValue () const
458 {
459 const OptionValueFileSpecList *option_value = GetAsFileSpecList ();
460 if (option_value)
461 return option_value->GetCurrentValue();
462 return FileSpecList();
463 }
464
465
466 lldb::Format
GetFormatValue(lldb::Format fail_value) const467 OptionValue::GetFormatValue (lldb::Format fail_value) const
468 {
469 const OptionValueFormat *option_value = GetAsFormat ();
470 if (option_value)
471 return option_value->GetCurrentValue();
472 return fail_value;
473 }
474
475 bool
SetFormatValue(lldb::Format new_value)476 OptionValue::SetFormatValue (lldb::Format new_value)
477 {
478 OptionValueFormat *option_value = GetAsFormat ();
479 if (option_value)
480 {
481 option_value->SetCurrentValue(new_value);
482 return true;
483 }
484 return false;
485 }
486
487 lldb::LanguageType
GetLanguageValue(lldb::LanguageType fail_value) const488 OptionValue::GetLanguageValue (lldb::LanguageType fail_value) const
489 {
490 const OptionValueLanguage *option_value = GetAsLanguage ();
491 if (option_value)
492 return option_value->GetCurrentValue();
493 return fail_value;
494 }
495
496 bool
SetLanguageValue(lldb::LanguageType new_language)497 OptionValue::SetLanguageValue (lldb::LanguageType new_language)
498 {
499 OptionValueLanguage *option_value = GetAsLanguage ();
500 if (option_value)
501 {
502 option_value->SetCurrentValue(new_language);
503 return true;
504 }
505 return false;
506 }
507
508 const FormatEntity::Entry *
GetFormatEntity() const509 OptionValue::GetFormatEntity () const
510 {
511 const OptionValueFormatEntity *option_value = GetAsFormatEntity();
512 if (option_value)
513 return &option_value->GetCurrentValue();
514 return nullptr;
515 }
516
517 const RegularExpression *
GetRegexValue() const518 OptionValue::GetRegexValue () const
519 {
520 const OptionValueRegex *option_value = GetAsRegex ();
521 if (option_value)
522 return option_value->GetCurrentValue();
523 return nullptr;
524 }
525
526
527 int64_t
GetSInt64Value(int64_t fail_value) const528 OptionValue::GetSInt64Value (int64_t fail_value) const
529 {
530 const OptionValueSInt64 *option_value = GetAsSInt64 ();
531 if (option_value)
532 return option_value->GetCurrentValue();
533 return fail_value;
534 }
535
536 bool
SetSInt64Value(int64_t new_value)537 OptionValue::SetSInt64Value (int64_t new_value)
538 {
539 OptionValueSInt64 *option_value = GetAsSInt64 ();
540 if (option_value)
541 {
542 option_value->SetCurrentValue(new_value);
543 return true;
544 }
545 return false;
546 }
547
548 const char *
GetStringValue(const char * fail_value) const549 OptionValue::GetStringValue (const char *fail_value) const
550 {
551 const OptionValueString *option_value = GetAsString ();
552 if (option_value)
553 return option_value->GetCurrentValue();
554 return fail_value;
555 }
556
557 bool
SetStringValue(const char * new_value)558 OptionValue::SetStringValue (const char *new_value)
559 {
560 OptionValueString *option_value = GetAsString ();
561 if (option_value)
562 {
563 option_value->SetCurrentValue(new_value);
564 return true;
565 }
566 return false;
567 }
568
569 uint64_t
GetUInt64Value(uint64_t fail_value) const570 OptionValue::GetUInt64Value (uint64_t fail_value) const
571 {
572 const OptionValueUInt64 *option_value = GetAsUInt64 ();
573 if (option_value)
574 return option_value->GetCurrentValue();
575 return fail_value;
576 }
577
578 bool
SetUInt64Value(uint64_t new_value)579 OptionValue::SetUInt64Value (uint64_t new_value)
580 {
581 OptionValueUInt64 *option_value = GetAsUInt64 ();
582 if (option_value)
583 {
584 option_value->SetCurrentValue(new_value);
585 return true;
586 }
587 return false;
588 }
589
590 UUID
GetUUIDValue() const591 OptionValue::GetUUIDValue () const
592 {
593 const OptionValueUUID *option_value = GetAsUUID();
594 if (option_value)
595 return option_value->GetCurrentValue();
596 return UUID();
597 }
598
599 bool
SetUUIDValue(const UUID & uuid)600 OptionValue::SetUUIDValue (const UUID &uuid)
601 {
602 OptionValueUUID *option_value = GetAsUUID();
603 if (option_value)
604 {
605 option_value->SetCurrentValue(uuid);
606 return true;
607 }
608 return false;
609 }
610
611 const char *
GetBuiltinTypeAsCString(Type t)612 OptionValue::GetBuiltinTypeAsCString (Type t)
613 {
614 switch (t)
615 {
616 case eTypeInvalid: return "invalid";
617 case eTypeArch: return "arch";
618 case eTypeArgs: return "arguments";
619 case eTypeArray: return "array";
620 case eTypeBoolean: return "boolean";
621 case eTypeChar:
622 return "char";
623 case eTypeDictionary: return "dictionary";
624 case eTypeEnum: return "enum";
625 case eTypeFileSpec: return "file";
626 case eTypeFileSpecList: return "file-list";
627 case eTypeFormat: return "format";
628 case eTypeFormatEntity: return "format-string";
629 case eTypeLanguage: return "language";
630 case eTypePathMap: return "path-map";
631 case eTypeProperties: return "properties";
632 case eTypeRegex: return "regex";
633 case eTypeSInt64: return "int";
634 case eTypeString: return "string";
635 case eTypeUInt64: return "unsigned";
636 case eTypeUUID: return "uuid";
637 }
638 return nullptr;
639 }
640
641
642 lldb::OptionValueSP
CreateValueFromCStringForTypeMask(const char * value_cstr,uint32_t type_mask,Error & error)643 OptionValue::CreateValueFromCStringForTypeMask (const char *value_cstr, uint32_t type_mask, Error &error)
644 {
645 // If only 1 bit is set in the type mask for a dictionary or array
646 // then we know how to decode a value from a cstring
647 lldb::OptionValueSP value_sp;
648 switch (type_mask)
649 {
650 case 1u << eTypeArch: value_sp.reset(new OptionValueArch()); break;
651 case 1u << eTypeBoolean: value_sp.reset(new OptionValueBoolean(false)); break;
652 case 1u << eTypeChar: value_sp.reset(new OptionValueChar('\0')); break;
653 case 1u << eTypeFileSpec: value_sp.reset(new OptionValueFileSpec()); break;
654 case 1u << eTypeFormat: value_sp.reset(new OptionValueFormat(eFormatInvalid)); break;
655 case 1u << eTypeFormatEntity: value_sp.reset(new OptionValueFormatEntity(NULL)); break;
656 case 1u << eTypeLanguage: value_sp.reset(new OptionValueLanguage(eLanguageTypeUnknown)); break;
657 case 1u << eTypeSInt64: value_sp.reset(new OptionValueSInt64()); break;
658 case 1u << eTypeString: value_sp.reset(new OptionValueString()); break;
659 case 1u << eTypeUInt64: value_sp.reset(new OptionValueUInt64()); break;
660 case 1u << eTypeUUID: value_sp.reset(new OptionValueUUID()); break;
661 }
662
663 if (value_sp)
664 error = value_sp->SetValueFromString (value_cstr, eVarSetOperationAssign);
665 else
666 error.SetErrorString("unsupported type mask");
667 return value_sp;
668 }
669
670 bool
DumpQualifiedName(Stream & strm) const671 OptionValue::DumpQualifiedName (Stream &strm) const
672 {
673 bool dumped_something = false;
674 lldb::OptionValueSP m_parent_sp(m_parent_wp.lock());
675 if (m_parent_sp)
676 {
677 if (m_parent_sp->DumpQualifiedName(strm))
678 dumped_something = true;
679 }
680 ConstString name (GetName());
681 if (name)
682 {
683 if (dumped_something)
684 strm.PutChar('.');
685 else
686 dumped_something = true;
687 strm << name;
688 }
689 return dumped_something;
690 }
691
692 size_t
AutoComplete(CommandInterpreter & interpreter,const char * s,int match_start_point,int max_return_elements,bool & word_complete,StringList & matches)693 OptionValue::AutoComplete (CommandInterpreter &interpreter,
694 const char *s,
695 int match_start_point,
696 int max_return_elements,
697 bool &word_complete,
698 StringList &matches)
699 {
700 word_complete = false;
701 matches.Clear();
702 return matches.GetSize();
703 }
704
705 Error
SetValueFromString(llvm::StringRef value,VarSetOperationType op)706 OptionValue::SetValueFromString (llvm::StringRef value, VarSetOperationType op)
707 {
708 Error error;
709 switch (op)
710 {
711 case eVarSetOperationReplace:
712 error.SetErrorStringWithFormat ("%s objects do not support the 'replace' operation", GetTypeAsCString());
713 break;
714 case eVarSetOperationInsertBefore:
715 error.SetErrorStringWithFormat ("%s objects do not support the 'insert-before' operation", GetTypeAsCString());
716 break;
717 case eVarSetOperationInsertAfter:
718 error.SetErrorStringWithFormat ("%s objects do not support the 'insert-after' operation", GetTypeAsCString());
719 break;
720 case eVarSetOperationRemove:
721 error.SetErrorStringWithFormat ("%s objects do not support the 'remove' operation", GetTypeAsCString());
722 break;
723 case eVarSetOperationAppend:
724 error.SetErrorStringWithFormat ("%s objects do not support the 'append' operation", GetTypeAsCString());
725 break;
726 case eVarSetOperationClear:
727 error.SetErrorStringWithFormat ("%s objects do not support the 'clear' operation", GetTypeAsCString());
728 break;
729 case eVarSetOperationAssign:
730 error.SetErrorStringWithFormat ("%s objects do not support the 'assign' operation", GetTypeAsCString());
731 break;
732 case eVarSetOperationInvalid:
733 error.SetErrorStringWithFormat ("invalid operation performed on a %s object", GetTypeAsCString());
734 break;
735 }
736 return error;
737 }
738
739