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

   1 //===-- OptionValueProperties.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/OptionValueProperties.h"
  11
  12 // C Includes
  13 // C++ Includes
  14 // Other libraries and framework includes
  15 // Project includes
  16 #include "lldb/Core/Flags.h"
  17 #include "lldb/Core/Stream.h"
  18 #include "lldb/Core/StringList.h"
  19 #include "lldb/Core/UserSettingsController.h"
  20 #include "lldb/Interpreter/Args.h"
  21 #include "lldb/Interpreter/OptionValues.h"
  22 #include "lldb/Interpreter/Property.h"
  23
  24 using namespace lldb;
  25 using namespace lldb_private;
  26
  27
  28 OptionValueProperties::OptionValueProperties (const ConstString &name) :
  29     OptionValue (),
  30     m_name (name),
  31     m_properties (),
  32     m_name_to_index ()
  33 {
  34 }
  35
  36 OptionValueProperties::OptionValueProperties (const OptionValueProperties &global_properties) :
  37     OptionValue (global_properties),
  38     m_name (global_properties.m_name),
  39     m_properties (global_properties.m_properties),
  40     m_name_to_index (global_properties.m_name_to_index)
  41 {
  42     // We now have an exact copy of "global_properties". We need to now
  43     // find all non-global settings and copy the property values so that
  44     // all non-global settings get new OptionValue instances created for
  45     // them.
  46     const size_t num_properties = m_properties.size();
  47     for (size_t i=0; i<num_properties; ++i)
  48     {
  49         // Duplicate any values that are not global when contructing properties from
  50         // a global copy
  51         if (m_properties[i].IsGlobal() == false)
  52         {
  53             lldb::OptionValueSP new_value_sp (m_properties[i].GetValue()->DeepCopy());
  54             m_properties[i].SetOptionValue(new_value_sp);
  55         }
  56     }
  57 }
  58
  59
  60
  61 size_t
  62 OptionValueProperties::GetNumProperties() const
  63 {
  64     return m_properties.size();
  65 }
  66
  67
  68 void
  69 OptionValueProperties::Initialize (const PropertyDefinition *defs)
  70 {
  71     for (size_t i=0; defs[i].name; ++i)
  72     {
  73         Property property(defs[i]);
  74         assert(property.IsValid());
  75         m_name_to_index.Append(property.GetName().GetCString(),m_properties.size());
  76         property.GetValue()->SetParent(shared_from_this());
  77         m_properties.push_back(property);
  78     }
  79     m_name_to_index.Sort();
  80 }
  81
  82 void
  83 OptionValueProperties::AppendProperty(const ConstString &name,
  84                                       const ConstString &desc,
  85                                       bool is_global,
  86                                       const OptionValueSP &value_sp)
  87 {
  88     Property property(name, desc, is_global, value_sp);
  89     m_name_to_index.Append(name.GetCString(),m_properties.size());
  90     m_properties.push_back(property);
  91     value_sp->SetParent (shared_from_this());
  92     m_name_to_index.Sort();
  93 }
  94
  95
  96
  97 //bool
  98 //OptionValueProperties::GetQualifiedName (Stream &strm)
  99 //{
 100 //    bool dumped_something = false;
 101 ////    lldb::OptionValuePropertiesSP parent_sp(GetParent ());
 102 ////    if (parent_sp)
 103 ////    {
 104 ////        parent_sp->GetQualifiedName (strm);
 105 ////        strm.PutChar('.');
 106 ////        dumped_something = true;
 107 ////    }
 108 //    if (m_name)
 109 //    {
 110 //        strm << m_name;
 111 //        dumped_something = true;
 112 //    }
 113 //    return dumped_something;
 114 //}
 115 //
 116 lldb::OptionValueSP
 117 OptionValueProperties::GetValueForKey  (const ExecutionContext *exe_ctx,
 118                                         const ConstString &key,
 119                                         bool will_modify) const
 120 {
 121     lldb::OptionValueSP value_sp;
 122     size_t idx = m_name_to_index.Find (key.GetCString(), SIZE_MAX);
 123     if (idx < m_properties.size())
 124         value_sp = GetPropertyAtIndex(exe_ctx, will_modify, idx)->GetValue();
 125     return value_sp;
 126 }
 127
 128 lldb::OptionValueSP
 129 OptionValueProperties::GetSubValue (const ExecutionContext *exe_ctx,
 130                                     const char *name,
 131                                     bool will_modify,
 132                                     Error &error) const
 133 {
 134     lldb::OptionValueSP value_sp;
 135
 136     if (name && name[0])
 137     {
 138         const char *sub_name = NULL;
 139         ConstString key;
 140         size_t key_len = ::strcspn (name, ".[{");
 141
 142         if (name[key_len])
 143         {
 144             key.SetCStringWithLength (name, key_len);
 145             sub_name = name + key_len;
 146         }
 147         else
 148             key.SetCString (name);
 149
 150         value_sp = GetValueForKey (exe_ctx, key, will_modify);
 151         if (sub_name && value_sp)
 152         {
 153             switch (sub_name[0])
 154             {
 155             case '.':
 156                 return value_sp->GetSubValue (exe_ctx, sub_name + 1, will_modify, error);
 157
 158             case '{':
 159                 // Predicate matching for predicates like
 160                 // "<setting-name>{<predicate>}"
 161                 // strings are parsed by the current OptionValueProperties subclass
 162                 // to mean whatever they want to. For instance a subclass of
 163                 // OptionValueProperties for a lldb_private::Target might implement:
 164                 // "target.run-args{arch==i386}"   -- only set run args if the arch is i386
 165                 // "target.run-args{path=/tmp/a/b/c/a.out}" -- only set run args if the path matches
 166                 // "target.run-args{basename==test&&arch==x86_64}" -- only set run args if exectable basename is "test" and arch is "x86_64"
 167                 if (sub_name[1])
 168                 {
 169                     const char *predicate_start = sub_name + 1;
 170                     const char *predicate_end = strchr(predicate_start, '}');
 171                     if (predicate_end)
 172                     {
 173                         std::string predicate(predicate_start, predicate_end);
 174                         if (PredicateMatches(exe_ctx, predicate.c_str()))
 175                         {
 176                             if (predicate_end[1])
 177                             {
 178                                 // Still more subvalue string to evaluate
 179                                 return value_sp->GetSubValue (exe_ctx, predicate_end + 1, will_modify, error);
 180                             }
 181                             else
 182                             {
 183                                 // We have a match!
 184                                 break;
 185                             }
 186                         }
 187                     }
 188                 }
 189                 // Predicate didn't match or wasn't correctly formed
 190                 value_sp.reset();
 191                 break;
 192
 193             case '[':
 194                 // Array or dictionary access for subvalues like:
 195                 // "[12]"       -- access 12th array element
 196                 // "['hello']"  -- dictionary access of key named hello
 197                 return value_sp->GetSubValue (exe_ctx, sub_name, will_modify, error);
 198
 199             default:
 200                 value_sp.reset();
 201                 break;
 202             }
 203         }
 204     }
 205     return value_sp;
 206 }
 207
 208 Error
 209 OptionValueProperties::SetSubValue (const ExecutionContext *exe_ctx,
 210                                     VarSetOperationType op,
 211                                     const char *name,
 212                                     const char *value)
 213 {
 214     Error error;
 215     const bool will_modify = true;
 216     lldb::OptionValueSP value_sp (GetSubValue (exe_ctx, name, will_modify, error));
 217     if (value_sp)
 218         error = value_sp->SetValueFromCString(value, op);
 219     else
 220     {
 221         if (error.AsCString() == NULL)
 222             error.SetErrorStringWithFormat("invalid value path '%s'", name);
 223     }
 224     return error;
 225 }
 226
 227
 228 ConstString
 229 OptionValueProperties::GetPropertyNameAtIndex (uint32_t idx) const
 230 {
 231     const Property *property = GetPropertyAtIndex(NULL, false, idx);
 232     if (property)
 233         return property->GetName();
 234     return ConstString();
 235
 236 }
 237
 238 const char *
 239 OptionValueProperties::GetPropertyDescriptionAtIndex (uint32_t idx) const
 240 {
 241     const Property *property = GetPropertyAtIndex(NULL, false, idx);
 242     if (property)
 243         return property->GetDescription();
 244     return NULL;
 245 }
 246
 247 uint32_t
 248 OptionValueProperties::GetPropertyIndex (const ConstString &name) const
 249 {
 250     return m_name_to_index.Find (name.GetCString(), SIZE_MAX);
 251 }
 252
 253 const Property *
 254 OptionValueProperties::GetProperty (const ExecutionContext *exe_ctx, bool will_modify, const ConstString &name) const
 255 {
 256     return GetPropertyAtIndex (exe_ctx, will_modify, m_name_to_index.Find (name.GetCString(), SIZE_MAX));
 257 }
 258
 259 const Property *
 260 OptionValueProperties::GetPropertyAtIndex (const ExecutionContext *exe_ctx, bool will_modify, uint32_t idx) const
 261 {
 262     return ProtectedGetPropertyAtIndex (idx);
 263 }
 264
 265 lldb::OptionValueSP
 266 OptionValueProperties::GetPropertyValueAtIndex (const ExecutionContext *exe_ctx,
 267                                                 bool will_modify,
 268                                                 uint32_t idx) const
 269 {
 270     const Property *setting = GetPropertyAtIndex (exe_ctx, will_modify, idx);
 271     if (setting)
 272         return setting->GetValue();
 273     return OptionValueSP();
 274 }
 275
 276 OptionValuePathMappings *
 277 OptionValueProperties::GetPropertyAtIndexAsOptionValuePathMappings (const ExecutionContext *exe_ctx, bool will_modify, uint32_t idx) const
 278 {
 279     OptionValueSP value_sp(GetPropertyValueAtIndex (exe_ctx, will_modify, idx));
 280     if (value_sp)
 281         return value_sp->GetAsPathMappings();
 282     return NULL;
 283 }
 284
 285 OptionValueFileSpecList *
 286 OptionValueProperties::GetPropertyAtIndexAsOptionValueFileSpecList (const ExecutionContext *exe_ctx, bool will_modify, uint32_t idx) const
 287 {
 288     OptionValueSP value_sp(GetPropertyValueAtIndex (exe_ctx, will_modify, idx));
 289     if (value_sp)
 290         return value_sp->GetAsFileSpecList();
 291     return NULL;
 292 }
 293
 294 OptionValueArch *
 295 OptionValueProperties::GetPropertyAtIndexAsOptionValueArch (const ExecutionContext *exe_ctx, uint32_t idx) const
 296 {
 297     const Property *property = GetPropertyAtIndex (exe_ctx, false, idx);
 298     if (property)
 299         return property->GetValue()->GetAsArch();
 300     return NULL;
 301 }
 302
 303 bool
 304 OptionValueProperties::GetPropertyAtIndexAsArgs (const ExecutionContext *exe_ctx, uint32_t idx, Args &args) const
 305 {
 306     const Property *property = GetPropertyAtIndex (exe_ctx, false, idx);
 307     if (property)
 308     {
 309         OptionValue *value = property->GetValue().get();
 310         if (value)
 311         {
 312             const OptionValueArray *array = value->GetAsArray();
 313             if (array)
 314                 return array->GetArgs(args);
 315             else
 316             {
 317                 const OptionValueDictionary *dict = value->GetAsDictionary();
 318                 if (dict)
 319                     return dict->GetArgs(args);
 320             }
 321         }
 322     }
 323     return false;
 324 }
 325
 326 bool
 327 OptionValueProperties::SetPropertyAtIndexFromArgs (const ExecutionContext *exe_ctx, uint32_t idx, const Args &args)
 328 {
 329     const Property *property = GetPropertyAtIndex (exe_ctx, true, idx);
 330     if (property)
 331     {
 332         OptionValue *value = property->GetValue().get();
 333         if (value)
 334         {
 335             OptionValueArray *array = value->GetAsArray();
 336             if (array)
 337                 return array->SetArgs(args, eVarSetOperationAssign).Success();
 338             else
 339             {
 340                 OptionValueDictionary *dict = value->GetAsDictionary();
 341                 if (dict)
 342                     return dict->SetArgs(args, eVarSetOperationAssign).Success();
 343             }
 344         }
 345     }
 346     return false;
 347 }
 348
 349 bool
 350 OptionValueProperties::GetPropertyAtIndexAsBoolean (const ExecutionContext *exe_ctx, uint32_t idx, bool fail_value) const
 351 {
 352     const Property *property = GetPropertyAtIndex (exe_ctx, false, idx);
 353     if (property)
 354     {
 355         OptionValue *value = property->GetValue().get();
 356         if (value)
 357             return value->GetBooleanValue(fail_value);
 358     }
 359     return fail_value;
 360 }
 361
 362 bool
 363 OptionValueProperties::SetPropertyAtIndexAsBoolean (const ExecutionContext *exe_ctx, uint32_t idx, bool new_value)
 364 {
 365     const Property *property = GetPropertyAtIndex (exe_ctx, true, idx);
 366     if (property)
 367     {
 368         OptionValue *value = property->GetValue().get();
 369         if (value)
 370         {
 371             value->SetBooleanValue(new_value);
 372             return true;
 373         }
 374     }
 375     return false;
 376 }
 377
 378 OptionValueDictionary *
 379 OptionValueProperties::GetPropertyAtIndexAsOptionValueDictionary (const ExecutionContext *exe_ctx, uint32_t idx) const
 380 {
 381     const Property *property = GetPropertyAtIndex (exe_ctx, false, idx);
 382     if (property)
 383         return property->GetValue()->GetAsDictionary();
 384     return NULL;
 385 }
 386
 387 int64_t
 388 OptionValueProperties::GetPropertyAtIndexAsEnumeration (const ExecutionContext *exe_ctx, uint32_t idx, int64_t fail_value) const
 389 {
 390     const Property *property = GetPropertyAtIndex (exe_ctx, false, idx);
 391     if (property)
 392     {
 393         OptionValue *value = property->GetValue().get();
 394         if (value)
 395             return value->GetEnumerationValue(fail_value);
 396     }
 397     return fail_value;
 398 }
 399
 400 bool
 401 OptionValueProperties::SetPropertyAtIndexAsEnumeration (const ExecutionContext *exe_ctx, uint32_t idx, int64_t new_value)
 402 {
 403     const Property *property = GetPropertyAtIndex (exe_ctx, true, idx);
 404     if (property)
 405     {
 406         OptionValue *value = property->GetValue().get();
 407         if (value)
 408             return value->SetEnumerationValue(new_value);
 409     }
 410     return false;
 411 }
 412
 413
 414 OptionValueFileSpec *
 415 OptionValueProperties::GetPropertyAtIndexAsOptionValueFileSpec (const ExecutionContext *exe_ctx, bool will_modify, uint32_t idx) const
 416 {
 417     const Property *property = GetPropertyAtIndex (exe_ctx, false, idx);
 418     if (property)
 419     {
 420         OptionValue *value = property->GetValue().get();
 421         if (value)
 422             return value->GetAsFileSpec();
 423     }
 424     return NULL;
 425 }
 426
 427
 428 FileSpec
 429 OptionValueProperties::GetPropertyAtIndexAsFileSpec (const ExecutionContext *exe_ctx, uint32_t idx) const
 430 {
 431     const Property *property = GetPropertyAtIndex (exe_ctx, false, idx);
 432     if (property)
 433     {
 434         OptionValue *value = property->GetValue().get();
 435         if (value)
 436             return value->GetFileSpecValue();
 437     }
 438     return FileSpec();
 439 }
 440
 441
 442 bool
 443 OptionValueProperties::SetPropertyAtIndexAsFileSpec (const ExecutionContext *exe_ctx, uint32_t idx, const FileSpec &new_file_spec)
 444 {
 445     const Property *property = GetPropertyAtIndex (exe_ctx, true, idx);
 446     if (property)
 447     {
 448         OptionValue *value = property->GetValue().get();
 449         if (value)
 450             return value->SetFileSpecValue(new_file_spec);
 451     }
 452     return false;
 453 }
 454
 455 const RegularExpression *
 456 OptionValueProperties::GetPropertyAtIndexAsOptionValueRegex (const ExecutionContext *exe_ctx, uint32_t idx) const
 457 {
 458     const Property *property = GetPropertyAtIndex (exe_ctx, false, idx);
 459     if (property)
 460     {
 461         OptionValue *value = property->GetValue().get();
 462         if (value)
 463             return value->GetRegexValue();
 464     }
 465     return NULL;
 466 }
 467
 468 OptionValueSInt64 *
 469 OptionValueProperties::GetPropertyAtIndexAsOptionValueSInt64 (const ExecutionContext *exe_ctx, uint32_t idx) const
 470 {
 471     const Property *property = GetPropertyAtIndex (exe_ctx, false, idx);
 472     if (property)
 473     {
 474         OptionValue *value = property->GetValue().get();
 475         if (value)
 476             return value->GetAsSInt64();
 477     }
 478     return NULL;
 479 }
 480
 481 int64_t
 482 OptionValueProperties::GetPropertyAtIndexAsSInt64 (const ExecutionContext *exe_ctx, uint32_t idx, int64_t fail_value) const
 483 {
 484     const Property *property = GetPropertyAtIndex (exe_ctx, false, idx);
 485     if (property)
 486     {
 487         OptionValue *value = property->GetValue().get();
 488         if (value)
 489             return value->GetSInt64Value(fail_value);
 490     }
 491     return fail_value;
 492 }
 493
 494 bool
 495 OptionValueProperties::SetPropertyAtIndexAsSInt64 (const ExecutionContext *exe_ctx, uint32_t idx, int64_t new_value)
 496 {
 497     const Property *property = GetPropertyAtIndex (exe_ctx, true, idx);
 498     if (property)
 499     {
 500         OptionValue *value = property->GetValue().get();
 501         if (value)
 502             return value->SetSInt64Value(new_value);
 503     }
 504     return false;
 505 }
 506
 507 const char *
 508 OptionValueProperties::GetPropertyAtIndexAsString (const ExecutionContext *exe_ctx, uint32_t idx, const char *fail_value) const
 509 {
 510     const Property *property = GetPropertyAtIndex (exe_ctx, false, idx);
 511     if (property)
 512     {
 513         OptionValue *value = property->GetValue().get();
 514         if (value)
 515             return value->GetStringValue(fail_value);
 516     }
 517     return fail_value;
 518 }
 519
 520 bool
 521 OptionValueProperties::SetPropertyAtIndexAsString (const ExecutionContext *exe_ctx, uint32_t idx, const char *new_value)
 522 {
 523     const Property *property = GetPropertyAtIndex (exe_ctx, true, idx);
 524     if (property)
 525     {
 526         OptionValue *value = property->GetValue().get();
 527         if (value)
 528             return value->SetStringValue(new_value);
 529     }
 530     return false;
 531 }
 532
 533 OptionValueString *
 534 OptionValueProperties::GetPropertyAtIndexAsOptionValueString (const ExecutionContext *exe_ctx, bool will_modify, uint32_t idx) const
 535 {
 536     OptionValueSP value_sp(GetPropertyValueAtIndex (exe_ctx, will_modify, idx));
 537     if (value_sp)
 538         return value_sp->GetAsString();
 539     return NULL;
 540 }
 541
 542
 543 uint64_t
 544 OptionValueProperties::GetPropertyAtIndexAsUInt64 (const ExecutionContext *exe_ctx, uint32_t idx, uint64_t fail_value) const
 545 {
 546     const Property *property = GetPropertyAtIndex (exe_ctx, false, idx);
 547     if (property)
 548     {
 549         OptionValue *value = property->GetValue().get();
 550         if (value)
 551             return value->GetUInt64Value(fail_value);
 552     }
 553     return fail_value;
 554 }
 555
 556 bool
 557 OptionValueProperties::SetPropertyAtIndexAsUInt64 (const ExecutionContext *exe_ctx, uint32_t idx, uint64_t new_value)
 558 {
 559     const Property *property = GetPropertyAtIndex (exe_ctx, true, idx);
 560     if (property)
 561     {
 562         OptionValue *value = property->GetValue().get();
 563         if (value)
 564             return value->SetUInt64Value(new_value);
 565     }
 566     return false;
 567 }
 568
 569 bool
 570 OptionValueProperties::Clear ()
 571 {
 572     const size_t num_properties = m_properties.size();
 573     for (size_t i=0; i<num_properties; ++i)
 574         m_properties[i].GetValue()->Clear();
 575     return true;
 576 }
 577
 578
 579 Error
 580 OptionValueProperties::SetValueFromCString (const char *value, VarSetOperationType op)
 581 {
 582     Error error;
 583
 584 //    Args args(value_cstr);
 585 //    const size_t argc = args.GetArgumentCount();
 586     switch (op)
 587     {
 588         case eVarSetOperationClear:
 589             Clear ();
 590             break;
 591
 592         case eVarSetOperationReplace:
 593         case eVarSetOperationAssign:
 594         case eVarSetOperationRemove:
 595         case eVarSetOperationInsertBefore:
 596         case eVarSetOperationInsertAfter:
 597         case eVarSetOperationAppend:
 598         case eVarSetOperationInvalid:
 599             error = OptionValue::SetValueFromCString (value, op);
 600             break;
 601     }
 602
 603     return error;
 604 }
 605
 606 void
 607 OptionValueProperties::DumpValue (const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask)
 608 {
 609     const size_t num_properties = m_properties.size();
 610     for (size_t i=0; i<num_properties; ++i)
 611     {
 612         const Property *property = GetPropertyAtIndex(exe_ctx, false, i);
 613         if (property)
 614         {
 615             OptionValue *option_value = property->GetValue().get();
 616             assert (option_value);
 617             const bool transparent_value = option_value->ValueIsTransparent ();
 618             property->Dump (exe_ctx,
 619                             strm,
 620                             dump_mask);
 621             if (!transparent_value)
 622                 strm.EOL();
 623         }
 624     }
 625 }
 626
 627 Error
 628 OptionValueProperties::DumpPropertyValue (const ExecutionContext *exe_ctx,
 629                                           Stream &strm,
 630                                           const char *property_path,
 631                                           uint32_t dump_mask)
 632 {
 633     Error error;
 634     const bool will_modify = false;
 635     lldb::OptionValueSP value_sp (GetSubValue (exe_ctx, property_path, will_modify, error));
 636     if (value_sp)
 637     {
 638         if (!value_sp->ValueIsTransparent ())
 639         {
 640             if (dump_mask & eDumpOptionName)
 641                 strm.PutCString (property_path);
 642             if (dump_mask & ~eDumpOptionName)
 643                 strm.PutChar (' ');
 644         }
 645         value_sp->DumpValue (exe_ctx, strm, dump_mask);
 646     }
 647     return error;
 648 }
 649
 650 lldb::OptionValueSP
 651 OptionValueProperties::DeepCopy () const
 652 {
 653     assert(!"this shouldn't happen");
 654     return lldb::OptionValueSP();
 655 }
 656
 657 const Property *
 658 OptionValueProperties::GetPropertyAtPath (const ExecutionContext *exe_ctx,
 659                                           bool will_modify,
 660                                           const char *name) const
 661 {
 662     const Property *property = NULL;
 663     if (name && name[0])
 664     {
 665         const char *sub_name = NULL;
 666         ConstString key;
 667         size_t key_len = ::strcspn (name, ".[{");
 668
 669         if (name[key_len])
 670         {
 671             key.SetCStringWithLength (name, key_len);
 672             sub_name = name + key_len;
 673         }
 674         else
 675             key.SetCString (name);
 676
 677         property = GetProperty (exe_ctx, will_modify, key);
 678         if (sub_name && property)
 679         {
 680             if (sub_name[0] == '.')
 681             {
 682                 OptionValueProperties *sub_properties = property->GetValue()->GetAsProperties();
 683                 if (sub_properties)
 684                     return sub_properties->GetPropertyAtPath(exe_ctx, will_modify, sub_name + 1);
 685             }
 686             property = NULL;
 687         }
 688     }
 689     return property;
 690 }
 691
 692 void
 693 OptionValueProperties::DumpAllDescriptions (CommandInterpreter &interpreter,
 694                                             Stream &strm) const
 695 {
 696     size_t max_name_len = 0;
 697     const size_t num_properties = m_properties.size();
 698     for (size_t i=0; i<num_properties; ++i)
 699     {
 700         const Property *property = ProtectedGetPropertyAtIndex(i);
 701         if (property)
 702             max_name_len = std::max<size_t>(property->GetName().GetLength(), max_name_len);
 703     }
 704     for (size_t i=0; i<num_properties; ++i)
 705     {
 706         const Property *property = ProtectedGetPropertyAtIndex(i);
 707         if (property)
 708             property->DumpDescription (interpreter, strm, max_name_len, false);
 709     }
 710 }
 711
 712 void
 713 OptionValueProperties::Apropos (const char *keyword, std::vector<const Property *> &matching_properties) const
 714 {
 715     const size_t num_properties = m_properties.size();
 716     StreamString strm;
 717     for (size_t i=0; i<num_properties; ++i)
 718     {
 719         const Property *property = ProtectedGetPropertyAtIndex(i);
 720         if (property)
 721         {
 722             const OptionValueProperties *properties = property->GetValue()->GetAsProperties();
 723             if (properties)
 724             {
 725                 properties->Apropos (keyword, matching_properties);
 726             }
 727             else
 728             {
 729                 bool match = false;
 730                 const char *name = property->GetName().GetCString();
 731                 if (name && ::strcasestr(name, keyword))
 732                     match = true;
 733                 else
 734                 {
 735                     const char *desc = property->GetDescription();
 736                     if (desc && ::strcasestr(desc, keyword))
 737                         match = true;
 738                 }
 739                 if (match)
 740                 {
 741                     matching_properties.push_back (property);
 742                 }
 743             }
 744         }
 745     }
 746 }
 747
 748 lldb::OptionValuePropertiesSP
 749 OptionValueProperties::GetSubProperty (const ExecutionContext *exe_ctx,
 750                                        const ConstString &name)
 751 {
 752     lldb::OptionValueSP option_value_sp(GetValueForKey(exe_ctx, name, false));
 753     if (option_value_sp)
 754     {
 755         OptionValueProperties *ov_properties = option_value_sp->GetAsProperties ();
 756         if (ov_properties)
 757             return ov_properties->shared_from_this();
 758     }
 759     return lldb::OptionValuePropertiesSP();
 760 }
 761
 762
 763