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