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