blob: 1f6b03ddac1ac2db1de346215fe378d7ab37aa18 [file] [log] [blame]
//===-- 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;
}