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