Merge lldb r188801 to contrib/llvm/tools/lldb/

1 files changed, 633 insertions, 0 deletions

diff --git a/contrib/llvm/tools/lldb/source/Interpreter/OptionValue.cpp b/contrib/llvm/tools/lldb/source/Interpreter/OptionValue.cpp
new file mode 100644
index 0000000..1f6b03d
--- /dev/null
+++ b/contrib/llvm/tools/lldb/source/Interpreter/OptionValue.cpp
@@ -0,0 +1,633 @@
+//===-- 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;
+}
+