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