source/Interpreter/OptionValue.cpp

//===-- 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;
}