Add support for character option types

[zturner]

Summary

This will allow, in a subsequent patch, the addition of a global setting that allows the user to specify a single character that LLDB will recognize as an escape character when processing arg strings to accomodate differences in Windows/non-Windows path handling.

This doesn't actually implement the escape-character global setting, which will come in a subsequent patch along with the code that uses it to properly parse command args.

[zturner]

Just realized I forgot to add the two new files, OptionValueChar.cpp and
.h. So hold off on reviewing this until tomorrow

[zturner]

Added OptionValueChar.cpp and OptionValueChar.h

[zturner]

ping. Also +clayborg just in case he's also interested in this.

[jingham]

This seems fine to me.

lldb/trunk/include/lldb/Interpreter/Args.h

public:
     static lldb::addr_t
     StringToAddress (const ExecutionContext *exe_ctx,
                      const char *s,
                      lldb::addr_t fail_value,
                      Error *error);
 
     static bool
     StringToBoolean (const char *s, bool fail_value, bool *success_ptr);
-    
+    static char StringToChar(const char *s, char fail_value, bool *success_ptr);
+
     static int64_t
     StringToOptionEnum (const char *s, OptionEnumValueElement *enum_values, int32_t fail_value, Error &error);
 
     static lldb::ScriptLanguage
     StringToScriptLanguage (const char *s, lldb::ScriptLanguage fail_value, bool *success_ptr);
 
     static Error
     StringToFormat (const char *s,

lldb/trunk/include/lldb/Interpreter/OptionValue.h

 namespace lldb_private {
 
     //---------------------------------------------------------------------
     // OptionValue
     //---------------------------------------------------------------------
     class OptionValue
     {
     public:
-        typedef enum {
+        typedef enum
+        {
             eTypeInvalid = 0,
             eTypeArch,
             eTypeArgs,
             eTypeArray,
             eTypeBoolean,
+            eTypeChar,
             eTypeDictionary,
             eTypeEnum,
             eTypeFileSpec,
             eTypeFileSpecList,
             eTypeFormat,
             eTypePathMap,
             eTypeProperties,
             eTypeRegex,
             eTypeSInt64,
-            eTypeString, 
+            eTypeString,
             eTypeUInt64,
             eTypeUUID
         } Type;
-        
         enum {
             eDumpOptionName         = (1u << 0),
             eDumpOptionType         = (1u << 1),
             eDumpOptionValue        = (1u << 2),
             eDumpOptionDescription  = (1u << 3),
             eDumpOptionRaw          = (1u << 4),
             eDumpGroupValue         = (eDumpOptionName | eDumpOptionType | eDumpOptionValue),
             eDumpGroupHelp          = (eDumpOptionName | eDumpOptionType | eDumpOptionDescription)
public:
         {
             // If only one bit is set, then return an appropriate enumeration
             switch (type_mask)
             {
                 case 1u << eTypeArch:           return eTypeArch;
                 case 1u << eTypeArgs:           return eTypeArgs;
                 case 1u << eTypeArray:          return eTypeArray;
                 case 1u << eTypeBoolean:        return eTypeBoolean;
+                case 1u << eTypeChar:           return eTypeChar;
                 case 1u << eTypeDictionary:     return eTypeDictionary;
                 case 1u << eTypeEnum:           return eTypeEnum;
                 case 1u << eTypeFileSpec:       return eTypeFileSpec;
                 case 1u << eTypeFileSpecList:   return eTypeFileSpecList;
                 case 1u << eTypeFormat:         return eTypeFormat;
                 case 1u << eTypePathMap:        return eTypePathMap;
                 case 1u << eTypeProperties:     return eTypeProperties;
                 case 1u << eTypeRegex:          return eTypeRegex;
public:
         OptionValueArgs *
         GetAsArgs ();
         
         const OptionValueArgs *
         GetAsArgs () const;
         
         OptionValueBoolean *
         GetAsBoolean ();
-        
+        OptionValueChar *
+        GetAsChar ();
+
         const OptionValueBoolean *
         GetAsBoolean () const;
-        
+        const OptionValueChar *
+        GetAsChar () const;
+
         OptionValueDictionary *
         GetAsDictionary ();
         
         const OptionValueDictionary *
         GetAsDictionary () const;
         
         OptionValueEnumeration *
         GetAsEnumeration ();
public:
         const OptionValueUUID *
         GetAsUUID () const;
         
         bool
         GetBooleanValue (bool fail_value = false) const;
         
         bool
         SetBooleanValue (bool new_value);
-        
+        char GetCharValue(char fail_value) const;
+
+        char SetCharValue(char new_value);
+
         int64_t
         GetEnumerationValue (int64_t fail_value = -1) const;
 
         bool
         SetEnumerationValue (int64_t value);
 
         FileSpec
         GetFileSpecValue () const;

lldb/trunk/include/lldb/Interpreter/OptionValueChar.h

+//===-- OptionValueBoolean.h ------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_OptionValueChar_h_
+#define liblldb_OptionValueChar_h_
+
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
+#include "lldb/Interpreter/OptionValue.h"
+
+namespace lldb_private {
+
+class OptionValueChar : public OptionValue
+{
+public:
+    OptionValueChar (char value) :
+        OptionValue(),
+        m_current_value (value),
+        m_default_value (value)
+    {
+    }
+    OptionValueChar (char current_value,
+                     char default_value) :
+        OptionValue(),
+        m_current_value (current_value),
+        m_default_value (default_value)
+    {
+    }
+    
+    virtual 
+    ~OptionValueChar()
+    {
+    }
+    
+    //---------------------------------------------------------------------
+    // Virtual subclass pure virtual overrides
+    //---------------------------------------------------------------------
+    
+    virtual OptionValue::Type
+    GetType () const
+    {
+        return eTypeChar;
+    }
+    
+    virtual void
+    DumpValue (const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask);
+    
+    virtual Error
+    SetValueFromCString (const char *value,
+                         VarSetOperationType op = eVarSetOperationAssign);
+    
+    virtual bool
+    Clear ()
+    {
+        m_current_value = m_default_value;
+        m_value_was_set = false;
+        return true;
+    }
+
+    //---------------------------------------------------------------------
+    // Subclass specific functions
+    //---------------------------------------------------------------------
+    
+    const char &
+    operator = (char c)
+    {
+        m_current_value = c;
+        return m_current_value;
+    }
+
+    char
+    GetCurrentValue() const
+    {
+        return m_current_value;
+    }
+    
+    char
+    GetDefaultValue() const
+    {
+        return m_default_value;
+    }
+    
+    void
+    SetCurrentValue (char value)
+    {
+        m_current_value = value;
+    }
+    
+    void
+    SetDefaultValue (char value)
+    {
+        m_default_value = value;
+    }
+    
+    virtual lldb::OptionValueSP
+    DeepCopy () const;
+
+protected:
+    char m_current_value;
+    char m_default_value;
+};
+
+} // namespace lldb_private
+
+#endif  // liblldb_OptionValueChar_h_

lldb/trunk/include/lldb/Interpreter/OptionValues.h

 #ifndef liblldb_OptionValues_h_
 #define liblldb_OptionValues_h_
 
 #include "lldb/Interpreter/OptionValue.h"
 #include "lldb/Interpreter/OptionValueArch.h"
 #include "lldb/Interpreter/OptionValueArgs.h"
 #include "lldb/Interpreter/OptionValueArray.h"
 #include "lldb/Interpreter/OptionValueBoolean.h"
+#include "lldb/Interpreter/OptionValueChar.h"
 #include "lldb/Interpreter/OptionValueDictionary.h"
 #include "lldb/Interpreter/OptionValueEnumeration.h"
 #include "lldb/Interpreter/OptionValueFileSpec.h"
 #include "lldb/Interpreter/OptionValueFileSpecList.h"
 #include "lldb/Interpreter/OptionValueFormat.h"
 #include "lldb/Interpreter/OptionValuePathMappings.h"
 #include "lldb/Interpreter/OptionValueProperties.h"
 #include "lldb/Interpreter/OptionValueRegex.h"
 #include "lldb/Interpreter/OptionValueSInt64.h"
 #include "lldb/Interpreter/OptionValueString.h"
 #include "lldb/Interpreter/OptionValueUInt64.h"
 #include "lldb/Interpreter/OptionValueUUID.h"
 
 #endif  // liblldb_OptionValues_h_

lldb/trunk/include/lldb/lldb-forward.h

 class   ObjectFileJITDelegate;
 class   OperatingSystem;
 class   Options;
 class   OptionValue;
 class   OptionValueArch;
 class   OptionValueArgs;
 class   OptionValueArray;
 class   OptionValueBoolean;
+class   OptionValueChar;
 class   OptionValueDictionary;
 class   OptionValueEnumeration;
 class   OptionValueFileSpec;
 class   OptionValueFileSpecList;
 class   OptionValueFormat;
 class   OptionValuePathMappings;
 class   OptionValueProperties;
 class   OptionValueRegex;

lldb/trunk/source/Interpreter/Args.cpp

if (s && s[0])
             if (success_ptr) *success_ptr = true;
             return true;
         }
     }
     if (success_ptr) *success_ptr = false;
     return fail_value;
 }
 
+char
+Args::StringToChar(const char *s, char fail_value, bool *success_ptr)
+{
+    bool success = false;
+    char result = fail_value;
+
+    if (s)
+    {
+        size_t length = strlen(s);
+        if (length == 1)
+        {
+            success = true;
+            result = s[0];
+        }
+    }
+    if (success_ptr)
+        *success_ptr = success;
+    return result;
+}
+
 const char *
 Args::StringToVersion (const char *s, uint32_t &major, uint32_t &minor, uint32_t &update)
 {
     major = UINT32_MAX;
     minor = UINT32_MAX;
     update = UINT32_MAX;
 
     if (s && s[0])

lldb/trunk/source/Interpreter/CMakeLists.txt

add_lldb_library(lldbInterpreter
   OptionGroupUInt64.cpp
   OptionGroupUUID.cpp
   OptionGroupValueObjectDisplay.cpp
   OptionValue.cpp
   OptionValueArch.cpp
   OptionValueArgs.cpp
   OptionValueArray.cpp
   OptionValueBoolean.cpp
+  OptionValueChar.cpp
   OptionValueDictionary.cpp
   OptionValueEnumeration.cpp
   OptionValueFileSpec.cpp
   OptionValueFileSpecLIst.cpp
   OptionValueFormat.cpp
   OptionValuePathMappings.cpp
   OptionValueProperties.cpp
   OptionValueRegex.cpp

lldb/trunk/source/Interpreter/OptionValue.cpp

 const OptionValueBoolean *
 OptionValue::GetAsBoolean () const
 {
     if (GetType () == OptionValue::eTypeBoolean)
         return static_cast<const OptionValueBoolean *>(this);
     return nullptr;
 }
 
+const OptionValueChar *
+OptionValue::GetAsChar () const
+{
+    if (GetType () == OptionValue::eTypeChar)
+        return static_cast<const OptionValueChar *>(this);
+    return nullptr;
+}
+
+OptionValueChar *
+OptionValue::GetAsChar ()
+{
+    if (GetType () == OptionValue::eTypeChar)
+        return static_cast<OptionValueChar *>(this);
+    return nullptr;
+}
 
 OptionValueFileSpec *
 OptionValue::GetAsFileSpec ()
 {
     if (GetType () == OptionValue::eTypeFileSpec)
         return static_cast<OptionValueFileSpec *>(this);
     return nullptr;
     
OptionValue::SetBooleanValue (bool new_value)
     if (option_value)
     {
         option_value->SetCurrentValue(new_value);
         return true;
     }
     return false;
 }
 
+char
+OptionValue::GetCharValue(char fail_value) const
+{
+    const OptionValueChar *option_value = GetAsChar();
+    if (option_value)
+        return option_value->GetCurrentValue();
+    return fail_value;
+}
+
+char
+OptionValue::SetCharValue(char new_value)
+{
+    OptionValueChar *option_value = GetAsChar();
+    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;
 }

 {
     switch (t)
     {
         case eTypeInvalid:      return "invalid";
         case eTypeArch:         return "arch";
         case eTypeArgs:         return "arguments";
         case eTypeArray:        return "array";
         case eTypeBoolean:      return "boolean";
+        case eTypeChar:
+            return "char";
         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";

 {
     // 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 << eTypeChar:       value_sp.reset(new OptionValueChar('\0')); 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;
     }
 

lldb/trunk/source/Interpreter/OptionValueArray.cpp

if (dump_mask & eDumpOptionValue)
                 case eTypeDictionary:
                 case eTypeProperties:
                 case eTypeFileSpecList:
                 case eTypePathMap:
                     m_values[i]->DumpValue(exe_ctx, strm, dump_mask | extra_dump_options);
                     break;
                     
                 case eTypeBoolean:
+                case eTypeChar:
                 case eTypeEnum:
                 case eTypeFileSpec:
                 case eTypeFormat:
                 case eTypeSInt64:
                 case eTypeString:
                 case eTypeUInt64:
                 case eTypeUUID:
                     // No need to show the type for dictionaries of simple items

lldb/trunk/source/Interpreter/OptionValueChar.cpp

+//===-- OptionValueChar.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/OptionValueChar.h"
+
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
+#include "lldb/Core/Stream.h"
+#include "lldb/Core/StringList.h"
+#include "lldb/Interpreter/Args.h"
+#include "llvm/ADT/STLExtras.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+void
+OptionValueChar::DumpValue (const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask)
+{
+    if (dump_mask & eDumpOptionType)
+        strm.Printf ("(%s)", GetTypeAsCString ());
+
+    if (dump_mask & eDumpOptionValue)
+    {
+        if (dump_mask & eDumpOptionType)
+            strm.PutCString (" = ");
+        if (m_current_value != '\0')
+            strm.PutChar(m_current_value);
+        else
+            strm.PutCString("(null)");
+    }
+}
+
+Error
+OptionValueChar::SetValueFromCString (const char *value_cstr,
+                                      VarSetOperationType op)
+{
+    Error error;
+    switch (op)
+    {
+    case eVarSetOperationClear:
+        Clear();
+        break;
+
+    case eVarSetOperationReplace:
+    case eVarSetOperationAssign:
+        {
+            bool success = false;
+            char char_value = Args::StringToChar(value_cstr, '\0', &success);
+            if (success)
+            {
+                m_current_value = char_value;
+                m_value_was_set = true;
+            }
+            else
+                error.SetErrorStringWithFormat("'%s' cannot be longer than 1 character", value_cstr);
+        }
+        break;
+
+    default:
+        error = OptionValue::SetValueFromCString (value_cstr, op);
+        break;
+    }
+    return error;
+}
+
+lldb::OptionValueSP
+OptionValueChar::DeepCopy () const
+{
+    return OptionValueSP(new OptionValueChar(*this));
+}
+
+

lldb/trunk/source/Interpreter/OptionValueDictionary.cpp

if (dump_mask & eDumpOptionValue)
                 case eTypeProperties:
                 case eTypeFileSpecList:
                 case eTypePathMap:
                     strm.PutChar (' ');
                     option_value->DumpValue(exe_ctx, strm, dump_mask | extra_dump_options);
                     break;
 
                 case eTypeBoolean:
+                case eTypeChar:
                 case eTypeEnum:
                 case eTypeFileSpec:
                 case eTypeFormat:
                 case eTypeSInt64:
                 case eTypeString:
                 case eTypeUInt64:
                 case eTypeUUID:
                     // No need to show the type for dictionaries of simple items

lldb/trunk/source/Interpreter/Property.cpp

switch (definition.type)
             // "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, nullptr)));
             else
                 m_value_sp.reset (new OptionValueBoolean(definition.default_uint_value != 0));
             break;
-            
+        case OptionValue::eTypeChar:
+            m_value_sp.reset(new OptionValueChar(Args::StringToChar(definition.default_cstr_value, '\0', nullptr)));
+            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