Home | History | Annotate | Download | only in Interpreter 
      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 }
    187