forked from OSchip/llvm-project
634 lines
16 KiB
C++
634 lines
16 KiB
C++
//===-- OptionValue.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/OptionValue.h"
|
|
|
|
// C Includes
|
|
// C++ Includes
|
|
// Other libraries and framework includes
|
|
// Project includes
|
|
#include "lldb/Core/StringList.h"
|
|
#include "lldb/Interpreter/OptionValues.h"
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
|
|
//-------------------------------------------------------------------------
|
|
// Get this value as a uint64_t value if it is encoded as a boolean,
|
|
// uint64_t or int64_t. Other types will cause "fail_value" to be
|
|
// returned
|
|
//-------------------------------------------------------------------------
|
|
uint64_t
|
|
OptionValue::GetUInt64Value (uint64_t fail_value, bool *success_ptr)
|
|
{
|
|
if (success_ptr)
|
|
*success_ptr = true;
|
|
switch (GetType())
|
|
{
|
|
case OptionValue::eTypeBoolean: return static_cast<OptionValueBoolean *>(this)->GetCurrentValue();
|
|
case OptionValue::eTypeSInt64: return static_cast<OptionValueSInt64 *>(this)->GetCurrentValue();
|
|
case OptionValue::eTypeUInt64: return static_cast<OptionValueUInt64 *>(this)->GetCurrentValue();
|
|
default:
|
|
break;
|
|
}
|
|
if (success_ptr)
|
|
*success_ptr = false;
|
|
return fail_value;
|
|
}
|
|
|
|
Error
|
|
OptionValue::SetSubValue (const ExecutionContext *exe_ctx,
|
|
VarSetOperationType op,
|
|
const char *name,
|
|
const char *value)
|
|
{
|
|
Error error;
|
|
error.SetErrorStringWithFormat("SetSubValue is not supported");
|
|
return error;
|
|
}
|
|
|
|
|
|
OptionValueBoolean *
|
|
OptionValue::GetAsBoolean ()
|
|
{
|
|
if (GetType () == OptionValue::eTypeBoolean)
|
|
return static_cast<OptionValueBoolean *>(this);
|
|
return NULL;
|
|
}
|
|
|
|
const OptionValueBoolean *
|
|
OptionValue::GetAsBoolean () const
|
|
{
|
|
if (GetType () == OptionValue::eTypeBoolean)
|
|
return static_cast<const OptionValueBoolean *>(this);
|
|
return NULL;
|
|
}
|
|
|
|
|
|
OptionValueFileSpec *
|
|
OptionValue::GetAsFileSpec ()
|
|
{
|
|
if (GetType () == OptionValue::eTypeFileSpec)
|
|
return static_cast<OptionValueFileSpec *>(this);
|
|
return NULL;
|
|
|
|
}
|
|
|
|
const OptionValueFileSpec *
|
|
OptionValue::GetAsFileSpec () const
|
|
{
|
|
if (GetType () == OptionValue::eTypeFileSpec)
|
|
return static_cast<const OptionValueFileSpec *>(this);
|
|
return NULL;
|
|
|
|
}
|
|
|
|
OptionValueFileSpecList *
|
|
OptionValue::GetAsFileSpecList ()
|
|
{
|
|
if (GetType () == OptionValue::eTypeFileSpecList)
|
|
return static_cast<OptionValueFileSpecList *>(this);
|
|
return NULL;
|
|
|
|
}
|
|
|
|
const OptionValueFileSpecList *
|
|
OptionValue::GetAsFileSpecList () const
|
|
{
|
|
if (GetType () == OptionValue::eTypeFileSpecList)
|
|
return static_cast<const OptionValueFileSpecList *>(this);
|
|
return NULL;
|
|
|
|
}
|
|
|
|
OptionValueArch *
|
|
OptionValue::GetAsArch ()
|
|
{
|
|
if (GetType () == OptionValue::eTypeArch)
|
|
return static_cast<OptionValueArch *>(this);
|
|
return NULL;
|
|
}
|
|
|
|
|
|
const OptionValueArch *
|
|
OptionValue::GetAsArch () const
|
|
{
|
|
if (GetType () == OptionValue::eTypeArch)
|
|
return static_cast<const OptionValueArch *>(this);
|
|
return NULL;
|
|
}
|
|
|
|
OptionValueArray *
|
|
OptionValue::GetAsArray ()
|
|
{
|
|
if (GetType () == OptionValue::eTypeArray)
|
|
return static_cast<OptionValueArray *>(this);
|
|
return NULL;
|
|
}
|
|
|
|
|
|
const OptionValueArray *
|
|
OptionValue::GetAsArray () const
|
|
{
|
|
if (GetType () == OptionValue::eTypeArray)
|
|
return static_cast<const OptionValueArray *>(this);
|
|
return NULL;
|
|
}
|
|
|
|
OptionValueArgs *
|
|
OptionValue::GetAsArgs ()
|
|
{
|
|
if (GetType () == OptionValue::eTypeArgs)
|
|
return static_cast<OptionValueArgs *>(this);
|
|
return NULL;
|
|
}
|
|
|
|
|
|
const OptionValueArgs *
|
|
OptionValue::GetAsArgs () const
|
|
{
|
|
if (GetType () == OptionValue::eTypeArgs)
|
|
return static_cast<const OptionValueArgs *>(this);
|
|
return NULL;
|
|
}
|
|
|
|
OptionValueDictionary *
|
|
OptionValue::GetAsDictionary ()
|
|
{
|
|
if (GetType () == OptionValue::eTypeDictionary)
|
|
return static_cast<OptionValueDictionary *>(this);
|
|
return NULL;
|
|
}
|
|
|
|
const OptionValueDictionary *
|
|
OptionValue::GetAsDictionary () const
|
|
{
|
|
if (GetType () == OptionValue::eTypeDictionary)
|
|
return static_cast<const OptionValueDictionary *>(this);
|
|
return NULL;
|
|
}
|
|
|
|
OptionValueEnumeration *
|
|
OptionValue::GetAsEnumeration ()
|
|
{
|
|
if (GetType () == OptionValue::eTypeEnum)
|
|
return static_cast<OptionValueEnumeration *>(this);
|
|
return NULL;
|
|
}
|
|
|
|
const OptionValueEnumeration *
|
|
OptionValue::GetAsEnumeration () const
|
|
{
|
|
if (GetType () == OptionValue::eTypeEnum)
|
|
return static_cast<const OptionValueEnumeration *>(this);
|
|
return NULL;
|
|
}
|
|
|
|
OptionValueFormat *
|
|
OptionValue::GetAsFormat ()
|
|
{
|
|
if (GetType () == OptionValue::eTypeFormat)
|
|
return static_cast<OptionValueFormat *>(this);
|
|
return NULL;
|
|
}
|
|
|
|
const OptionValueFormat *
|
|
OptionValue::GetAsFormat () const
|
|
{
|
|
if (GetType () == OptionValue::eTypeFormat)
|
|
return static_cast<const OptionValueFormat *>(this);
|
|
return NULL;
|
|
}
|
|
|
|
OptionValuePathMappings *
|
|
OptionValue::GetAsPathMappings ()
|
|
{
|
|
if (GetType () == OptionValue::eTypePathMap)
|
|
return static_cast<OptionValuePathMappings *>(this);
|
|
return NULL;
|
|
}
|
|
|
|
const OptionValuePathMappings *
|
|
OptionValue::GetAsPathMappings () const
|
|
{
|
|
if (GetType () == OptionValue::eTypePathMap)
|
|
return static_cast<const OptionValuePathMappings *>(this);
|
|
return NULL;
|
|
}
|
|
|
|
OptionValueProperties *
|
|
OptionValue::GetAsProperties ()
|
|
{
|
|
if (GetType () == OptionValue::eTypeProperties)
|
|
return static_cast<OptionValueProperties *>(this);
|
|
return NULL;
|
|
}
|
|
|
|
const OptionValueProperties *
|
|
OptionValue::GetAsProperties () const
|
|
{
|
|
if (GetType () == OptionValue::eTypeProperties)
|
|
return static_cast<const OptionValueProperties *>(this);
|
|
return NULL;
|
|
}
|
|
|
|
OptionValueRegex *
|
|
OptionValue::GetAsRegex ()
|
|
{
|
|
if (GetType () == OptionValue::eTypeRegex)
|
|
return static_cast<OptionValueRegex *>(this);
|
|
return NULL;
|
|
}
|
|
|
|
const OptionValueRegex *
|
|
OptionValue::GetAsRegex () const
|
|
{
|
|
if (GetType () == OptionValue::eTypeRegex)
|
|
return static_cast<const OptionValueRegex *>(this);
|
|
return NULL;
|
|
}
|
|
|
|
OptionValueSInt64 *
|
|
OptionValue::GetAsSInt64 ()
|
|
{
|
|
if (GetType () == OptionValue::eTypeSInt64)
|
|
return static_cast<OptionValueSInt64 *>(this);
|
|
return NULL;
|
|
}
|
|
|
|
const OptionValueSInt64 *
|
|
OptionValue::GetAsSInt64 () const
|
|
{
|
|
if (GetType () == OptionValue::eTypeSInt64)
|
|
return static_cast<const OptionValueSInt64 *>(this);
|
|
return NULL;
|
|
}
|
|
|
|
OptionValueString *
|
|
OptionValue::GetAsString ()
|
|
{
|
|
if (GetType () == OptionValue::eTypeString)
|
|
return static_cast<OptionValueString *>(this);
|
|
return NULL;
|
|
}
|
|
|
|
const OptionValueString *
|
|
OptionValue::GetAsString () const
|
|
{
|
|
if (GetType () == OptionValue::eTypeString)
|
|
return static_cast<const OptionValueString *>(this);
|
|
return NULL;
|
|
}
|
|
|
|
OptionValueUInt64 *
|
|
OptionValue::GetAsUInt64 ()
|
|
{
|
|
if (GetType () == OptionValue::eTypeUInt64)
|
|
return static_cast<OptionValueUInt64 *>(this);
|
|
return NULL;
|
|
}
|
|
|
|
const OptionValueUInt64 *
|
|
OptionValue::GetAsUInt64 () const
|
|
{
|
|
if (GetType () == OptionValue::eTypeUInt64)
|
|
return static_cast<const OptionValueUInt64 *>(this);
|
|
return NULL;
|
|
}
|
|
|
|
OptionValueUUID *
|
|
OptionValue::GetAsUUID ()
|
|
{
|
|
if (GetType () == OptionValue::eTypeUUID)
|
|
return static_cast<OptionValueUUID *>(this);
|
|
return NULL;
|
|
|
|
}
|
|
|
|
const OptionValueUUID *
|
|
OptionValue::GetAsUUID () const
|
|
{
|
|
if (GetType () == OptionValue::eTypeUUID)
|
|
return static_cast<const OptionValueUUID *>(this);
|
|
return NULL;
|
|
|
|
}
|
|
|
|
bool
|
|
OptionValue::GetBooleanValue (bool fail_value) const
|
|
{
|
|
const OptionValueBoolean *option_value = GetAsBoolean ();
|
|
if (option_value)
|
|
return option_value->GetCurrentValue();
|
|
return fail_value;
|
|
}
|
|
|
|
bool
|
|
OptionValue::SetBooleanValue (bool new_value)
|
|
{
|
|
OptionValueBoolean *option_value = GetAsBoolean ();
|
|
if (option_value)
|
|
{
|
|
option_value->SetCurrentValue(new_value);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
int64_t
|
|
OptionValue::GetEnumerationValue (int64_t fail_value) const
|
|
{
|
|
const OptionValueEnumeration *option_value = GetAsEnumeration();
|
|
if (option_value)
|
|
return option_value->GetCurrentValue();
|
|
return fail_value;
|
|
}
|
|
|
|
bool
|
|
OptionValue::SetEnumerationValue (int64_t value)
|
|
{
|
|
OptionValueEnumeration *option_value = GetAsEnumeration();
|
|
if (option_value)
|
|
{
|
|
option_value->SetCurrentValue(value);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
FileSpec
|
|
OptionValue::GetFileSpecValue () const
|
|
{
|
|
const OptionValueFileSpec *option_value = GetAsFileSpec ();
|
|
if (option_value)
|
|
return option_value->GetCurrentValue();
|
|
return FileSpec();
|
|
}
|
|
|
|
|
|
bool
|
|
OptionValue::SetFileSpecValue (const FileSpec &file_spec)
|
|
{
|
|
OptionValueFileSpec *option_value = GetAsFileSpec ();
|
|
if (option_value)
|
|
{
|
|
option_value->SetCurrentValue(file_spec, false);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
FileSpecList
|
|
OptionValue::GetFileSpecListValue () const
|
|
{
|
|
const OptionValueFileSpecList *option_value = GetAsFileSpecList ();
|
|
if (option_value)
|
|
return option_value->GetCurrentValue();
|
|
return FileSpecList();
|
|
}
|
|
|
|
|
|
lldb::Format
|
|
OptionValue::GetFormatValue (lldb::Format fail_value) const
|
|
{
|
|
const OptionValueFormat *option_value = GetAsFormat ();
|
|
if (option_value)
|
|
return option_value->GetCurrentValue();
|
|
return fail_value;
|
|
}
|
|
|
|
bool
|
|
OptionValue::SetFormatValue (lldb::Format new_value)
|
|
{
|
|
OptionValueFormat *option_value = GetAsFormat ();
|
|
if (option_value)
|
|
{
|
|
option_value->SetCurrentValue(new_value);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
const RegularExpression *
|
|
OptionValue::GetRegexValue () const
|
|
{
|
|
const OptionValueRegex *option_value = GetAsRegex ();
|
|
if (option_value)
|
|
return option_value->GetCurrentValue();
|
|
return NULL;
|
|
}
|
|
|
|
|
|
int64_t
|
|
OptionValue::GetSInt64Value (int64_t fail_value) const
|
|
{
|
|
const OptionValueSInt64 *option_value = GetAsSInt64 ();
|
|
if (option_value)
|
|
return option_value->GetCurrentValue();
|
|
return fail_value;
|
|
}
|
|
|
|
bool
|
|
OptionValue::SetSInt64Value (int64_t new_value)
|
|
{
|
|
OptionValueSInt64 *option_value = GetAsSInt64 ();
|
|
if (option_value)
|
|
{
|
|
option_value->SetCurrentValue(new_value);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
const char *
|
|
OptionValue::GetStringValue (const char *fail_value) const
|
|
{
|
|
const OptionValueString *option_value = GetAsString ();
|
|
if (option_value)
|
|
return option_value->GetCurrentValue();
|
|
return fail_value;
|
|
}
|
|
|
|
bool
|
|
OptionValue::SetStringValue (const char *new_value)
|
|
{
|
|
OptionValueString *option_value = GetAsString ();
|
|
if (option_value)
|
|
{
|
|
option_value->SetCurrentValue(new_value);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
uint64_t
|
|
OptionValue::GetUInt64Value (uint64_t fail_value) const
|
|
{
|
|
const OptionValueUInt64 *option_value = GetAsUInt64 ();
|
|
if (option_value)
|
|
return option_value->GetCurrentValue();
|
|
return fail_value;
|
|
}
|
|
|
|
bool
|
|
OptionValue::SetUInt64Value (uint64_t new_value)
|
|
{
|
|
OptionValueUInt64 *option_value = GetAsUInt64 ();
|
|
if (option_value)
|
|
{
|
|
option_value->SetCurrentValue(new_value);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
UUID
|
|
OptionValue::GetUUIDValue () const
|
|
{
|
|
const OptionValueUUID *option_value = GetAsUUID();
|
|
if (option_value)
|
|
return option_value->GetCurrentValue();
|
|
return UUID();
|
|
}
|
|
|
|
bool
|
|
OptionValue::SetUUIDValue (const UUID &uuid)
|
|
{
|
|
OptionValueUUID *option_value = GetAsUUID();
|
|
if (option_value)
|
|
{
|
|
option_value->SetCurrentValue(uuid);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
const char *
|
|
OptionValue::GetBuiltinTypeAsCString (Type t)
|
|
{
|
|
switch (t)
|
|
{
|
|
case eTypeInvalid: return "invalid";
|
|
case eTypeArch: return "arch";
|
|
case eTypeArgs: return "arguments";
|
|
case eTypeArray: return "array";
|
|
case eTypeBoolean: return "boolean";
|
|
case eTypeDictionary: return "dictionary";
|
|
case eTypeEnum: return "enum";
|
|
case eTypeFileSpec: return "file";
|
|
case eTypeFileSpecList: return "file-list";
|
|
case eTypeFormat: return "format";
|
|
case eTypePathMap: return "path-map";
|
|
case eTypeProperties: return "properties";
|
|
case eTypeRegex: return "regex";
|
|
case eTypeSInt64: return "int";
|
|
case eTypeString: return "string";
|
|
case eTypeUInt64: return "unsigned";
|
|
case eTypeUUID: return "uuid";
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
|
|
lldb::OptionValueSP
|
|
OptionValue::CreateValueFromCStringForTypeMask (const char *value_cstr, uint32_t type_mask, Error &error)
|
|
{
|
|
// If only 1 bit is set in the type mask for a dictionary or array
|
|
// then we know how to decode a value from a cstring
|
|
lldb::OptionValueSP value_sp;
|
|
switch (type_mask)
|
|
{
|
|
case 1u << eTypeArch: value_sp.reset(new OptionValueArch()); break;
|
|
case 1u << eTypeBoolean: value_sp.reset(new OptionValueBoolean(false)); break;
|
|
case 1u << eTypeFileSpec: value_sp.reset(new OptionValueFileSpec()); break;
|
|
case 1u << eTypeFormat: value_sp.reset(new OptionValueFormat(eFormatInvalid)); break;
|
|
case 1u << eTypeSInt64: value_sp.reset(new OptionValueSInt64()); break;
|
|
case 1u << eTypeString: value_sp.reset(new OptionValueString()); break;
|
|
case 1u << eTypeUInt64: value_sp.reset(new OptionValueUInt64()); break;
|
|
case 1u << eTypeUUID: value_sp.reset(new OptionValueUUID()); break;
|
|
}
|
|
|
|
if (value_sp)
|
|
error = value_sp->SetValueFromCString (value_cstr, eVarSetOperationAssign);
|
|
else
|
|
error.SetErrorString("unsupported type mask");
|
|
return value_sp;
|
|
}
|
|
|
|
bool
|
|
OptionValue::DumpQualifiedName (Stream &strm) const
|
|
{
|
|
bool dumped_something = false;
|
|
lldb::OptionValueSP m_parent_sp(m_parent_wp.lock());
|
|
if (m_parent_sp)
|
|
{
|
|
if (m_parent_sp->DumpQualifiedName(strm))
|
|
dumped_something = true;
|
|
}
|
|
ConstString name (GetName());
|
|
if (name)
|
|
{
|
|
if (dumped_something)
|
|
strm.PutChar('.');
|
|
else
|
|
dumped_something = true;
|
|
strm << name;
|
|
}
|
|
return dumped_something;
|
|
}
|
|
|
|
size_t
|
|
OptionValue::AutoComplete (CommandInterpreter &interpreter,
|
|
const char *s,
|
|
int match_start_point,
|
|
int max_return_elements,
|
|
bool &word_complete,
|
|
StringList &matches)
|
|
{
|
|
word_complete = false;
|
|
matches.Clear();
|
|
return matches.GetSize();
|
|
}
|
|
|
|
Error
|
|
OptionValue::SetValueFromCString (const char *value, VarSetOperationType op)
|
|
{
|
|
Error error;
|
|
switch (op)
|
|
{
|
|
case eVarSetOperationReplace:
|
|
error.SetErrorStringWithFormat ("%s objects do not support the 'replace' operation", GetTypeAsCString());
|
|
break;
|
|
case eVarSetOperationInsertBefore:
|
|
error.SetErrorStringWithFormat ("%s objects do not support the 'insert-before' operation", GetTypeAsCString());
|
|
break;
|
|
case eVarSetOperationInsertAfter:
|
|
error.SetErrorStringWithFormat ("%s objects do not support the 'insert-after' operation", GetTypeAsCString());
|
|
break;
|
|
case eVarSetOperationRemove:
|
|
error.SetErrorStringWithFormat ("%s objects do not support the 'remove' operation", GetTypeAsCString());
|
|
break;
|
|
case eVarSetOperationAppend:
|
|
error.SetErrorStringWithFormat ("%s objects do not support the 'append' operation", GetTypeAsCString());
|
|
break;
|
|
case eVarSetOperationClear:
|
|
error.SetErrorStringWithFormat ("%s objects do not support the 'clear' operation", GetTypeAsCString());
|
|
break;
|
|
case eVarSetOperationAssign:
|
|
error.SetErrorStringWithFormat ("%s objects do not support the 'assign' operation", GetTypeAsCString());
|
|
break;
|
|
case eVarSetOperationInvalid:
|
|
error.SetErrorStringWithFormat ("invalid operation performed on a %s object", GetTypeAsCString());
|
|
break;
|
|
}
|
|
return error;
|
|
}
|
|
|