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