contrib/llvm/tools/lldb/source/Interpreter/OptionValueString.cpp

   1 //===-- OptionValueString.cpp ------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "lldb/Interpreter/OptionValueString.h"
  11
  12 // C Includes
  13 // C++ Includes
  14 // Other libraries and framework includes
  15 // Project includes
  16 #include "lldb/Core/Stream.h"
  17 #include "lldb/Interpreter/Args.h"
  18
  19 using namespace lldb;
  20 using namespace lldb_private;
  21
  22 void
  23 OptionValueString::DumpValue (const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask)
  24 {
  25     if (dump_mask & eDumpOptionType)
  26         strm.Printf ("(%s)", GetTypeAsCString ());
  27     if (dump_mask & eDumpOptionValue)
  28     {
  29         if (dump_mask & eDumpOptionType)
  30             strm.PutCString (" = ");
  31         if (!m_current_value.empty() || m_value_was_set)
  32         {
  33             if (m_options.Test (eOptionEncodeCharacterEscapeSequences))
  34             {
  35                 std::string expanded_escape_value;
  36                 Args::ExpandEscapedCharacters(m_current_value.c_str(), expanded_escape_value);
  37                 if (dump_mask & eDumpOptionRaw)
  38                     strm.Printf ("%s", expanded_escape_value.c_str());
  39                 else
  40                     strm.Printf ("\"%s\"", expanded_escape_value.c_str());
  41             }
  42             else
  43             {
  44                 if (dump_mask & eDumpOptionRaw)
  45                     strm.Printf ("%s", m_current_value.c_str());
  46                 else
  47                     strm.Printf ("\"%s\"", m_current_value.c_str());
  48             }
  49         }
  50     }
  51 }
  52
  53 Error
  54 OptionValueString::SetValueFromCString (const char *value_cstr,
  55                                         VarSetOperationType op)
  56 {
  57     Error error;
  58
  59     std::string value_str_no_quotes;
  60     if (value_cstr)
  61     {
  62         switch (value_cstr[0])
  63         {
  64         case '"':
  65         case '\'':
  66             {
  67                 size_t len = strlen(value_cstr);
  68                 if (len <= 1 || value_cstr[len-1] != value_cstr[0])
  69                 {
  70                     error.SetErrorString("mismatched quotes");
  71                     return error;
  72                 }
  73                 value_str_no_quotes.assign (value_cstr + 1, len - 2);
  74                 value_cstr = value_str_no_quotes.c_str();
  75             }
  76             break;
  77         }
  78     }
  79
  80     switch (op)
  81     {
  82     case eVarSetOperationInvalid:
  83     case eVarSetOperationInsertBefore:
  84     case eVarSetOperationInsertAfter:
  85     case eVarSetOperationRemove:
  86         if (m_validator)
  87         {
  88             error = m_validator(value_cstr,m_validator_baton);
  89             if (error.Fail())
  90                 return error;
  91         }
  92         error = OptionValue::SetValueFromCString (value_cstr, op);
  93         break;
  94
  95     case eVarSetOperationAppend:
  96         {
  97         std::string new_value(m_current_value);
  98         if (value_cstr && value_cstr[0])
  99         {
 100             if (m_options.Test (eOptionEncodeCharacterEscapeSequences))
 101             {
 102                 std::string str;
 103                 Args::EncodeEscapeSequences (value_cstr, str);
 104                 new_value.append(str);
 105             }
 106             else
 107                 new_value.append(value_cstr);
 108         }
 109         if (m_validator)
 110         {
 111             error = m_validator(new_value.c_str(),m_validator_baton);
 112             if (error.Fail())
 113                 return error;
 114         }
 115         m_current_value.assign(new_value);
 116         }
 117         break;
 118
 119     case eVarSetOperationClear:
 120         Clear ();
 121         break;
 122
 123     case eVarSetOperationReplace:
 124     case eVarSetOperationAssign:
 125         if (m_validator)
 126         {
 127             error = m_validator(value_cstr,m_validator_baton);
 128             if (error.Fail())
 129                 return error;
 130         }
 131         m_value_was_set = true;
 132         if (m_options.Test (eOptionEncodeCharacterEscapeSequences))
 133         {
 134             Args::EncodeEscapeSequences (value_cstr, m_current_value);
 135         }
 136         else
 137         {
 138             SetCurrentValue (value_cstr);
 139         }
 140         break;
 141     }
 142     return error;
 143 }
 144
 145
 146 lldb::OptionValueSP
 147 OptionValueString::DeepCopy () const
 148 {
 149     return OptionValueSP(new OptionValueString(*this));
 150 }
 151
 152 Error
 153 OptionValueString::SetCurrentValue (const char *value)
 154 {
 155     if (m_validator)
 156     {
 157         Error error(m_validator(value,m_validator_baton));
 158         if (error.Fail())
 159             return error;
 160     }
 161     if (value && value[0])
 162         m_current_value.assign (value);
 163     else
 164         m_current_value.clear();
 165     return Error();
 166 }
 167
 168 Error
 169 OptionValueString::AppendToCurrentValue (const char *value)
 170 {
 171     if (value && value[0])
 172     {
 173         if (m_validator)
 174         {
 175             std::string new_value(m_current_value);
 176             new_value.append(value);
 177             Error error(m_validator(value,m_validator_baton));
 178             if (error.Fail())
 179                 return error;
 180             m_current_value.assign(new_value);
 181         }
 182         else
 183             m_current_value.append (value);
 184     }
 185     return Error();
 186 }