[lldb][NFC] Fix all formatting errors in .cpp file headers
Summary:
A *.cpp file header in LLDB (and in LLDB) should like this:
```
//===-- TestUtilities.cpp -------------------------------------------------===//
```
However in LLDB most of our source files have arbitrary changes to this format and
these changes are spreading through LLDB as folks usually just use the existing
source files as templates for their new files (most notably the unnecessary
editor language indicator `-*- C++ -*-` is spreading and in every review
someone is pointing out that this is wrong, resulting in people pointing out that this
is done in the same way in other files).
This patch removes most of these inconsistencies including the editor language indicators,
all the different missing/additional '-' characters, files that center the file name, missing
trailing `===//` (mostly caused by clang-format breaking the line).
Reviewers: aprantl, espindola, jfb, shafik, JDevlieghere
Reviewed By: JDevlieghere
Subscribers: dexonsmith, wuzish, emaste, sdardis, nemanjai, kbarton, MaskRay, atanasyan, arphaman, jfb, abidh, jsji, JDevlieghere, usaxena95, lldb-commits
Tags: #lldb
Differential Revision: https://reviews.llvm.org/D73258
2020-01-24 15:23:27 +08:00
|
|
|
//===-- OptionValueProperties.cpp -----------------------------------------===//
|
2012-08-23 01:17:09 +08:00
|
|
|
//
|
2019-01-19 16:50:56 +08:00
|
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
2012-08-23 01:17:09 +08:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "lldb/Interpreter/OptionValueProperties.h"
|
|
|
|
|
2017-02-15 03:06:07 +08:00
|
|
|
#include "lldb/Utility/Flags.h"
|
|
|
|
|
2012-08-23 01:17:09 +08:00
|
|
|
#include "lldb/Core/UserSettingsController.h"
|
|
|
|
#include "lldb/Interpreter/OptionValues.h"
|
|
|
|
#include "lldb/Interpreter/Property.h"
|
2018-04-18 02:53:35 +08:00
|
|
|
#include "lldb/Utility/Args.h"
|
2017-02-03 05:39:50 +08:00
|
|
|
#include "lldb/Utility/Stream.h"
|
2017-03-22 02:25:04 +08:00
|
|
|
#include "lldb/Utility/StringList.h"
|
2012-08-23 01:17:09 +08:00
|
|
|
|
|
|
|
using namespace lldb;
|
|
|
|
using namespace lldb_private;
|
|
|
|
|
2021-02-20 04:42:42 +08:00
|
|
|
OptionValueProperties::OptionValueProperties(ConstString name) : m_name(name) {}
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2012-08-23 01:17:09 +08:00
|
|
|
size_t OptionValueProperties::GetNumProperties() const {
|
|
|
|
return m_properties.size();
|
|
|
|
}
|
|
|
|
|
2018-09-27 15:11:58 +08:00
|
|
|
void OptionValueProperties::Initialize(const PropertyDefinitions &defs) {
|
|
|
|
for (const auto &definition : defs) {
|
|
|
|
Property property(definition);
|
2012-08-23 01:17:09 +08:00
|
|
|
assert(property.IsValid());
|
2017-05-02 18:17:30 +08:00
|
|
|
m_name_to_index.Append(ConstString(property.GetName()), m_properties.size());
|
2012-08-23 01:17:09 +08:00
|
|
|
property.GetValue()->SetParent(shared_from_this());
|
|
|
|
m_properties.push_back(property);
|
|
|
|
}
|
|
|
|
m_name_to_index.Sort();
|
|
|
|
}
|
|
|
|
|
2015-01-14 05:13:08 +08:00
|
|
|
void OptionValueProperties::SetValueChangedCallback(
|
2020-01-09 21:14:54 +08:00
|
|
|
uint32_t property_idx, std::function<void()> callback) {
|
2015-01-14 05:13:08 +08:00
|
|
|
Property *property = ProtectedGetPropertyAtIndex(property_idx);
|
|
|
|
if (property)
|
2020-01-09 21:14:54 +08:00
|
|
|
property->SetValueChangedCallback(std::move(callback));
|
2015-01-14 05:13:08 +08:00
|
|
|
}
|
|
|
|
|
2019-03-07 05:22:25 +08:00
|
|
|
void OptionValueProperties::AppendProperty(ConstString name,
|
|
|
|
ConstString desc,
|
2012-08-23 01:17:09 +08:00
|
|
|
bool is_global,
|
|
|
|
const OptionValueSP &value_sp) {
|
|
|
|
Property property(name, desc, is_global, value_sp);
|
2017-05-02 18:17:30 +08:00
|
|
|
m_name_to_index.Append(name, m_properties.size());
|
2012-08-23 01:17:09 +08:00
|
|
|
m_properties.push_back(property);
|
|
|
|
value_sp->SetParent(shared_from_this());
|
|
|
|
m_name_to_index.Sort();
|
|
|
|
}
|
|
|
|
|
|
|
|
// bool
|
|
|
|
// OptionValueProperties::GetQualifiedName (Stream &strm)
|
|
|
|
//{
|
|
|
|
// bool dumped_something = false;
|
|
|
|
//// lldb::OptionValuePropertiesSP parent_sp(GetParent ());
|
|
|
|
//// if (parent_sp)
|
|
|
|
//// {
|
|
|
|
//// parent_sp->GetQualifiedName (strm);
|
|
|
|
//// strm.PutChar('.');
|
|
|
|
//// dumped_something = true;
|
|
|
|
//// }
|
|
|
|
// if (m_name)
|
|
|
|
// {
|
|
|
|
// strm << m_name;
|
|
|
|
// dumped_something = true;
|
|
|
|
// }
|
|
|
|
// return dumped_something;
|
|
|
|
//}
|
|
|
|
//
|
|
|
|
lldb::OptionValueSP
|
|
|
|
OptionValueProperties::GetValueForKey(const ExecutionContext *exe_ctx,
|
2019-03-07 05:22:25 +08:00
|
|
|
ConstString key,
|
2012-08-23 01:17:09 +08:00
|
|
|
bool will_modify) const {
|
|
|
|
lldb::OptionValueSP value_sp;
|
2017-05-02 18:17:30 +08:00
|
|
|
size_t idx = m_name_to_index.Find(key, SIZE_MAX);
|
2012-08-23 01:17:09 +08:00
|
|
|
if (idx < m_properties.size())
|
|
|
|
value_sp = GetPropertyAtIndex(exe_ctx, will_modify, idx)->GetValue();
|
|
|
|
return value_sp;
|
|
|
|
}
|
|
|
|
|
|
|
|
lldb::OptionValueSP
|
|
|
|
OptionValueProperties::GetSubValue(const ExecutionContext *exe_ctx,
|
2017-05-12 12:51:55 +08:00
|
|
|
llvm::StringRef name, bool will_modify,
|
|
|
|
Status &error) const {
|
2012-08-23 01:17:09 +08:00
|
|
|
lldb::OptionValueSP value_sp;
|
2016-11-18 02:08:12 +08:00
|
|
|
if (name.empty())
|
|
|
|
return OptionValueSP();
|
|
|
|
|
|
|
|
llvm::StringRef sub_name;
|
|
|
|
ConstString key;
|
|
|
|
size_t key_len = name.find_first_of(".[{");
|
|
|
|
if (key_len != llvm::StringRef::npos) {
|
|
|
|
key.SetString(name.take_front(key_len));
|
|
|
|
sub_name = name.drop_front(key_len);
|
|
|
|
} else
|
|
|
|
key.SetString(name);
|
|
|
|
|
|
|
|
value_sp = GetValueForKey(exe_ctx, key, will_modify);
|
|
|
|
if (sub_name.empty() || !value_sp)
|
|
|
|
return value_sp;
|
|
|
|
|
|
|
|
switch (sub_name[0]) {
|
|
|
|
case '.': {
|
|
|
|
lldb::OptionValueSP return_val_sp;
|
|
|
|
return_val_sp =
|
|
|
|
value_sp->GetSubValue(exe_ctx, sub_name.drop_front(), will_modify, error);
|
|
|
|
if (!return_val_sp) {
|
|
|
|
if (Properties::IsSettingExperimental(sub_name.drop_front())) {
|
|
|
|
size_t experimental_len =
|
|
|
|
strlen(Properties::GetExperimentalSettingsName());
|
|
|
|
if (sub_name[experimental_len + 1] == '.')
|
|
|
|
return_val_sp = value_sp->GetSubValue(
|
|
|
|
exe_ctx, sub_name.drop_front(experimental_len + 2), will_modify, error);
|
|
|
|
// It isn't an error if an experimental setting is not present.
|
|
|
|
if (!return_val_sp)
|
|
|
|
error.Clear();
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2016-11-18 02:08:12 +08:00
|
|
|
}
|
|
|
|
return return_val_sp;
|
|
|
|
}
|
|
|
|
case '[':
|
2018-05-01 00:49:04 +08:00
|
|
|
// Array or dictionary access for subvalues like: "[12]" -- access
|
|
|
|
// 12th array element "['hello']" -- dictionary access of key named hello
|
2016-11-18 02:08:12 +08:00
|
|
|
return value_sp->GetSubValue(exe_ctx, sub_name, will_modify, error);
|
|
|
|
|
|
|
|
default:
|
|
|
|
value_sp.reset();
|
|
|
|
break;
|
2012-08-23 01:17:09 +08:00
|
|
|
}
|
2015-02-20 19:14:59 +08:00
|
|
|
return value_sp;
|
2012-08-23 01:17:09 +08:00
|
|
|
}
|
|
|
|
|
2017-05-12 12:51:55 +08:00
|
|
|
Status OptionValueProperties::SetSubValue(const ExecutionContext *exe_ctx,
|
|
|
|
VarSetOperationType op,
|
|
|
|
llvm::StringRef name,
|
|
|
|
llvm::StringRef value) {
|
|
|
|
Status error;
|
2012-08-23 01:17:09 +08:00
|
|
|
const bool will_modify = true;
|
2018-05-02 06:49:01 +08:00
|
|
|
llvm::SmallVector<llvm::StringRef, 8> components;
|
|
|
|
name.split(components, '.');
|
|
|
|
bool name_contains_experimental = false;
|
|
|
|
for (const auto &part : components)
|
|
|
|
if (Properties::IsSettingExperimental(part))
|
|
|
|
name_contains_experimental = true;
|
|
|
|
|
2012-08-23 01:17:09 +08:00
|
|
|
lldb::OptionValueSP value_sp(GetSubValue(exe_ctx, name, will_modify, error));
|
|
|
|
if (value_sp)
|
2016-11-18 02:08:12 +08:00
|
|
|
error = value_sp->SetValueFromString(value, op);
|
2016-09-07 04:57:50 +08:00
|
|
|
else {
|
2018-05-02 06:49:01 +08:00
|
|
|
// Don't set an error if the path contained .experimental. - those are
|
|
|
|
// allowed to be missing and should silently fail.
|
2018-12-15 08:15:33 +08:00
|
|
|
if (!name_contains_experimental && error.AsCString() == nullptr) {
|
2016-11-18 02:08:12 +08:00
|
|
|
error.SetErrorStringWithFormat("invalid value path '%s'", name.str().c_str());
|
2018-05-02 06:49:01 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2012-08-23 01:17:09 +08:00
|
|
|
return error;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2012-08-23 01:17:09 +08:00
|
|
|
|
|
|
|
uint32_t
|
2019-03-07 05:22:25 +08:00
|
|
|
OptionValueProperties::GetPropertyIndex(ConstString name) const {
|
2017-05-02 18:17:30 +08:00
|
|
|
return m_name_to_index.Find(name, SIZE_MAX);
|
2012-08-23 01:17:09 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
const Property *
|
|
|
|
OptionValueProperties::GetProperty(const ExecutionContext *exe_ctx,
|
|
|
|
bool will_modify,
|
2019-03-07 05:22:25 +08:00
|
|
|
ConstString name) const {
|
2016-10-07 05:22:44 +08:00
|
|
|
return GetPropertyAtIndex(
|
|
|
|
exe_ctx, will_modify,
|
2017-05-02 18:17:30 +08:00
|
|
|
m_name_to_index.Find(name, SIZE_MAX));
|
2012-08-23 01:17:09 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
const Property *OptionValueProperties::GetPropertyAtIndex(
|
|
|
|
const ExecutionContext *exe_ctx, bool will_modify, uint32_t idx) const {
|
|
|
|
return ProtectedGetPropertyAtIndex(idx);
|
|
|
|
}
|
|
|
|
|
|
|
|
lldb::OptionValueSP OptionValueProperties::GetPropertyValueAtIndex(
|
|
|
|
const ExecutionContext *exe_ctx, bool will_modify, uint32_t idx) const {
|
|
|
|
const Property *setting = GetPropertyAtIndex(exe_ctx, will_modify, idx);
|
|
|
|
if (setting)
|
|
|
|
return setting->GetValue();
|
|
|
|
return OptionValueSP();
|
|
|
|
}
|
|
|
|
|
|
|
|
OptionValuePathMappings *
|
|
|
|
OptionValueProperties::GetPropertyAtIndexAsOptionValuePathMappings(
|
|
|
|
const ExecutionContext *exe_ctx, bool will_modify, uint32_t idx) const {
|
|
|
|
OptionValueSP value_sp(GetPropertyValueAtIndex(exe_ctx, will_modify, idx));
|
|
|
|
if (value_sp)
|
|
|
|
return value_sp->GetAsPathMappings();
|
2014-04-20 08:31:37 +08:00
|
|
|
return nullptr;
|
2012-08-23 01:17:09 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
OptionValueFileSpecList *
|
|
|
|
OptionValueProperties::GetPropertyAtIndexAsOptionValueFileSpecList(
|
|
|
|
const ExecutionContext *exe_ctx, bool will_modify, uint32_t idx) const {
|
|
|
|
OptionValueSP value_sp(GetPropertyValueAtIndex(exe_ctx, will_modify, idx));
|
2015-07-22 06:05:07 +08:00
|
|
|
if (value_sp)
|
|
|
|
return value_sp->GetAsFileSpecList();
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2012-08-23 01:17:09 +08:00
|
|
|
OptionValueArch *OptionValueProperties::GetPropertyAtIndexAsOptionValueArch(
|
|
|
|
const ExecutionContext *exe_ctx, uint32_t idx) const {
|
|
|
|
const Property *property = GetPropertyAtIndex(exe_ctx, false, idx);
|
|
|
|
if (property)
|
|
|
|
return property->GetValue()->GetAsArch();
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2015-07-22 06:05:07 +08:00
|
|
|
OptionValueLanguage *
|
|
|
|
OptionValueProperties::GetPropertyAtIndexAsOptionValueLanguage(
|
2012-08-23 01:17:09 +08:00
|
|
|
const ExecutionContext *exe_ctx, uint32_t idx) const {
|
|
|
|
const Property *property = GetPropertyAtIndex(exe_ctx, false, idx);
|
|
|
|
if (property)
|
|
|
|
return property->GetValue()->GetAsLanguage();
|
2014-04-20 08:31:37 +08:00
|
|
|
return nullptr;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
2012-08-23 01:17:09 +08:00
|
|
|
bool OptionValueProperties::GetPropertyAtIndexAsArgs(
|
|
|
|
const ExecutionContext *exe_ctx, uint32_t idx, Args &args) const {
|
|
|
|
const Property *property = GetPropertyAtIndex(exe_ctx, false, idx);
|
2021-02-20 05:33:47 +08:00
|
|
|
if (!property)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
OptionValue *value = property->GetValue().get();
|
|
|
|
if (!value)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
const OptionValueArgs *arguments = value->GetAsArgs();
|
|
|
|
if (arguments)
|
|
|
|
return arguments->GetArgs(args);
|
|
|
|
|
|
|
|
const OptionValueArray *array = value->GetAsArray();
|
|
|
|
if (array)
|
|
|
|
return array->GetArgs(args);
|
|
|
|
|
|
|
|
const OptionValueDictionary *dict = value->GetAsDictionary();
|
|
|
|
if (dict)
|
|
|
|
return dict->GetArgs(args);
|
|
|
|
|
2012-08-23 01:17:09 +08:00
|
|
|
return false;
|
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2012-08-23 01:17:09 +08:00
|
|
|
bool OptionValueProperties::SetPropertyAtIndexFromArgs(
|
|
|
|
const ExecutionContext *exe_ctx, uint32_t idx, const Args &args) {
|
|
|
|
const Property *property = GetPropertyAtIndex(exe_ctx, true, idx);
|
2021-02-20 05:33:47 +08:00
|
|
|
if (!property)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
OptionValue *value = property->GetValue().get();
|
|
|
|
if (!value)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
OptionValueArgs *arguments = value->GetAsArgs();
|
|
|
|
if (arguments)
|
|
|
|
return arguments->SetArgs(args, eVarSetOperationAssign).Success();
|
|
|
|
|
|
|
|
OptionValueArray *array = value->GetAsArray();
|
|
|
|
if (array)
|
|
|
|
return array->SetArgs(args, eVarSetOperationAssign).Success();
|
|
|
|
|
|
|
|
OptionValueDictionary *dict = value->GetAsDictionary();
|
|
|
|
if (dict)
|
|
|
|
return dict->SetArgs(args, eVarSetOperationAssign).Success();
|
|
|
|
|
2012-08-23 01:17:09 +08:00
|
|
|
return false;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
2012-08-23 02:39:03 +08:00
|
|
|
bool OptionValueProperties::GetPropertyAtIndexAsBoolean(
|
2012-08-23 01:17:09 +08:00
|
|
|
const ExecutionContext *exe_ctx, uint32_t idx, bool fail_value) const {
|
2015-07-22 06:05:07 +08:00
|
|
|
const Property *property = GetPropertyAtIndex(exe_ctx, false, idx);
|
|
|
|
if (property) {
|
2012-08-23 01:17:09 +08:00
|
|
|
OptionValue *value = property->GetValue().get();
|
|
|
|
if (value)
|
|
|
|
return value->GetBooleanValue(fail_value);
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2012-08-23 01:17:09 +08:00
|
|
|
return fail_value;
|
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2012-08-23 01:17:09 +08:00
|
|
|
bool OptionValueProperties::SetPropertyAtIndexAsBoolean(
|
|
|
|
const ExecutionContext *exe_ctx, uint32_t idx, bool new_value) {
|
|
|
|
const Property *property = GetPropertyAtIndex(exe_ctx, true, idx);
|
|
|
|
if (property) {
|
|
|
|
OptionValue *value = property->GetValue().get();
|
|
|
|
if (value) {
|
|
|
|
value->SetBooleanValue(new_value);
|
|
|
|
return true;
|
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2012-08-23 01:17:09 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
OptionValueDictionary *
|
|
|
|
OptionValueProperties::GetPropertyAtIndexAsOptionValueDictionary(
|
|
|
|
const ExecutionContext *exe_ctx, uint32_t idx) const {
|
|
|
|
const Property *property = GetPropertyAtIndex(exe_ctx, false, idx);
|
|
|
|
if (property)
|
|
|
|
return property->GetValue()->GetAsDictionary();
|
2014-04-20 08:31:37 +08:00
|
|
|
return nullptr;
|
2012-08-23 01:17:09 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2012-08-23 01:17:09 +08:00
|
|
|
int64_t OptionValueProperties::GetPropertyAtIndexAsEnumeration(
|
|
|
|
const ExecutionContext *exe_ctx, uint32_t idx, int64_t fail_value) const {
|
|
|
|
const Property *property = GetPropertyAtIndex(exe_ctx, false, idx);
|
|
|
|
if (property) {
|
|
|
|
OptionValue *value = property->GetValue().get();
|
|
|
|
if (value)
|
|
|
|
return value->GetEnumerationValue(fail_value);
|
|
|
|
}
|
|
|
|
return fail_value;
|
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2012-08-23 01:17:09 +08:00
|
|
|
bool OptionValueProperties::SetPropertyAtIndexAsEnumeration(
|
|
|
|
const ExecutionContext *exe_ctx, uint32_t idx, int64_t new_value) {
|
|
|
|
const Property *property = GetPropertyAtIndex(exe_ctx, true, idx);
|
|
|
|
if (property) {
|
|
|
|
OptionValue *value = property->GetValue().get();
|
|
|
|
if (value)
|
|
|
|
return value->SetEnumerationValue(new_value);
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2015-02-05 06:00:53 +08:00
|
|
|
const FormatEntity::Entry *
|
|
|
|
OptionValueProperties::GetPropertyAtIndexAsFormatEntity(
|
|
|
|
const ExecutionContext *exe_ctx, uint32_t idx) {
|
|
|
|
const Property *property = GetPropertyAtIndex(exe_ctx, true, idx);
|
|
|
|
if (property) {
|
|
|
|
OptionValue *value = property->GetValue().get();
|
|
|
|
if (value)
|
|
|
|
return value->GetFormatEntity();
|
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
}
|
2012-08-23 01:17:09 +08:00
|
|
|
|
2012-08-23 02:39:03 +08:00
|
|
|
OptionValueFileSpec *
|
|
|
|
OptionValueProperties::GetPropertyAtIndexAsOptionValueFileSpec(
|
|
|
|
const ExecutionContext *exe_ctx, bool will_modify, uint32_t idx) const {
|
|
|
|
const Property *property = GetPropertyAtIndex(exe_ctx, false, idx);
|
|
|
|
if (property) {
|
|
|
|
OptionValue *value = property->GetValue().get();
|
|
|
|
if (value)
|
|
|
|
return value->GetAsFileSpec();
|
|
|
|
}
|
2014-04-20 08:31:37 +08:00
|
|
|
return nullptr;
|
2012-08-23 02:39:03 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2012-08-23 01:17:09 +08:00
|
|
|
FileSpec OptionValueProperties::GetPropertyAtIndexAsFileSpec(
|
|
|
|
const ExecutionContext *exe_ctx, uint32_t idx) const {
|
|
|
|
const Property *property = GetPropertyAtIndex(exe_ctx, false, idx);
|
|
|
|
if (property) {
|
|
|
|
OptionValue *value = property->GetValue().get();
|
|
|
|
if (value)
|
|
|
|
return value->GetFileSpecValue();
|
|
|
|
}
|
|
|
|
return FileSpec();
|
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2012-08-23 01:17:09 +08:00
|
|
|
bool OptionValueProperties::SetPropertyAtIndexAsFileSpec(
|
|
|
|
const ExecutionContext *exe_ctx, uint32_t idx,
|
|
|
|
const FileSpec &new_file_spec) {
|
|
|
|
const Property *property = GetPropertyAtIndex(exe_ctx, true, idx);
|
|
|
|
if (property) {
|
|
|
|
OptionValue *value = property->GetValue().get();
|
|
|
|
if (value)
|
|
|
|
return value->SetFileSpecValue(new_file_spec);
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
const RegularExpression *
|
|
|
|
OptionValueProperties::GetPropertyAtIndexAsOptionValueRegex(
|
|
|
|
const ExecutionContext *exe_ctx, uint32_t idx) const {
|
|
|
|
const Property *property = GetPropertyAtIndex(exe_ctx, false, idx);
|
|
|
|
if (property) {
|
|
|
|
OptionValue *value = property->GetValue().get();
|
|
|
|
if (value)
|
|
|
|
return value->GetRegexValue();
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2014-04-20 08:31:37 +08:00
|
|
|
return nullptr;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
2012-08-23 01:17:09 +08:00
|
|
|
OptionValueSInt64 *OptionValueProperties::GetPropertyAtIndexAsOptionValueSInt64(
|
|
|
|
const ExecutionContext *exe_ctx, uint32_t idx) const {
|
|
|
|
const Property *property = GetPropertyAtIndex(exe_ctx, false, idx);
|
|
|
|
if (property) {
|
|
|
|
OptionValue *value = property->GetValue().get();
|
|
|
|
if (value)
|
|
|
|
return value->GetAsSInt64();
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2014-04-20 08:31:37 +08:00
|
|
|
return nullptr;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
2012-08-23 01:17:09 +08:00
|
|
|
int64_t OptionValueProperties::GetPropertyAtIndexAsSInt64(
|
|
|
|
const ExecutionContext *exe_ctx, uint32_t idx, int64_t fail_value) const {
|
|
|
|
const Property *property = GetPropertyAtIndex(exe_ctx, false, idx);
|
|
|
|
if (property) {
|
|
|
|
OptionValue *value = property->GetValue().get();
|
|
|
|
if (value)
|
|
|
|
return value->GetSInt64Value(fail_value);
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2012-08-23 01:17:09 +08:00
|
|
|
return fail_value;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
2012-08-23 01:17:09 +08:00
|
|
|
bool OptionValueProperties::SetPropertyAtIndexAsSInt64(
|
|
|
|
const ExecutionContext *exe_ctx, uint32_t idx, int64_t new_value) {
|
|
|
|
const Property *property = GetPropertyAtIndex(exe_ctx, true, idx);
|
|
|
|
if (property) {
|
|
|
|
OptionValue *value = property->GetValue().get();
|
|
|
|
if (value)
|
|
|
|
return value->SetSInt64Value(new_value);
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2012-08-23 01:17:09 +08:00
|
|
|
return false;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
2016-11-18 02:08:12 +08:00
|
|
|
llvm::StringRef OptionValueProperties::GetPropertyAtIndexAsString(
|
2012-08-23 01:17:09 +08:00
|
|
|
const ExecutionContext *exe_ctx, uint32_t idx,
|
2016-11-18 02:08:12 +08:00
|
|
|
llvm::StringRef fail_value) const {
|
2012-08-23 01:17:09 +08:00
|
|
|
const Property *property = GetPropertyAtIndex(exe_ctx, false, idx);
|
|
|
|
if (property) {
|
|
|
|
OptionValue *value = property->GetValue().get();
|
|
|
|
if (value)
|
|
|
|
return value->GetStringValue(fail_value);
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2012-08-23 01:17:09 +08:00
|
|
|
return fail_value;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
2012-09-01 08:38:36 +08:00
|
|
|
bool OptionValueProperties::SetPropertyAtIndexAsString(
|
2016-09-24 02:06:53 +08:00
|
|
|
const ExecutionContext *exe_ctx, uint32_t idx, llvm::StringRef new_value) {
|
2012-08-23 01:17:09 +08:00
|
|
|
const Property *property = GetPropertyAtIndex(exe_ctx, true, idx);
|
|
|
|
if (property) {
|
|
|
|
OptionValue *value = property->GetValue().get();
|
|
|
|
if (value)
|
|
|
|
return value->SetStringValue(new_value);
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2012-08-23 01:17:09 +08:00
|
|
|
return false;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
2012-09-01 08:38:36 +08:00
|
|
|
OptionValueString *OptionValueProperties::GetPropertyAtIndexAsOptionValueString(
|
|
|
|
const ExecutionContext *exe_ctx, bool will_modify, uint32_t idx) const {
|
|
|
|
OptionValueSP value_sp(GetPropertyValueAtIndex(exe_ctx, will_modify, idx));
|
|
|
|
if (value_sp)
|
|
|
|
return value_sp->GetAsString();
|
2014-04-20 08:31:37 +08:00
|
|
|
return nullptr;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
2012-08-23 01:17:09 +08:00
|
|
|
uint64_t OptionValueProperties::GetPropertyAtIndexAsUInt64(
|
|
|
|
const ExecutionContext *exe_ctx, uint32_t idx, uint64_t fail_value) const {
|
|
|
|
const Property *property = GetPropertyAtIndex(exe_ctx, false, idx);
|
|
|
|
if (property) {
|
|
|
|
OptionValue *value = property->GetValue().get();
|
|
|
|
if (value)
|
|
|
|
return value->GetUInt64Value(fail_value);
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2012-08-23 01:17:09 +08:00
|
|
|
return fail_value;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
2012-09-01 08:38:36 +08:00
|
|
|
bool OptionValueProperties::SetPropertyAtIndexAsUInt64(
|
2012-08-23 01:17:09 +08:00
|
|
|
const ExecutionContext *exe_ctx, uint32_t idx, uint64_t new_value) {
|
|
|
|
const Property *property = GetPropertyAtIndex(exe_ctx, true, idx);
|
|
|
|
if (property) {
|
|
|
|
OptionValue *value = property->GetValue().get();
|
|
|
|
if (value)
|
|
|
|
return value->SetUInt64Value(new_value);
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2012-08-23 01:17:09 +08:00
|
|
|
return false;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
2020-07-22 02:32:55 +08:00
|
|
|
void OptionValueProperties::Clear() {
|
2012-08-23 01:17:09 +08:00
|
|
|
const size_t num_properties = m_properties.size();
|
|
|
|
for (size_t i = 0; i < num_properties; ++i)
|
|
|
|
m_properties[i].GetValue()->Clear();
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
2017-05-12 12:51:55 +08:00
|
|
|
Status OptionValueProperties::SetValueFromString(llvm::StringRef value,
|
|
|
|
VarSetOperationType op) {
|
|
|
|
Status error;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2012-08-23 01:17:09 +08:00
|
|
|
// Args args(value_cstr);
|
|
|
|
// const size_t argc = args.GetArgumentCount();
|
|
|
|
switch (op) {
|
|
|
|
case eVarSetOperationClear:
|
2016-09-07 04:57:50 +08:00
|
|
|
Clear();
|
|
|
|
break;
|
|
|
|
|
2012-08-23 01:17:09 +08:00
|
|
|
case eVarSetOperationReplace:
|
|
|
|
case eVarSetOperationAssign:
|
|
|
|
case eVarSetOperationRemove:
|
|
|
|
case eVarSetOperationInsertBefore:
|
|
|
|
case eVarSetOperationInsertAfter:
|
|
|
|
case eVarSetOperationAppend:
|
|
|
|
case eVarSetOperationInvalid:
|
2015-02-20 19:14:59 +08:00
|
|
|
error = OptionValue::SetValueFromString(value, op);
|
2016-09-07 04:57:50 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2012-08-23 01:17:09 +08:00
|
|
|
return error;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
2012-08-23 01:17:09 +08:00
|
|
|
void OptionValueProperties::DumpValue(const ExecutionContext *exe_ctx,
|
|
|
|
Stream &strm, uint32_t dump_mask) {
|
|
|
|
const size_t num_properties = m_properties.size();
|
|
|
|
for (size_t i = 0; i < num_properties; ++i) {
|
|
|
|
const Property *property = GetPropertyAtIndex(exe_ctx, false, i);
|
|
|
|
if (property) {
|
|
|
|
OptionValue *option_value = property->GetValue().get();
|
|
|
|
assert(option_value);
|
|
|
|
const bool transparent_value = option_value->ValueIsTransparent();
|
|
|
|
property->Dump(exe_ctx, strm, dump_mask);
|
|
|
|
if (!transparent_value)
|
|
|
|
strm.EOL();
|
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2012-08-23 01:17:09 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2017-05-12 12:51:55 +08:00
|
|
|
Status OptionValueProperties::DumpPropertyValue(const ExecutionContext *exe_ctx,
|
|
|
|
Stream &strm,
|
|
|
|
llvm::StringRef property_path,
|
|
|
|
uint32_t dump_mask) {
|
|
|
|
Status error;
|
2012-08-23 01:17:09 +08:00
|
|
|
const bool will_modify = false;
|
|
|
|
lldb::OptionValueSP value_sp(
|
|
|
|
GetSubValue(exe_ctx, property_path, will_modify, error));
|
|
|
|
if (value_sp) {
|
|
|
|
if (!value_sp->ValueIsTransparent()) {
|
|
|
|
if (dump_mask & eDumpOptionName)
|
|
|
|
strm.PutCString(property_path);
|
|
|
|
if (dump_mask & ~eDumpOptionName)
|
|
|
|
strm.PutChar(' ');
|
|
|
|
}
|
2014-04-20 08:31:37 +08:00
|
|
|
value_sp->DumpValue(exe_ctx, strm, dump_mask);
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2014-04-20 08:31:37 +08:00
|
|
|
return error;
|
2012-08-23 01:17:09 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2021-02-20 05:49:42 +08:00
|
|
|
OptionValuePropertiesSP
|
|
|
|
OptionValueProperties::CreateLocalCopy(const Properties &global_properties) {
|
|
|
|
auto global_props_sp = global_properties.GetValueProperties();
|
|
|
|
lldbassert(global_props_sp);
|
|
|
|
|
|
|
|
auto copy_sp = global_props_sp->DeepCopy(global_props_sp->GetParent());
|
|
|
|
return std::static_pointer_cast<OptionValueProperties>(copy_sp);
|
|
|
|
}
|
|
|
|
|
|
|
|
OptionValueSP
|
|
|
|
OptionValueProperties::DeepCopy(const OptionValueSP &new_parent) const {
|
|
|
|
auto copy_sp = OptionValue::DeepCopy(new_parent);
|
|
|
|
// copy_sp->GetAsProperties cannot be used here as it doesn't work for derived
|
|
|
|
// types that override GetType returning a different value.
|
|
|
|
auto *props_value_ptr = static_cast<OptionValueProperties *>(copy_sp.get());
|
|
|
|
lldbassert(props_value_ptr);
|
|
|
|
|
|
|
|
for (auto &property : props_value_ptr->m_properties) {
|
|
|
|
// Duplicate any values that are not global when constructing properties
|
|
|
|
// from a global copy.
|
|
|
|
if (!property.IsGlobal()) {
|
|
|
|
auto value_sp = property.GetValue()->DeepCopy(copy_sp);
|
|
|
|
property.SetOptionValue(value_sp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return copy_sp;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
2012-08-23 01:17:09 +08:00
|
|
|
const Property *OptionValueProperties::GetPropertyAtPath(
|
2016-11-18 02:08:12 +08:00
|
|
|
const ExecutionContext *exe_ctx, bool will_modify, llvm::StringRef name) const {
|
2012-08-23 01:17:09 +08:00
|
|
|
const Property *property = nullptr;
|
2016-11-18 02:08:12 +08:00
|
|
|
if (name.empty())
|
|
|
|
return nullptr;
|
|
|
|
llvm::StringRef sub_name;
|
|
|
|
ConstString key;
|
|
|
|
size_t key_len = name.find_first_of(".[{");
|
|
|
|
|
|
|
|
if (key_len != llvm::StringRef::npos) {
|
|
|
|
key.SetString(name.take_front(key_len));
|
|
|
|
sub_name = name.drop_front(key_len);
|
|
|
|
} else
|
|
|
|
key.SetString(name);
|
|
|
|
|
|
|
|
property = GetProperty(exe_ctx, will_modify, key);
|
|
|
|
if (sub_name.empty() || !property)
|
|
|
|
return property;
|
|
|
|
|
|
|
|
if (sub_name[0] == '.') {
|
|
|
|
OptionValueProperties *sub_properties =
|
|
|
|
property->GetValue()->GetAsProperties();
|
|
|
|
if (sub_properties)
|
|
|
|
return sub_properties->GetPropertyAtPath(exe_ctx, will_modify,
|
|
|
|
sub_name.drop_front());
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2016-11-18 02:08:12 +08:00
|
|
|
return nullptr;
|
2012-08-23 01:17:09 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void OptionValueProperties::DumpAllDescriptions(CommandInterpreter &interpreter,
|
|
|
|
Stream &strm) const {
|
|
|
|
size_t max_name_len = 0;
|
|
|
|
const size_t num_properties = m_properties.size();
|
|
|
|
for (size_t i = 0; i < num_properties; ++i) {
|
|
|
|
const Property *property = ProtectedGetPropertyAtIndex(i);
|
|
|
|
if (property)
|
2016-11-16 07:36:43 +08:00
|
|
|
max_name_len = std::max<size_t>(property->GetName().size(), max_name_len);
|
2012-08-23 01:17:09 +08:00
|
|
|
}
|
|
|
|
for (size_t i = 0; i < num_properties; ++i) {
|
|
|
|
const Property *property = ProtectedGetPropertyAtIndex(i);
|
|
|
|
if (property)
|
|
|
|
property->DumpDescription(interpreter, strm, max_name_len, false);
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2012-08-23 01:17:09 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2012-08-23 01:17:09 +08:00
|
|
|
void OptionValueProperties::Apropos(
|
2016-11-17 05:45:04 +08:00
|
|
|
llvm::StringRef keyword,
|
2012-08-23 01:17:09 +08:00
|
|
|
std::vector<const Property *> &matching_properties) const {
|
|
|
|
const size_t num_properties = m_properties.size();
|
|
|
|
StreamString strm;
|
|
|
|
for (size_t i = 0; i < num_properties; ++i) {
|
2015-02-20 19:14:59 +08:00
|
|
|
const Property *property = ProtectedGetPropertyAtIndex(i);
|
2012-08-23 01:17:09 +08:00
|
|
|
if (property) {
|
|
|
|
const OptionValueProperties *properties =
|
|
|
|
property->GetValue()->GetAsProperties();
|
|
|
|
if (properties) {
|
|
|
|
properties->Apropos(keyword, matching_properties);
|
|
|
|
} else {
|
|
|
|
bool match = false;
|
2016-11-16 07:36:43 +08:00
|
|
|
llvm::StringRef name = property->GetName();
|
|
|
|
if (name.contains_lower(keyword))
|
2012-08-23 01:17:09 +08:00
|
|
|
match = true;
|
|
|
|
else {
|
2016-11-16 07:36:43 +08:00
|
|
|
llvm::StringRef desc = property->GetDescription();
|
|
|
|
if (desc.contains_lower(keyword))
|
2012-08-23 01:17:09 +08:00
|
|
|
match = true;
|
|
|
|
}
|
|
|
|
if (match) {
|
|
|
|
matching_properties.push_back(property);
|
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2012-08-23 01:17:09 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2012-08-23 01:17:09 +08:00
|
|
|
}
|
|
|
|
|
2012-10-20 02:02:49 +08:00
|
|
|
lldb::OptionValuePropertiesSP
|
|
|
|
OptionValueProperties::GetSubProperty(const ExecutionContext *exe_ctx,
|
2019-03-07 05:22:25 +08:00
|
|
|
ConstString name) {
|
2012-10-20 02:02:49 +08:00
|
|
|
lldb::OptionValueSP option_value_sp(GetValueForKey(exe_ctx, name, false));
|
|
|
|
if (option_value_sp) {
|
|
|
|
OptionValueProperties *ov_properties = option_value_sp->GetAsProperties();
|
|
|
|
if (ov_properties)
|
|
|
|
return ov_properties->shared_from_this();
|
|
|
|
}
|
|
|
|
return lldb::OptionValuePropertiesSP();
|
|
|
|
}
|