mirror of
https://github.com/intel/llvm.git
synced 2026-01-26 12:26:52 +08:00
4c05410f8f
Added the ability for OptionValueString objects to take flags. The only flag is currently for parsing escape sequences. Not the prompt string can have escape characters translate which will allow colors in the prompt. Added functions to Args that will parse the escape sequences in a string, and also re-encode the escape sequences for display. This was looted from other parts of LLDB (the Debugger::FormatString() function). llvm-svn: 163043
274 lines
11 KiB
C++
274 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"
|
|
|
|
// 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);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|