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