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.

include/lldb/Interpreter/Args.h

 
     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);
 

include/lldb/Interpreter/OptionValue.h

     class OptionValue
     {
     public:
-        typedef enum {
+        typedef enum
+        {
             eTypeInvalid = 0,
             eTypeArch,
             eTypeArgs,
             eTypeArray,
             eTypeBoolean,
+            eTypeChar,
             eTypeDictionary,
             eTypeEnum,
             eTypeFileSpec,

             eTypeProperties,
             eTypeRegex,
             eTypeSInt64,
-            eTypeString, 
+            eTypeString,
             eTypeUInt64,
             eTypeUUID
         } Type;
-        
         enum {
             eDumpOptionName         = (1u << 0),
             eDumpOptionType         = (1u << 1),

                 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;

         
         OptionValueBoolean *
         GetAsBoolean ();
-        
+        OptionValueChar *
+        GetAsChar ();
+
         const OptionValueBoolean *
         GetAsBoolean () const;
-        
+        const OptionValueChar *
+        GetAsChar () const;
+
         OptionValueDictionary *
         GetAsDictionary ();
         

         
         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;
 

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_

include/lldb/Interpreter/OptionValues.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/lldb-forward.h

 class   OptionValueArgs;
 class   OptionValueArray;
 class   OptionValueBoolean;
+class   OptionValueChar;
 class   OptionValueDictionary;
 class   OptionValueEnumeration;
 class   OptionValueFileSpec;

source/Interpreter/Args.cpp

     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)
 {

source/Interpreter/CMakeLists.txt

   OptionValueArgs.cpp
   OptionValueArray.cpp
   OptionValueBoolean.cpp
+  OptionValueChar.cpp
   OptionValueDictionary.cpp
   OptionValueEnumeration.cpp
   OptionValueFileSpec.cpp

source/Interpreter/OptionValue.cpp

     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 ()

     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
 {

         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 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;

source/Interpreter/OptionValueArray.cpp

                     break;
                     
                 case eTypeBoolean:
+                case eTypeChar:
                 case eTypeEnum:
                 case eTypeFileSpec:
                 case eTypeFormat:

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));
+}
+
+

source/Interpreter/OptionValueDictionary.cpp

                     break;
 
                 case eTypeBoolean:
+                case eTypeChar:
                 case eTypeEnum:
                 case eTypeFileSpec:
                 case eTypeFormat:

source/Interpreter/Property.cpp

             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)));