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