ceff6644bb
This patch removes the comments grouping header includes. They were added after running IWYU over the LLDB codebase. However they add little value, are often outdates and burdensome to maintain. llvm-svn: 346626
294 lines
11 KiB
C++
294 lines
11 KiB
C++
//===-- Property.cpp --------------------------------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "lldb/Interpreter/Property.h"
|
|
|
|
#include "lldb/Core/UserSettingsController.h"
|
|
#include "lldb/Host/StringConvert.h"
|
|
#include "lldb/Interpreter/CommandInterpreter.h"
|
|
#include "lldb/Interpreter/OptionArgParser.h"
|
|
#include "lldb/Interpreter/OptionValues.h"
|
|
#include "lldb/Target/Language.h"
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
Property::Property(const PropertyDefinition &definition)
|
|
: m_name(definition.name), m_description(definition.description),
|
|
m_value_sp(), m_is_global(definition.global) {
|
|
switch (definition.type) {
|
|
case OptionValue::eTypeInvalid:
|
|
case OptionValue::eTypeProperties:
|
|
break;
|
|
case OptionValue::eTypeArch:
|
|
// "definition.default_uint_value" is not used
|
|
// "definition.default_cstr_value" as a string value that represents the
|
|
// default string value for the architecture/triple
|
|
m_value_sp.reset(new OptionValueArch(definition.default_cstr_value));
|
|
break;
|
|
|
|
case OptionValue::eTypeArgs:
|
|
// "definition.default_uint_value" is always a OptionValue::Type
|
|
m_value_sp.reset(new OptionValueArgs());
|
|
break;
|
|
|
|
case OptionValue::eTypeArray:
|
|
// "definition.default_uint_value" is always a OptionValue::Type
|
|
m_value_sp.reset(new OptionValueArray(OptionValue::ConvertTypeToMask(
|
|
(OptionValue::Type)definition.default_uint_value)));
|
|
break;
|
|
|
|
case OptionValue::eTypeBoolean:
|
|
// "definition.default_uint_value" is the default boolean value if
|
|
// "definition.default_cstr_value" is NULL, otherwise interpret
|
|
// "definition.default_cstr_value" as a string value that represents the
|
|
// default value.
|
|
if (definition.default_cstr_value)
|
|
m_value_sp.reset(new OptionValueBoolean(OptionArgParser::ToBoolean(
|
|
llvm::StringRef(definition.default_cstr_value), false, nullptr)));
|
|
else
|
|
m_value_sp.reset(
|
|
new OptionValueBoolean(definition.default_uint_value != 0));
|
|
break;
|
|
|
|
case OptionValue::eTypeChar: {
|
|
llvm::StringRef s(definition.default_cstr_value ? definition.default_cstr_value : "");
|
|
m_value_sp = std::make_shared<OptionValueChar>(
|
|
OptionArgParser::ToChar(s, '\0', nullptr));
|
|
break;
|
|
}
|
|
case OptionValue::eTypeDictionary:
|
|
// "definition.default_uint_value" is always a OptionValue::Type
|
|
m_value_sp.reset(new OptionValueDictionary(OptionValue::ConvertTypeToMask(
|
|
(OptionValue::Type)definition.default_uint_value)));
|
|
break;
|
|
|
|
case OptionValue::eTypeEnum:
|
|
// "definition.default_uint_value" is the default enumeration value if
|
|
// "definition.default_cstr_value" is NULL, otherwise interpret
|
|
// "definition.default_cstr_value" as a string value that represents the
|
|
// default value.
|
|
{
|
|
OptionValueEnumeration *enum_value = new OptionValueEnumeration(
|
|
definition.enum_values, definition.default_uint_value);
|
|
m_value_sp.reset(enum_value);
|
|
if (definition.default_cstr_value) {
|
|
if (enum_value
|
|
->SetValueFromString(
|
|
llvm::StringRef(definition.default_cstr_value))
|
|
.Success()) {
|
|
enum_value->SetDefaultValue(enum_value->GetCurrentValue());
|
|
// Call Clear() since we don't want the value to appear as having
|
|
// been set since we called SetValueFromString() above. Clear will
|
|
// set the current value to the default and clear the boolean that
|
|
// says that the value has been set.
|
|
enum_value->Clear();
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case OptionValue::eTypeFileSpec: {
|
|
// "definition.default_uint_value" represents if the
|
|
// "definition.default_cstr_value" should be resolved or not
|
|
const bool resolve = definition.default_uint_value != 0;
|
|
FileSpec file_spec = FileSpec(definition.default_cstr_value);
|
|
if (resolve)
|
|
FileSystem::Instance().Resolve(file_spec);
|
|
m_value_sp.reset(new OptionValueFileSpec(file_spec, resolve));
|
|
break;
|
|
}
|
|
|
|
case OptionValue::eTypeFileSpecList:
|
|
// "definition.default_uint_value" is not used for a
|
|
// OptionValue::eTypeFileSpecList
|
|
m_value_sp.reset(new OptionValueFileSpecList());
|
|
break;
|
|
|
|
case OptionValue::eTypeFormat:
|
|
// "definition.default_uint_value" is the default format enumeration value
|
|
// if "definition.default_cstr_value" is NULL, otherwise interpret
|
|
// "definition.default_cstr_value" as a string value that represents the
|
|
// default value.
|
|
{
|
|
Format new_format = eFormatInvalid;
|
|
if (definition.default_cstr_value)
|
|
OptionArgParser::ToFormat(definition.default_cstr_value, new_format,
|
|
nullptr);
|
|
else
|
|
new_format = (Format)definition.default_uint_value;
|
|
m_value_sp.reset(new OptionValueFormat(new_format));
|
|
}
|
|
break;
|
|
|
|
case OptionValue::eTypeLanguage:
|
|
// "definition.default_uint_value" is the default language enumeration
|
|
// value if "definition.default_cstr_value" is NULL, otherwise interpret
|
|
// "definition.default_cstr_value" as a string value that represents the
|
|
// default value.
|
|
{
|
|
LanguageType new_lang = eLanguageTypeUnknown;
|
|
if (definition.default_cstr_value)
|
|
Language::GetLanguageTypeFromString(
|
|
llvm::StringRef(definition.default_cstr_value));
|
|
else
|
|
new_lang = (LanguageType)definition.default_uint_value;
|
|
m_value_sp.reset(new OptionValueLanguage(new_lang));
|
|
}
|
|
break;
|
|
|
|
case OptionValue::eTypeFormatEntity:
|
|
// "definition.default_cstr_value" as a string value that represents the
|
|
// default
|
|
m_value_sp.reset(
|
|
new OptionValueFormatEntity(definition.default_cstr_value));
|
|
break;
|
|
|
|
case OptionValue::eTypePathMap:
|
|
// "definition.default_uint_value" tells us if notifications should occur
|
|
// for path mappings
|
|
m_value_sp.reset(
|
|
new OptionValuePathMappings(definition.default_uint_value != 0));
|
|
break;
|
|
|
|
case OptionValue::eTypeRegex:
|
|
// "definition.default_uint_value" is used to the regular expression flags
|
|
// "definition.default_cstr_value" the default regular expression value
|
|
// value.
|
|
m_value_sp.reset(new OptionValueRegex(definition.default_cstr_value));
|
|
break;
|
|
|
|
case OptionValue::eTypeSInt64:
|
|
// "definition.default_uint_value" is the default integer value if
|
|
// "definition.default_cstr_value" is NULL, otherwise interpret
|
|
// "definition.default_cstr_value" as a string value that represents the
|
|
// default value.
|
|
m_value_sp.reset(new OptionValueSInt64(
|
|
definition.default_cstr_value
|
|
? StringConvert::ToSInt64(definition.default_cstr_value)
|
|
: definition.default_uint_value));
|
|
break;
|
|
|
|
case OptionValue::eTypeUInt64:
|
|
// "definition.default_uint_value" is the default unsigned integer value if
|
|
// "definition.default_cstr_value" is NULL, otherwise interpret
|
|
// "definition.default_cstr_value" as a string value that represents the
|
|
// default value.
|
|
m_value_sp.reset(new OptionValueUInt64(
|
|
definition.default_cstr_value
|
|
? StringConvert::ToUInt64(definition.default_cstr_value)
|
|
: definition.default_uint_value));
|
|
break;
|
|
|
|
case OptionValue::eTypeUUID:
|
|
// "definition.default_uint_value" is not used for a OptionValue::eTypeUUID
|
|
// "definition.default_cstr_value" can contain a default UUID value
|
|
{
|
|
UUID uuid;
|
|
if (definition.default_cstr_value)
|
|
uuid.SetFromStringRef(definition.default_cstr_value);
|
|
m_value_sp.reset(new OptionValueUUID(uuid));
|
|
}
|
|
break;
|
|
|
|
case OptionValue::eTypeString:
|
|
// "definition.default_uint_value" can contain the string option flags
|
|
// OR'ed together "definition.default_cstr_value" can contain a default
|
|
// string value
|
|
{
|
|
OptionValueString *string_value =
|
|
new OptionValueString(definition.default_cstr_value);
|
|
if (definition.default_uint_value != 0)
|
|
string_value->GetOptions().Reset(definition.default_uint_value);
|
|
m_value_sp.reset(string_value);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
Property::Property(const ConstString &name, const ConstString &desc,
|
|
bool is_global, const lldb::OptionValueSP &value_sp)
|
|
: m_name(name), m_description(desc), m_value_sp(value_sp),
|
|
m_is_global(is_global) {}
|
|
|
|
bool Property::DumpQualifiedName(Stream &strm) const {
|
|
if (m_name) {
|
|
if (m_value_sp->DumpQualifiedName(strm))
|
|
strm.PutChar('.');
|
|
strm << m_name;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void Property::Dump(const ExecutionContext *exe_ctx, Stream &strm,
|
|
uint32_t dump_mask) const {
|
|
if (m_value_sp) {
|
|
const bool dump_desc = dump_mask & OptionValue::eDumpOptionDescription;
|
|
const bool dump_cmd = dump_mask & OptionValue::eDumpOptionCommand;
|
|
const bool transparent = m_value_sp->ValueIsTransparent();
|
|
if (dump_cmd && !transparent)
|
|
strm << "settings set -f ";
|
|
if (dump_desc || !transparent) {
|
|
if ((dump_mask & OptionValue::eDumpOptionName) && m_name) {
|
|
DumpQualifiedName(strm);
|
|
if (dump_mask & ~OptionValue::eDumpOptionName)
|
|
strm.PutChar(' ');
|
|
}
|
|
}
|
|
if (dump_desc) {
|
|
llvm::StringRef desc = GetDescription();
|
|
if (!desc.empty())
|
|
strm << "-- " << desc;
|
|
|
|
if (transparent && (dump_mask == (OptionValue::eDumpOptionName |
|
|
OptionValue::eDumpOptionDescription)))
|
|
strm.EOL();
|
|
}
|
|
m_value_sp->DumpValue(exe_ctx, strm, dump_mask);
|
|
}
|
|
}
|
|
|
|
void Property::DumpDescription(CommandInterpreter &interpreter, Stream &strm,
|
|
uint32_t output_width,
|
|
bool display_qualified_name) const {
|
|
if (!m_value_sp)
|
|
return;
|
|
llvm::StringRef desc = GetDescription();
|
|
|
|
if (desc.empty())
|
|
return;
|
|
|
|
StreamString qualified_name;
|
|
const OptionValueProperties *sub_properties = m_value_sp->GetAsProperties();
|
|
if (sub_properties) {
|
|
strm.EOL();
|
|
|
|
if (m_value_sp->DumpQualifiedName(qualified_name))
|
|
strm.Printf("'%s' variables:\n\n", qualified_name.GetData());
|
|
sub_properties->DumpAllDescriptions(interpreter, strm);
|
|
} else {
|
|
if (display_qualified_name) {
|
|
StreamString qualified_name;
|
|
DumpQualifiedName(qualified_name);
|
|
interpreter.OutputFormattedHelpText(strm, qualified_name.GetString(),
|
|
"--", desc, output_width);
|
|
} else {
|
|
interpreter.OutputFormattedHelpText(strm, m_name.GetStringRef(), "--",
|
|
desc, output_width);
|
|
}
|
|
}
|
|
}
|
|
|
|
void Property::SetValueChangedCallback(OptionValueChangedCallback callback,
|
|
void *baton) {
|
|
if (m_value_sp)
|
|
m_value_sp->SetValueChangedCallback(callback, baton);
|
|
}
|