Refactor OptionValue::SetValueFromCString to use llvm::StringRef

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

public:
         
         static const char *
         GetBuiltinTypeAsCString (Type t);
     
         virtual void
         DumpValue (const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask) = 0;
         
         virtual Error
-        SetValueFromCString (const char *value, VarSetOperationType op = eVarSetOperationAssign);
+        SetValueFromString (llvm::StringRef value, VarSetOperationType op = eVarSetOperationAssign);
         
         virtual bool
         Clear () = 0;
 
         virtual lldb::OptionValueSP
         DeepCopy () const = 0;
 
         virtual size_t

lldb/trunk/include/lldb/Interpreter/OptionValueArch.h

public:
     {
         return eTypeArch;
     }
     
     virtual void
     DumpValue (const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask);
     
     virtual Error
-    SetValueFromCString (const char *value,
+    SetValueFromString (llvm::StringRef value,
                          VarSetOperationType op = eVarSetOperationAssign);
     
     virtual bool
     Clear ()
     {
         m_current_value = m_default_value;
         m_value_was_set = false;
         return true;

lldb/trunk/include/lldb/Interpreter/OptionValueArray.h

public:
     {
         return eTypeArray;
     }
     
     virtual void
     DumpValue (const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask);
     
     virtual Error
-    SetValueFromCString (const char *value,
+    SetValueFromString (llvm::StringRef value,
                          VarSetOperationType op = eVarSetOperationAssign);
     
     virtual bool
     Clear ()
     {
         m_values.clear();
         m_value_was_set = false;
         return true;

lldb/trunk/include/lldb/Interpreter/OptionValueBoolean.h

public:
     {
         return eTypeBoolean;
     }
     
     virtual void
     DumpValue (const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask);
     
     virtual Error
-    SetValueFromCString (const char *value,
+    SetValueFromString (llvm::StringRef value,
                          VarSetOperationType op = eVarSetOperationAssign);
     
     virtual bool
     Clear ()
     {
         m_current_value = m_default_value;
         m_value_was_set = false;
         return true;

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

public:
     {
         return eTypeChar;
     }
     
     virtual void
     DumpValue (const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask);
     
     virtual Error
-    SetValueFromCString (const char *value,
+    SetValueFromString (llvm::StringRef value,
                          VarSetOperationType op = eVarSetOperationAssign);
     
     virtual bool
     Clear ()
     {
         m_current_value = m_default_value;
         m_value_was_set = false;
         return true;

lldb/trunk/include/lldb/Interpreter/OptionValueDictionary.h

public:
     {
         return eTypeDictionary;
     }
     
     virtual void
     DumpValue (const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask);
     
     virtual Error
-    SetValueFromCString (const char *value,
+    SetValueFromString (llvm::StringRef value,
                          VarSetOperationType op = eVarSetOperationAssign);
     
     virtual bool
     Clear ()
     {
         m_values.clear();
         m_value_was_set = false;
         return true;

lldb/trunk/include/lldb/Interpreter/OptionValueEnumeration.h

public:
     {
         return eTypeEnum;
     }
     
     virtual void
     DumpValue (const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask);
     
     virtual Error
-    SetValueFromCString (const char *value,
+    SetValueFromString (llvm::StringRef value,
                          VarSetOperationType op = eVarSetOperationAssign);
     
     virtual bool
     Clear ()
     {
         m_current_value = m_default_value;
         m_value_was_set = false;
         return true;

lldb/trunk/include/lldb/Interpreter/OptionValueFileSpec.h

public:
     {
         return eTypeFileSpec;
     }
     
     virtual void
     DumpValue (const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask);
     
     virtual Error
-    SetValueFromCString (const char *value,
+    SetValueFromString (llvm::StringRef value,
                          VarSetOperationType op = eVarSetOperationAssign);
     
     virtual bool
     Clear ()
     {
         m_current_value = m_default_value;
         m_value_was_set = false;
         m_data_sp.reset();

lldb/trunk/include/lldb/Interpreter/OptionValueFileSpecList.h

public:
     {
         return eTypeFileSpecList;
     }
     
     virtual void
     DumpValue (const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask);
     
     virtual Error
-    SetValueFromCString (const char *value,
+    SetValueFromString (llvm::StringRef value,
                          VarSetOperationType op = eVarSetOperationAssign);
     
     virtual bool
     Clear ()
     {
         m_current_value.Clear();
         m_value_was_set = false;
         return true;

lldb/trunk/include/lldb/Interpreter/OptionValueFormat.h

public:
     {
         return eTypeFormat;
     }
     
     virtual void
     DumpValue (const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask);
     
     virtual Error
-    SetValueFromCString (const char *value,
+    SetValueFromString (llvm::StringRef value,
                          VarSetOperationType op = eVarSetOperationAssign);
     
     virtual bool
     Clear ()
     {
         m_current_value = m_default_value;
         m_value_was_set = false;
         return true;

lldb/trunk/include/lldb/Interpreter/OptionValueFormatEntity.h

public:
     {
         return eTypeFormatEntity;
     }
     
     void
     DumpValue (const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask) override;
     
     Error
-    SetValueFromCString (const char *value,
+    SetValueFromString (llvm::StringRef value,
                          VarSetOperationType op = eVarSetOperationAssign) override;
     
     bool
     Clear () override;
     
     lldb::OptionValueSP
     DeepCopy () const override;
 

lldb/trunk/include/lldb/Interpreter/OptionValuePathMappings.h

public:
     {
         return eTypePathMap;
     }
     
     virtual void
     DumpValue (const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask);
     
     virtual Error
-    SetValueFromCString (const char *value,
+    SetValueFromString (llvm::StringRef value,
                          VarSetOperationType op = eVarSetOperationAssign);
     
     virtual bool
     Clear ()
     {
         m_path_mappings.Clear(m_notify_changes);
         m_value_was_set = false;
         return true;

lldb/trunk/include/lldb/Interpreter/OptionValueProperties.h

public:
     
     virtual bool
     Clear ();
 
     virtual lldb::OptionValueSP
     DeepCopy () const;
     
     virtual Error
-    SetValueFromCString (const char *value, VarSetOperationType op = eVarSetOperationAssign);
+    SetValueFromString (llvm::StringRef value, VarSetOperationType op = eVarSetOperationAssign);
 
     virtual void
     DumpValue (const ExecutionContext *exe_ctx,
                Stream &strm,
                uint32_t dump_mask);
 
     virtual ConstString
     GetName () const

lldb/trunk/include/lldb/Interpreter/OptionValueRegex.h

public:
     {
         return eTypeRegex;
     }
     
     virtual void
     DumpValue (const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask);
     
     virtual Error
-    SetValueFromCString (const char *value,
+    SetValueFromString (llvm::StringRef value,
                          VarSetOperationType op = eVarSetOperationAssign);
 
     virtual bool
     Clear ()
     {
         m_regex.Clear();
         m_value_was_set = false;
         return true;

lldb/trunk/include/lldb/Interpreter/OptionValueSInt64.h

public:
     {
         return eTypeSInt64;
     }
     
     virtual void
     DumpValue (const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask);
     
     virtual Error
-    SetValueFromCString (const char *value,
+    SetValueFromString (llvm::StringRef value,
                          VarSetOperationType op = eVarSetOperationAssign);
     
     virtual bool
     Clear ()
     {
         m_current_value = m_default_value;
         m_value_was_set = false;
         return true;

lldb/trunk/include/lldb/Interpreter/OptionValueString.h

public:
     {
         return eTypeString;
     }
     
     virtual void
     DumpValue (const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask);
     
     virtual Error
-    SetValueFromCString (const char *value,
+    SetValueFromString (llvm::StringRef value,
                          VarSetOperationType op = eVarSetOperationAssign);
 
     virtual bool
     Clear ()
     {
         m_current_value = m_default_value;
         m_value_was_set = false;
         return true;

lldb/trunk/include/lldb/Interpreter/OptionValueUInt64.h

public:
     {
         return eTypeUInt64;
     }
     
     virtual void
     DumpValue (const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask);
     
     virtual Error
-    SetValueFromCString (const char *value,
+    SetValueFromString (llvm::StringRef value,
                          VarSetOperationType op = eVarSetOperationAssign);
     
     virtual bool
     Clear ()
     {
         m_current_value = m_default_value;
         m_value_was_set = false;
         return true;

lldb/trunk/include/lldb/Interpreter/OptionValueUUID.h

public:
     {
         return eTypeUUID;
     }
     
     virtual void
     DumpValue (const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask);
     
     virtual Error
-    SetValueFromCString (const char *value,
+    SetValueFromString (llvm::StringRef value,
                          VarSetOperationType op = eVarSetOperationAssign);
     
     virtual bool
     Clear ()
     {
         m_uuid.Clear();
         m_value_was_set = false;
         return true;

lldb/trunk/source/Commands/CommandObjectBreakpoint.cpp

public:
     {
         Error error;
         const int short_option = g_breakpoint_name_options[option_idx].short_option;
       
         switch (short_option)
         {
         case 'N':
             if (BreakpointID::StringIsBreakpointName(option_value, error) && error.Success())
-                m_name.SetValueFromCString(option_value);
+                m_name.SetValueFromString(option_value);
             break;
           
         case 'B':
-            if (m_breakpoint.SetValueFromCString(option_value).Fail())
+            if (m_breakpoint.SetValueFromString(option_value).Fail())
                 error.SetErrorStringWithFormat ("unrecognized value \"%s\" for breakpoint", option_value);
             break;
         case 'D':
-            if (m_use_dummy.SetValueFromCString(option_value).Fail())
+            if (m_use_dummy.SetValueFromString(option_value).Fail())
                 error.SetErrorStringWithFormat ("unrecognized value \"%s\" for use-dummy", option_value);
             break;
 
         default:
               error.SetErrorStringWithFormat("unrecognized short option '%c'", short_option);
               break;
         }
         return error;

lldb/trunk/source/Commands/CommandObjectCommands.cpp

public:
         SetOptionValue (uint32_t option_idx, const char *option_arg)
         {
             Error error;
             const int short_option = m_getopt_table[option_idx].val;
             
             switch (short_option)
             {
                 case 'c':
-                    error = m_count.SetValueFromCString(option_arg,eVarSetOperationAssign);
+                    error = m_count.SetValueFromString(option_arg,eVarSetOperationAssign);
                     break;
                 case 's':
                     if (option_arg && strcmp("end", option_arg) == 0)
                     {
                         m_start_idx.SetCurrentValue(UINT64_MAX);
                         m_start_idx.SetOptionWasSet();
                     }
                     else
-                        error = m_start_idx.SetValueFromCString(option_arg,eVarSetOperationAssign);
+                        error = m_start_idx.SetValueFromString(option_arg,eVarSetOperationAssign);
                     break;
                 case 'e':
-                    error = m_stop_idx.SetValueFromCString(option_arg,eVarSetOperationAssign);
+                    error = m_stop_idx.SetValueFromString(option_arg,eVarSetOperationAssign);
                     break;
                 case 'C':
                     m_clear.SetCurrentValue(true);
                     m_clear.SetOptionWasSet();
                     break;
                 default:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
public:
         SetOptionValue (uint32_t option_idx, const char *option_arg)
         {
             Error error;
             const int short_option = m_getopt_table[option_idx].val;
             
             switch (short_option)
             {
                 case 'e':
-                    error = m_stop_on_error.SetValueFromCString(option_arg);
+                    error = m_stop_on_error.SetValueFromString(option_arg);
                     break;
 
                 case 'c':
-                    error = m_stop_on_continue.SetValueFromCString(option_arg);
+                    error = m_stop_on_continue.SetValueFromString(option_arg);
                     break;
 
                 case 's':
-                    error = m_silent_run.SetValueFromCString(option_arg);
+                    error = m_silent_run.SetValueFromString(option_arg);
                     break;
 
                 default:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
             
             return error;

lldb/trunk/source/Commands/CommandObjectMemory.cpp

SetOptionValue (CommandInterpreter &interpreter,
                     const char *option_arg)
     {
         Error error;
         const int short_option = g_option_table[option_idx].short_option;
         
         switch (short_option)
         {
             case 'l':
-                error = m_num_per_line.SetValueFromCString (option_arg);
+                error = m_num_per_line.SetValueFromString (option_arg);
                 if (m_num_per_line.GetCurrentValue() == 0)
                     error.SetErrorStringWithFormat("invalid value for --num-per-line option '%s'", option_arg);
                 break;
 
             case 'b':
                 m_output_as_binary = true;
                 break;
                 
             case 't':
-                error = m_view_as_type.SetValueFromCString (option_arg);
+                error = m_view_as_type.SetValueFromString (option_arg);
                 break;
             
             case 'r':
                 m_force = true;
                 break;
                 
             default:
                 error.SetErrorStringWithFormat("unrecognized short option '%c'", short_option);
SetOptionValue (CommandInterpreter &interpreter,
                     const char *option_arg)
     {
         Error error;
         const int short_option = g_memory_find_option_table[option_idx].short_option;
       
         switch (short_option)
         {
         case 'e':
-              m_expr.SetValueFromCString(option_arg);
+              m_expr.SetValueFromString(option_arg);
               break;
           
         case 's':
-              m_string.SetValueFromCString(option_arg);
+              m_string.SetValueFromString(option_arg);
               break;
           
         case 'c':
-              if (m_count.SetValueFromCString(option_arg).Fail())
+              if (m_count.SetValueFromString(option_arg).Fail())
                   error.SetErrorString("unrecognized value for count");
               break;
                 
         case 'o':
-               if (m_offset.SetValueFromCString(option_arg).Fail())
+               if (m_offset.SetValueFromString(option_arg).Fail())
                    error.SetErrorString("unrecognized value for dump-offset");
                 break;
 
         default:
               error.SetErrorStringWithFormat("unrecognized short option '%c'", short_option);
               break;
         }
         return error;

lldb/trunk/source/Core/Disassembler.cpp

while (!done)
             else
                 value = line;
                 
             OptionValueSP data_value_sp;
             switch (data_type)
             {
             case OptionValue::eTypeUInt64:
                 data_value_sp.reset (new OptionValueUInt64 (0, 0));
-                data_value_sp->SetValueFromCString (value.c_str());
+                data_value_sp->SetValueFromString (value);
                 break;
             // Other types can be added later as needed.
             default:
                 data_value_sp.reset (new OptionValueString (value.c_str(), ""));
                 break;
             }
 
             option_value_sp->GetAsArray()->InsertValue (idx, data_value_sp);
while (!done)
                     return option_value_sp;
                 }
                 // We've used the data_type to read an array; re-set the type to Invalid
                 data_type = OptionValue::eTypeInvalid;
             }
             else if ((value[0] == '0') && (value[1] == 'x'))
             {
                 value_sp.reset (new OptionValueUInt64 (0, 0));
-                value_sp->SetValueFromCString (value.c_str());
+                value_sp->SetValueFromString (value);
             }
             else
             {
                 size_t len = value.size();
                 if ((value[0] == '"') && (value[len-1] == '"'))
                     value = value.substr (1, len-2);
                 value_sp.reset (new OptionValueString (value.c_str(), ""));
             }

lldb/trunk/source/Interpreter/OptionGroupBoolean.cpp

OptionGroupBoolean::SetOptionValue (CommandInterpreter &interpreter,
     if (m_option_definition.option_has_arg == OptionParser::eNoArgument)
     {
         // Not argument, toggle the default value and mark the option as having been set
         m_value.SetCurrentValue (!m_value.GetDefaultValue());
         m_value.SetOptionWasSet ();
     }
     else
     {
-        error = m_value.SetValueFromCString (option_arg);
+        error = m_value.SetValueFromString (option_arg);
     }
     return error;
 }
 
 void
 OptionGroupBoolean::OptionParsingStarting (CommandInterpreter &interpreter)
 {
     m_value.Clear();
 }

lldb/trunk/source/Interpreter/OptionGroupFile.cpp

 {
 }
 
 Error
 OptionGroupFile::SetOptionValue (CommandInterpreter &interpreter,
                                  uint32_t option_idx,
                                  const char *option_arg)
 {
-    Error error (m_file.SetValueFromCString (option_arg));
+    Error error (m_file.SetValueFromString (option_arg));
     return error;
 }
 
 void
 OptionGroupFile::OptionParsingStarting (CommandInterpreter &interpreter)
 {
     m_file.Clear();
 }

 {
 }
 
 Error
 OptionGroupFileList::SetOptionValue (CommandInterpreter &interpreter,
                                      uint32_t option_idx,
                                      const char *option_arg)
 {
-    Error error (m_file_list.SetValueFromCString (option_arg));
+    Error error (m_file_list.SetValueFromString (option_arg));
     return error;
 }
 
 void
 OptionGroupFileList::OptionParsingStarting (CommandInterpreter &interpreter)
 {
     m_file_list.Clear();
 }

lldb/trunk/source/Interpreter/OptionGroupFormat.cpp

OptionGroupFormat::SetOptionValue (CommandInterpreter &interpreter,
                                    const char *option_arg)
 {
     Error error;
     const int short_option = g_option_table[option_idx].short_option;
 
     switch (short_option)
     {
         case 'f':
-            error = m_format.SetValueFromCString (option_arg);
+            error = m_format.SetValueFromString (option_arg);
             break;
 
         case 'c':
             if (m_count.GetDefaultValue() == 0)
             {
                 error.SetErrorString ("--count option is disabled");
             }
             else
             {
-                error = m_count.SetValueFromCString (option_arg);
+                error = m_count.SetValueFromString (option_arg);
                 if (m_count.GetCurrentValue() == 0)
                     error.SetErrorStringWithFormat("invalid --count option value '%s'", option_arg);
             }
             break;
             
         case 's':
             if (m_byte_size.GetDefaultValue() == 0)
             {
                 error.SetErrorString ("--size option is disabled");
             }
             else
             {
-                error = m_byte_size.SetValueFromCString (option_arg);
+                error = m_byte_size.SetValueFromString (option_arg);
                 if (m_byte_size.GetCurrentValue() == 0)
                     error.SetErrorStringWithFormat("invalid --size option value '%s'", option_arg);
             }
             break;
 
         case 'G':
             {
                 char *end = nullptr;

lldb/trunk/source/Interpreter/OptionGroupOutputFile.cpp

OptionGroupOutputFile::SetOptionValue (CommandInterpreter &interpreter,
                                        const char *option_arg)
 {
     Error error;
     const int short_option = g_option_table[option_idx].short_option;
 
     switch (short_option)
     {
         case 'o':
-            error = m_file.SetValueFromCString (option_arg);
+            error = m_file.SetValueFromString (option_arg);
             break;
 
         case SHORT_OPTION_APND:
             m_append.SetCurrentValue(true);
             break;
 
         default:
             error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);

lldb/trunk/source/Interpreter/OptionGroupString.cpp

 {
 }
 
 Error
 OptionGroupString::SetOptionValue (CommandInterpreter &interpreter,
                                    uint32_t option_idx,
                                    const char *option_arg)
 {
-    Error error (m_value.SetValueFromCString (option_arg));
+    Error error (m_value.SetValueFromString (option_arg));
     return error;
 }
 
 void
 OptionGroupString::OptionParsingStarting (CommandInterpreter &interpreter)
 {
     m_value.Clear();
 }

lldb/trunk/source/Interpreter/OptionGroupUInt64.cpp

 {
 }
 
 Error
 OptionGroupUInt64::SetOptionValue (CommandInterpreter &interpreter,
                                    uint32_t option_idx,
                                    const char *option_arg)
 {
-    Error error (m_value.SetValueFromCString (option_arg));
+    Error error (m_value.SetValueFromString (option_arg));
     return error;
 }
 
 void
 OptionGroupUInt64::OptionParsingStarting (CommandInterpreter &interpreter)
 {
     m_value.Clear();
 }

lldb/trunk/source/Interpreter/OptionGroupUUID.cpp

OptionGroupUUID::SetOptionValue (CommandInterpreter &interpreter,
                                  const char *option_arg)
 {
     Error error;
     const int short_option = g_option_table[option_idx].short_option;
 
     switch (short_option)
     {
         case 'u':
-            error = m_uuid.SetValueFromCString (option_arg);
+            error = m_uuid.SetValueFromString (option_arg);
             if (error.Success())
                 m_uuid.SetOptionWasSet();
             break;
 
         default:
             error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
             break;
     }

lldb/trunk/source/Interpreter/OptionValue.cpp

OptionValue::CreateValueFromCStringForTypeMask (const char *value_cstr, uint32_t type_mask, Error &error)
     case 1u << eTypeFormatEntity:   value_sp.reset(new OptionValueFormatEntity(NULL));    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);
+        error = value_sp->SetValueFromString (value_cstr, eVarSetOperationAssign);
     else
         error.SetErrorString("unsupported type mask");
     return value_sp;
 }
 
 bool
 OptionValue::DumpQualifiedName (Stream &strm) const
 {
OptionValue::AutoComplete (CommandInterpreter &interpreter,
                            StringList &matches)
 {
     word_complete = false;
     matches.Clear();
     return matches.GetSize();
 }
 
 Error
-OptionValue::SetValueFromCString (const char *value, VarSetOperationType op)
+OptionValue::SetValueFromString (llvm::StringRef value, VarSetOperationType op)
 {
     Error error;
     switch (op)
     {
     case eVarSetOperationReplace:
         error.SetErrorStringWithFormat ("%s objects do not support the 'replace' operation", GetTypeAsCString());
         break;
     case eVarSetOperationInsertBefore:

lldb/trunk/source/Interpreter/OptionValueArch.cpp

if (dump_mask & eDumpOptionValue)
             const char *arch_name = m_current_value.GetArchitectureName();
             if (arch_name)
                 strm.PutCString (arch_name);
         }
     }
 }
 
 Error
-OptionValueArch::SetValueFromCString (const char *value_cstr, VarSetOperationType op)
+OptionValueArch::SetValueFromString (llvm::StringRef value, VarSetOperationType op)
 {
     Error error;
     switch (op)
     {
     case eVarSetOperationClear:
         Clear();
         NotifyValueChanged();
         break;
         
     case eVarSetOperationReplace:
     case eVarSetOperationAssign:
-        if (value_cstr)
         {
-            std::string value = llvm::StringRef(value_cstr).trim().str();
-            value_cstr = value.c_str();
-            if (m_current_value.SetTriple (value_cstr))
+            std::string value_str = value.trim().str();
+            if (m_current_value.SetTriple (value_str.c_str()))
             {
                 m_value_was_set = true;
                 NotifyValueChanged();
             }
             else
-                error.SetErrorStringWithFormat("unsupported architecture '%s'", value_cstr);
-        }
-        else
-        {
-            error.SetErrorString("invalid value string");
-        }
+                error.SetErrorStringWithFormat("unsupported architecture '%s'", value_str.c_str());
             break;
-        
+        }
     case eVarSetOperationInsertBefore:
     case eVarSetOperationInsertAfter:
     case eVarSetOperationRemove:
     case eVarSetOperationAppend:
     case eVarSetOperationInvalid:
-        error = OptionValue::SetValueFromCString (value_cstr, op);
+        error = OptionValue::SetValueFromString (value, op);
         break;
     }
     return error;
 }
 
 lldb::OptionValueSP
 OptionValueArch::DeepCopy () const
 {

lldb/trunk/source/Interpreter/OptionValueArray.cpp

if (dump_mask & eDumpOptionValue)
             if (i < (size - 1))
                 strm.EOL();
         }
         strm.IndentLess();
     }
 }
 
 Error
-OptionValueArray::SetValueFromCString (const char *value, VarSetOperationType op)
+OptionValueArray::SetValueFromString (llvm::StringRef value, VarSetOperationType op)
 {
-    Args args(value);
+    Args args(value.str().c_str());
     Error error = SetArgs (args, op);
     if (error.Success())
         NotifyValueChanged();
     return error;
 }
 
 
 lldb::OptionValueSP

lldb/trunk/source/Interpreter/OptionValueBoolean.cpp

//        DumpQualifiedName (strm);
     {
         if (dump_mask & eDumpOptionType)
             strm.PutCString (" = ");
         strm.PutCString (m_current_value ? "true" : "false");
     }
 }
 
 Error
-OptionValueBoolean::SetValueFromCString (const char *value_cstr,
+OptionValueBoolean::SetValueFromString (llvm::StringRef value_str,
                                          VarSetOperationType op)
 {
     Error error;
     switch (op)
     {
     case eVarSetOperationClear:
         Clear();
         NotifyValueChanged();
         break;
 
     case eVarSetOperationReplace:
     case eVarSetOperationAssign:
         {
             bool success = false;
-            bool value = Args::StringToBoolean(value_cstr, false, &success);
+            bool value = Args::StringToBoolean(value_str.str().c_str(), false, &success);
             if (success)
             {
                 m_value_was_set = true;
                 m_current_value = value;
                 NotifyValueChanged();
             }
             else
             {
-                if (value_cstr == nullptr)
-                    error.SetErrorString ("invalid boolean string value: NULL");
-                else if (value_cstr[0] == '\0')
+                if (value_str.size() == 0)
                     error.SetErrorString ("invalid boolean string value <empty>");
                 else
-                    error.SetErrorStringWithFormat ("invalid boolean string value: '%s'", value_cstr);
+                    error.SetErrorStringWithFormat ("invalid boolean string value: '%s'",
+                            value_str.str().c_str());
             }
         }
         break;
 
     case eVarSetOperationInsertBefore:
     case eVarSetOperationInsertAfter:
     case eVarSetOperationRemove:
     case eVarSetOperationAppend:
     case eVarSetOperationInvalid:
-        error = OptionValue::SetValueFromCString (value_cstr, op);
+        error = OptionValue::SetValueFromString (value_str, op);
         break;
     }
     return error;
 }
 
 lldb::OptionValueSP
 OptionValueBoolean::DeepCopy () const
 {

lldb/trunk/source/Interpreter/OptionValueChar.cpp

if (dump_mask & eDumpOptionValue)
         if (m_current_value != '\0')
             strm.PutChar(m_current_value);
         else
             strm.PutCString("(null)");
     }
 }
 
 Error
-OptionValueChar::SetValueFromCString (const char *value_cstr,
+OptionValueChar::SetValueFromString (llvm::StringRef value,
                                       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);
+            char char_value = Args::StringToChar(value.str().c_str(), '\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);
+                error.SetErrorStringWithFormat("'%s' cannot be longer than 1 character", value.str().c_str());
         }
         break;
 
     default:
-        error = OptionValue::SetValueFromCString (value_cstr, op);
+        error = OptionValue::SetValueFromString (value.str().c_str(), op);
         break;
     }
     return error;
 }
 
 lldb::OptionValueSP
 OptionValueChar::DeepCopy () const
 {
     return OptionValueSP(new OptionValueChar(*this));
 }
 
 

lldb/trunk/source/Interpreter/OptionValueDictionary.cpp

case eVarSetOperationRemove:
         {
             error.SetErrorString("remove operation takes one or more key arguments");
         }
         break;
         
     case eVarSetOperationInsertBefore:
     case eVarSetOperationInsertAfter:
     case eVarSetOperationInvalid:
-        error = OptionValue::SetValueFromCString (nullptr, op);
+        error = OptionValue::SetValueFromString (llvm::StringRef(), op);
         break;
     }
     return error;
 }
 
 Error
-OptionValueDictionary::SetValueFromCString (const char *value_cstr, VarSetOperationType op)
+OptionValueDictionary::SetValueFromString (llvm::StringRef value, VarSetOperationType op)
 {
-    Args args(value_cstr);
+    Args args(value.str().c_str());
     Error error = SetArgs (args, op);
     if (error.Success())
         NotifyValueChanged();
     return error;
 }
 
 lldb::OptionValueSP
 OptionValueDictionary::GetSubValue (const ExecutionContext *exe_ctx, const char *name, bool will_modify, Error &error) const

 
 Error
 OptionValueDictionary::SetSubValue (const ExecutionContext *exe_ctx, VarSetOperationType op, const char *name, const char *value)
 {
     Error error;
     const bool will_modify = true;
     lldb::OptionValueSP value_sp (GetSubValue (exe_ctx, name, will_modify, error));
     if (value_sp)
-        error = value_sp->SetValueFromCString(value, op);
+        error = value_sp->SetValueFromString(value, op);
     else
     {
         if (error.AsCString() == nullptr)
             error.SetErrorStringWithFormat("invalid value path '%s'", name);
     }
     return error;
 }
 

 {
     collection::const_iterator pos = m_values.find (key);
     if (pos != m_values.end())
     {
         if (!can_replace)
             return false;
         if (pos->second->GetType() == OptionValue::eTypeString)
         {
-            pos->second->SetValueFromCString(value);
+            pos->second->SetValueFromString(value);
             return true;
         }
     }
     m_values[key] = OptionValueSP (new OptionValueString (value));
     return true;
 
 }
 

lldb/trunk/source/Interpreter/OptionValueEnumeration.cpp

if (dump_mask & eDumpOptionValue)
                 return;
             }
         }
         strm.Printf("%" PRIu64, (uint64_t)m_current_value);
     }
 }
 
 Error
-OptionValueEnumeration::SetValueFromCString (const char *value, VarSetOperationType op)
+OptionValueEnumeration::SetValueFromString (llvm::StringRef value, VarSetOperationType op)
 {
     Error error;
     switch (op)
     {
         case eVarSetOperationClear:
             Clear ();
             NotifyValueChanged();
             break;
             
         case eVarSetOperationReplace:
         case eVarSetOperationAssign:
-            if (value && value[0])
             {
-                ConstString const_enumerator_name(llvm::StringRef(value).trim());
+                ConstString const_enumerator_name(value.trim());
                 const EnumerationMapEntry *enumerator_entry = m_enumerations.FindFirstValueForName (const_enumerator_name.GetCString());
                 if (enumerator_entry)
                 {
                     m_current_value = enumerator_entry->value.value;
                     NotifyValueChanged();
                 }
                 else
                 {
                     StreamString error_strm;
-                    error_strm.Printf("invalid enumeration value '%s'", value);
+                    error_strm.Printf("invalid enumeration value '%s'", value.str().c_str());
                     const size_t count = m_enumerations.GetSize ();
                     if (count)
                     {
                         error_strm.Printf(", valid values are: %s", m_enumerations.GetCStringAtIndex(0));
                         for (size_t i=1; i<count; ++i)
                         {
                             error_strm.Printf (", %s", m_enumerations.GetCStringAtIndex(i));
                         }
                     }
                     error.SetErrorString(error_strm.GetData());
                 }
-            }
-            else
-            {
-                error.SetErrorString("invalid enumeration value");
-            }
                 break;
+            }
             
         case eVarSetOperationInsertBefore:
         case eVarSetOperationInsertAfter:
         case eVarSetOperationRemove:
         case eVarSetOperationAppend:
         case eVarSetOperationInvalid:
-            error = OptionValue::SetValueFromCString (value, op);
+            error = OptionValue::SetValueFromString (value, op);
             break;
     }
     return error;
 }
 
 void
 OptionValueEnumeration::SetEnumerations (const OptionEnumValueElement *enumerators)
 {

lldb/trunk/source/Interpreter/OptionValueFileSpec.cpp

if (dump_mask & eDumpOptionValue)
         if (m_current_value)
         {
             strm << '"' << m_current_value.GetPath().c_str() << '"';
         }
     }
 }
 
 Error
-OptionValueFileSpec::SetValueFromCString (const char *value_cstr,
+OptionValueFileSpec::SetValueFromString (llvm::StringRef value,
                                           VarSetOperationType op)
 {
     Error error;
     switch (op)
     {
     case eVarSetOperationClear:
         Clear ();
         NotifyValueChanged();
         break;
         
     case eVarSetOperationReplace:
     case eVarSetOperationAssign:
-        if (value_cstr && value_cstr[0])
+        if (value.size() > 0)
         {
             // The setting value may have whitespace, double-quotes, or single-quotes around the file
             // path to indicate that internal spaces are not word breaks.  Strip off any ws & quotes
             // from the start and end of the file path - we aren't doing any word // breaking here so 
             // the quoting is unnecessary.  NB this will cause a problem if someone tries to specify
             // a file path that legitimately begins or ends with a " or ' character, or whitespace.
-            std::string filepath(value_cstr);
-            auto prefix_chars_to_trim = filepath.find_first_not_of ("\"' \t");
-            if (prefix_chars_to_trim != std::string::npos && prefix_chars_to_trim > 0)
-                filepath.erase(0, prefix_chars_to_trim);
-            auto suffix_chars_to_trim = filepath.find_last_not_of ("\"' \t");
-            if (suffix_chars_to_trim != std::string::npos && suffix_chars_to_trim < filepath.size())
-                filepath.erase (suffix_chars_to_trim + 1);
-
+            value = value.trim("\"' \t");
             m_value_was_set = true;
-            m_current_value.SetFile(filepath.c_str(), m_resolve);
+            m_current_value.SetFile(value.str().c_str(), m_resolve);
             m_data_sp.reset();
             NotifyValueChanged();
         }
         else
         {
             error.SetErrorString("invalid value string");
         }
         break;
         
     case eVarSetOperationInsertBefore:
     case eVarSetOperationInsertAfter:
     case eVarSetOperationRemove:
     case eVarSetOperationAppend:
     case eVarSetOperationInvalid:
-        error = OptionValue::SetValueFromCString (value_cstr, op);
+        error = OptionValue::SetValueFromString (value, op);
         break;
     }
     return error;
 }
 
 lldb::OptionValueSP
 OptionValueFileSpec::DeepCopy () const
 {

lldb/trunk/source/Interpreter/OptionValueFileSpecLIst.cpp

if (dump_mask & eDumpOptionValue)
             strm.Printf("[%u]: ", i);
             m_current_value.GetFileSpecAtIndex(i).Dump(&strm);
         }
         strm.IndentLess();
     }
 }
 
 Error
-OptionValueFileSpecList::SetValueFromCString (const char *value, VarSetOperationType op)
+OptionValueFileSpecList::SetValueFromString (llvm::StringRef value, VarSetOperationType op)
 {
     Error error;
-    Args args(value);
+    Args args(value.str().c_str());
     const size_t argc = args.GetArgumentCount();
 
     switch (op)
     {
         case eVarSetOperationClear:
             Clear ();
             NotifyValueChanged();
             break;
switch (op)
             }
             else
             {
                 error.SetErrorString("remove operation takes one or more array index");
             }
             break;
 
         case eVarSetOperationInvalid:
-            error = OptionValue::SetValueFromCString (value, op);
+            error = OptionValue::SetValueFromString (value, op);
             break;
     }
     return error;
 }
 
 lldb::OptionValueSP
 OptionValueFileSpecList::DeepCopy () const
 {
     return OptionValueSP(new OptionValueFileSpecList(*this));
 }
 
 

lldb/trunk/source/Interpreter/OptionValueFormat.cpp

OptionValueFormat::DumpValue (const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask)
     {
         if (dump_mask & eDumpOptionType)
             strm.PutCString (" = ");
         strm.PutCString (FormatManager::GetFormatAsCString (m_current_value));
     }
 }
 
 Error
-OptionValueFormat::SetValueFromCString (const char *value_cstr, VarSetOperationType op)
+OptionValueFormat::SetValueFromString (llvm::StringRef value, VarSetOperationType op)
 {
     Error error;
     switch (op)
     {
     case eVarSetOperationClear:
         Clear();
         NotifyValueChanged();
         break;
         
     case eVarSetOperationReplace:
     case eVarSetOperationAssign:
         {
             Format new_format;
-            error = Args::StringToFormat (value_cstr, new_format, nullptr);
+            error = Args::StringToFormat (value.str().c_str(), new_format, nullptr);
             if (error.Success())
             {
                 m_value_was_set = true;
                 m_current_value = new_format;
                 NotifyValueChanged();
             }
         }
         break;
         
     case eVarSetOperationInsertBefore:
     case eVarSetOperationInsertAfter:
     case eVarSetOperationRemove:
     case eVarSetOperationAppend:
     case eVarSetOperationInvalid:
-        error = OptionValue::SetValueFromCString (value_cstr, op);
+        error = OptionValue::SetValueFromString (value, op);
         break;
     }
     return error;
 }
 
 
 lldb::OptionValueSP
 OptionValueFormat::DeepCopy () const
 {
     return OptionValueSP(new OptionValueFormat(*this));
 }
 

lldb/trunk/source/Interpreter/OptionValueFormatEntity.cpp

OptionValueFormatEntity::DumpValue (const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask)
     {
         if (dump_mask & eDumpOptionType)
             strm.PutCString (" = \"");
         strm << m_current_format.c_str() << '"';
     }
 }
 
 Error
-OptionValueFormatEntity::SetValueFromCString (const char *value_cstr,
+OptionValueFormatEntity::SetValueFromString (llvm::StringRef value_str,
                                       VarSetOperationType op)
 {
     Error error;
     switch (op)
     {
         case eVarSetOperationClear:
             Clear();
             NotifyValueChanged();
             break;
             
         case eVarSetOperationReplace:
         case eVarSetOperationAssign:
             {
                 FormatEntity::Entry entry;
-                llvm::StringRef value_str(value_cstr);
                 error = FormatEntity::Parse(value_str, entry);
                 if (error.Success())
                 {
                     m_current_entry = std::move(entry);
-                    m_current_format = value_cstr;
+                    m_current_format = value_str;
                     m_value_was_set = true;
                     NotifyValueChanged();
                 }
             }
             break;
             
         case eVarSetOperationInsertBefore:
         case eVarSetOperationInsertAfter:
         case eVarSetOperationRemove:
         case eVarSetOperationAppend:
         case eVarSetOperationInvalid:
-            error = OptionValue::SetValueFromCString (value_cstr, op);
+            error = OptionValue::SetValueFromString (value_str, op);
             break;
     }
     return error;
 }
 
 lldb::OptionValueSP
 OptionValueFormatEntity::DeepCopy () const
 {

lldb/trunk/source/Interpreter/OptionValuePathMappings.cpp

OptionValuePathMappings::DumpValue (const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask)
     {
         if (dump_mask & eDumpOptionType)
             strm.Printf (" =%s", (m_path_mappings.GetSize() > 0) ? "\n" : "");
         m_path_mappings.Dump(&strm);
     }
 }
 
 Error
-OptionValuePathMappings::SetValueFromCString (const char *value, VarSetOperationType op)
+OptionValuePathMappings::SetValueFromString (llvm::StringRef value, VarSetOperationType op)
 {
     Error error;
-    Args args(value);
+    Args args(value.str().c_str());
     const size_t argc = args.GetArgumentCount();
 
     switch (op)
     {
         case eVarSetOperationClear:
             Clear ();
             NotifyValueChanged();
             break;
switch (op)
             }
             else
             {
                 error.SetErrorString("remove operation takes one or more array index");
             }
             break;
 
         case eVarSetOperationInvalid:
-            error = OptionValue::SetValueFromCString (value, op);
+            error = OptionValue::SetValueFromString (value, op);
             break;
     }
     return error;
 }
 
 lldb::OptionValueSP
 OptionValuePathMappings::DeepCopy () const
 {
     return OptionValueSP(new OptionValuePathMappings(*this));
 }

lldb/trunk/source/Interpreter/OptionValueProperties.cpp

OptionValueProperties::SetSubValue (const ExecutionContext *exe_ctx,
                                     VarSetOperationType op,
                                     const char *name,
                                     const char *value)
 {
     Error error;
     const bool will_modify = true;
     lldb::OptionValueSP value_sp (GetSubValue (exe_ctx, name, will_modify, error));
     if (value_sp)
-        error = value_sp->SetValueFromCString(value, op);
+        error = value_sp->SetValueFromString(value ? llvm::StringRef(value) : llvm::StringRef(), op);
     else
     {
         if (error.AsCString() == nullptr)
             error.SetErrorStringWithFormat("invalid value path '%s'", name);
     }
     return error;
 }
 
OptionValueProperties::Clear ()
     const size_t num_properties = m_properties.size();
     for (size_t i=0; i<num_properties; ++i)
         m_properties[i].GetValue()->Clear();
     return true;
 }
 
 
 Error
-OptionValueProperties::SetValueFromCString (const char *value, VarSetOperationType op)
+OptionValueProperties::SetValueFromString (llvm::StringRef value, VarSetOperationType op)
 {
     Error error;
     
 //    Args args(value_cstr);
 //    const size_t argc = args.GetArgumentCount();
     switch (op)
     {
         case eVarSetOperationClear:
             Clear ();
             break;
             
         case eVarSetOperationReplace:
         case eVarSetOperationAssign:
         case eVarSetOperationRemove:
         case eVarSetOperationInsertBefore:
         case eVarSetOperationInsertAfter:
         case eVarSetOperationAppend:
         case eVarSetOperationInvalid:
-            error = OptionValue::SetValueFromCString (value, op);
+            error = OptionValue::SetValueFromString (value, op);
             break;
     }
     
     return error;
 }
 
 void
 OptionValueProperties::DumpValue (const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask)

lldb/trunk/source/Interpreter/OptionValueRegex.cpp

if (dump_mask & eDumpOptionValue)
         else
         {
             
         }
     }
 }
 
 Error
-OptionValueRegex::SetValueFromCString (const char *value_cstr,
+OptionValueRegex::SetValueFromString (llvm::StringRef value,
                                         VarSetOperationType op)
 {
     Error error;
     switch (op)
     {
     case eVarSetOperationInvalid:
     case eVarSetOperationInsertBefore:
     case eVarSetOperationInsertAfter:
     case eVarSetOperationRemove:
     case eVarSetOperationAppend:
-        error = OptionValue::SetValueFromCString (value_cstr, op);
+        error = OptionValue::SetValueFromString (value, op);
         break;
 
     case eVarSetOperationClear:
         Clear();
         NotifyValueChanged();
         break;
 
     case eVarSetOperationReplace:
     case eVarSetOperationAssign:
-        if (m_regex.Compile (value_cstr))
+        if (m_regex.Compile (value.str().c_str()))
         {
             m_value_was_set = true;
             NotifyValueChanged();
         }
         else
         {
             char regex_error[1024];
             if (m_regex.GetErrorAsCString(regex_error, sizeof(regex_error)))

lldb/trunk/source/Interpreter/OptionValueSInt64.cpp

//        DumpQualifiedName (strm);
     {
         if (dump_mask & eDumpOptionType)
             strm.PutCString (" = ");
         strm.Printf ("%" PRIi64, m_current_value);
     }
 }
 
 Error
-OptionValueSInt64::SetValueFromCString (const char *value_cstr, VarSetOperationType op)
+OptionValueSInt64::SetValueFromString (llvm::StringRef value_ref, VarSetOperationType op)
 {
-    //printf ("%p: SetValueFromCString (s=\"%s\", op=%i)\n", this, value_cstr, op);
     Error error;
     switch (op)
     {
         case eVarSetOperationClear:
             Clear();
             NotifyValueChanged();
             break;
             
         case eVarSetOperationReplace:
         case eVarSetOperationAssign:
             {
                 bool success = false;
-                std::string value_str = llvm::StringRef(value_cstr).trim().str();
+                std::string value_str = value_ref.trim().str();
                 int64_t value = StringConvert::ToSInt64 (value_str.c_str(), 0, 0, &success);
                 if (success)
                 {
                     if (value >= m_min_value && value <= m_max_value)
                     {
                         m_value_was_set = true;
                         m_current_value = value;
                         NotifyValueChanged();
                     }
                     else
                         error.SetErrorStringWithFormat ("%" PRIi64 " is out of range, valid values must be between %" PRIi64 " and %" PRIi64 ".",
                                                         value,
                                                         m_min_value,
                                                         m_max_value);
                 }
                 else
                 {
-                    error.SetErrorStringWithFormat ("invalid int64_t string value: '%s'", value_cstr);
+                    error.SetErrorStringWithFormat ("invalid int64_t string value: '%s'",
+                            value_ref.str().c_str());
                 }
             }
             break;
             
         case eVarSetOperationInsertBefore:
         case eVarSetOperationInsertAfter:
         case eVarSetOperationRemove:
         case eVarSetOperationAppend:
         case eVarSetOperationInvalid:
-            error = OptionValue::SetValueFromCString (value_cstr, op);
+            error = OptionValue::SetValueFromString (value_ref, op);
             break;
     }
     return error;
 }
 
 lldb::OptionValueSP
 OptionValueSInt64::DeepCopy () const
 {
     return OptionValueSP(new OptionValueSInt64(*this));
 }

lldb/trunk/source/Interpreter/OptionValueString.cpp

if (dump_mask & eDumpOptionValue)
                 else
                     strm.Printf ("\"%s\"", m_current_value.c_str());
             }
         }
     }
 }
 
 Error
-OptionValueString::SetValueFromCString (const char *value_cstr,
+OptionValueString::SetValueFromString (llvm::StringRef value,
                                         VarSetOperationType op)
 {
     Error error;
 
-    std::string value_str_no_quotes;
-    llvm::StringRef trimmed = value_cstr ? llvm::StringRef(value_cstr).trim() : llvm::StringRef();
-    if (trimmed.size() > 0)
+    std::string value_str = value.str();
+    value = value.trim();
+    if (value.size() > 0)
     {
-        switch (trimmed.front())
+        switch (value.front())
         {
         case '"':
         case '\'':
             {
-                if (trimmed.size() <= 1 || trimmed.back() != trimmed.front())
+                if (value.size() <= 1 || value.back() != value.front())
                 {
                     error.SetErrorString("mismatched quotes");
                     return error;
                 }
-                trimmed = trimmed.drop_front().drop_back().str();
+                value = value.drop_front().drop_back().str();
             }
             break;
         }
-        value_str_no_quotes = trimmed.str();
-        value_cstr = value_str_no_quotes.c_str();
+        value_str = value.str();
     }
 
     switch (op)
     {
     case eVarSetOperationInvalid:
     case eVarSetOperationInsertBefore:
     case eVarSetOperationInsertAfter:
     case eVarSetOperationRemove:
         if (m_validator)
         {
-            error = m_validator(value_cstr,m_validator_baton);
+            error = m_validator(value_str.c_str(),m_validator_baton);
             if (error.Fail())
                 return error;
         }
-        error = OptionValue::SetValueFromCString (value_cstr, op);
+        error = OptionValue::SetValueFromString (value, op);
         break;
 
     case eVarSetOperationAppend:
         {
             std::string new_value(m_current_value);
-            if (value_cstr && value_cstr[0])
+            if (value.size() > 0)
             {
                 if (m_options.Test (eOptionEncodeCharacterEscapeSequences))
                 {
                     std::string str;
-                    Args::EncodeEscapeSequences (value_cstr, str);
+                    Args::EncodeEscapeSequences (value_str.c_str(), str);
                     new_value.append(str);
                 }
                 else
-                    new_value.append(value_cstr);
+                    new_value.append(value);
             }
             if (m_validator)
             {
                 error = m_validator(new_value.c_str(),m_validator_baton);
                 if (error.Fail())
                     return error;
             }
             m_current_value.assign(new_value);
             NotifyValueChanged();
         }
         break;
 
     case eVarSetOperationClear:
         Clear ();
         NotifyValueChanged();
         break;
 
     case eVarSetOperationReplace:
     case eVarSetOperationAssign:
         if (m_validator)
         {
-            error = m_validator(value_cstr,m_validator_baton);
+            error = m_validator(value_str.c_str(), m_validator_baton);
             if (error.Fail())
                 return error;
         }
         m_value_was_set = true;
         if (m_options.Test (eOptionEncodeCharacterEscapeSequences))
         {
-            Args::EncodeEscapeSequences (value_cstr, m_current_value);
+            Args::EncodeEscapeSequences (value_str.c_str(), m_current_value);
         }
         else
         {
-            SetCurrentValue (value_cstr);
+            SetCurrentValue (value_str.c_str());
         }
         NotifyValueChanged();
         break;
     }
     return error;
 }
 
 

lldb/trunk/source/Interpreter/OptionValueUInt64.cpp

 
 using namespace lldb;
 using namespace lldb_private;
 
 lldb::OptionValueSP
 OptionValueUInt64::Create (const char *value_cstr, Error &error)
 {
     lldb::OptionValueSP value_sp (new OptionValueUInt64());
-    error = value_sp->SetValueFromCString (value_cstr);
+    error = value_sp->SetValueFromString (value_cstr);
     if (error.Fail())
         value_sp.reset();
     return value_sp;
 }
 
 
 void
 OptionValueUInt64::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 (" = ");
         strm.Printf ("%" PRIu64, m_current_value);
     }
 }
 
 Error
-OptionValueUInt64::SetValueFromCString (const char *value_cstr, VarSetOperationType op)
+OptionValueUInt64::SetValueFromString (llvm::StringRef value_ref, VarSetOperationType op)
 {
     Error error;
     switch (op)
     {
         case eVarSetOperationClear:
             Clear ();
             NotifyValueChanged();
             break;
             
         case eVarSetOperationReplace:
         case eVarSetOperationAssign:
         {
             bool success = false;
-            std::string value_str = llvm::StringRef(value_cstr).trim().str();
+            std::string value_str = value_ref.trim().str();
             uint64_t value = StringConvert::ToUInt64 (value_str.c_str(), 0, 0, &success);
             if (success)
             {
                 m_value_was_set = true;
                 m_current_value = value;
                 NotifyValueChanged();
             }
             else
             {
-                error.SetErrorStringWithFormat ("invalid uint64_t string value: '%s'", value_cstr);
+                error.SetErrorStringWithFormat ("invalid uint64_t string value: '%s'", value_str.c_str());
             }
         }
             break;
             
         case eVarSetOperationInsertBefore:
         case eVarSetOperationInsertAfter:
         case eVarSetOperationRemove:
         case eVarSetOperationAppend:
         case eVarSetOperationInvalid:
-            error = OptionValue::SetValueFromCString (value_cstr, op);
+            error = OptionValue::SetValueFromString (value_ref, op);
             break;
     }
     return error;
 }
 
 lldb::OptionValueSP
 OptionValueUInt64::DeepCopy () const
 {
     return OptionValueSP(new OptionValueUInt64(*this));
 }
 

lldb/trunk/source/Interpreter/OptionValueUUID.cpp

OptionValueUUID::DumpValue (const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask)
     {
         if (dump_mask & eDumpOptionType)
             strm.PutCString (" = ");
         m_uuid.Dump (&strm);
     }
 }
 
 Error
-OptionValueUUID::SetValueFromCString (const char *value_cstr,
+OptionValueUUID::SetValueFromString (llvm::StringRef value,
                                       VarSetOperationType op)
 {
     Error error;
     switch (op)
     {
         case eVarSetOperationClear:
             Clear();
             NotifyValueChanged();
             break;
             
         case eVarSetOperationReplace:
         case eVarSetOperationAssign:
             {
-                if (m_uuid.SetFromCString(value_cstr) == 0)
-                    error.SetErrorStringWithFormat ("invalid uuid string value '%s'", value_cstr);
+                if (m_uuid.SetFromCString(value.str().c_str()) == 0)
+                    error.SetErrorStringWithFormat ("invalid uuid string value '%s'", value.str().c_str());
                 else
                 {
                     m_value_was_set = true;
                     NotifyValueChanged();
                 }
             }
             break;
             
         case eVarSetOperationInsertBefore:
         case eVarSetOperationInsertAfter:
         case eVarSetOperationRemove:
         case eVarSetOperationAppend:
         case eVarSetOperationInvalid:
-            error = OptionValue::SetValueFromCString (value_cstr, op);
+            error = OptionValue::SetValueFromString (value, op);
             break;
     }
     return error;
 }
 
 lldb::OptionValueSP
 OptionValueUUID::DeepCopy () const
 {

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.
         {
             OptionValueEnumeration *enum_value = new OptionValueEnumeration(definition.enum_values, definition.default_uint_value);
             m_value_sp.reset (enum_value);
             if (definition.default_cstr_value)
             {
-                if (enum_value->SetValueFromCString(definition.default_cstr_value).Success())
+                if (enum_value->SetValueFromString(definition.default_cstr_value).Success())
                 {
                     enum_value->SetDefaultValue(enum_value->GetCurrentValue());
                     // Call Clear() since we don't want the value to appear as
-                    // having been set since we called SetValueFromCString() above.
+                    // having been set since we called SetValueFromString() above.
                     // Clear will set the current value to the default and clear
                     // the boolean that says that the value has been set.
                     enum_value->Clear();
                 }
             }
         }
             break;