forked from OSchip/llvm-project
276 lines
11 KiB
C++
276 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/lldb-python.h"
|
|
|
|
#include "lldb/Interpreter/Property.h"
|
|
|
|
// C Includes
|
|
// C++ Includes
|
|
// Other libraries and framework includes
|
|
// Project includes
|
|
#include "lldb/Core/UserSettingsController.h"
|
|
#include "lldb/Interpreter/Args.h"
|
|
#include "lldb/Interpreter/CommandInterpreter.h"
|
|
#include "lldb/Interpreter/OptionValues.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(Args::StringToBoolean (definition.default_cstr_value, false, NULL)));
|
|
else
|
|
m_value_sp.reset (new OptionValueBoolean(definition.default_uint_value != 0));
|
|
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->SetValueFromCString(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 SetValueFromCString() 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
|
|
m_value_sp.reset (new OptionValueFileSpec(FileSpec(definition.default_cstr_value, definition.default_uint_value != 0)));
|
|
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)
|
|
Args::StringToFormat (definition.default_cstr_value, new_format, NULL);
|
|
else
|
|
new_format = (Format)definition.default_uint_value;
|
|
m_value_sp.reset (new OptionValueFormat(new_format));
|
|
}
|
|
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, definition.default_uint_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 ? Args::StringToSInt64 (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 ? Args::StringToUInt64 (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.SetFromCString (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 transparent = m_value_sp->ValueIsTransparent ();
|
|
if (dump_desc || !transparent)
|
|
{
|
|
if ((dump_mask & OptionValue::eDumpOptionName) && m_name)
|
|
{
|
|
DumpQualifiedName(strm);
|
|
if (dump_mask & ~OptionValue::eDumpOptionName)
|
|
strm.PutChar(' ');
|
|
}
|
|
}
|
|
if (dump_desc)
|
|
{
|
|
const char *desc = GetDescription();
|
|
if (desc)
|
|
strm.Printf ("-- %s", 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)
|
|
{
|
|
const char *desc = GetDescription();
|
|
|
|
if (desc)
|
|
{
|
|
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.GetString().c_str());
|
|
sub_properties->DumpAllDescriptions(interpreter, strm);
|
|
}
|
|
else
|
|
{
|
|
if (desc)
|
|
{
|
|
if (display_qualified_name)
|
|
{
|
|
StreamString qualified_name;
|
|
DumpQualifiedName(qualified_name);
|
|
interpreter.OutputFormattedHelpText (strm,
|
|
qualified_name.GetString().c_str(),
|
|
"--",
|
|
desc,
|
|
output_width);
|
|
}
|
|
else
|
|
{
|
|
interpreter.OutputFormattedHelpText (strm,
|
|
m_name.GetCString(),
|
|
"--",
|
|
desc,
|
|
output_width);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|