contrib/llvm/tools/lldb/source/Interpreter/OptionValue.cpp

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