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