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

   1 //===-- Property.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/Property.h"
  11
  12 // C Includes
  13 // C++ Includes
  14 // Other libraries and framework includes
  15 // Project includes
  16 #include "lldb/Core/UserSettingsController.h"
  17 #include "lldb/Host/StringConvert.h"
  18 #include "lldb/Interpreter/CommandInterpreter.h"
  19 #include "lldb/Interpreter/OptionValues.h"
  20 #include "lldb/Target/Language.h"
  21
  22 using namespace lldb;
  23 using namespace lldb_private;
  24
  25 Property::Property(const PropertyDefinition &definition)
  26     : m_name(definition.name), m_description(definition.description),
  27       m_value_sp(), m_is_global(definition.global) {
  28   switch (definition.type) {
  29   case OptionValue::eTypeInvalid:
  30   case OptionValue::eTypeProperties:
  31     break;
  32   case OptionValue::eTypeArch:
  33     // "definition.default_uint_value" is not used
  34     // "definition.default_cstr_value" as a string value that represents the
  35     // default string value for the architecture/triple
  36     m_value_sp.reset(new OptionValueArch(definition.default_cstr_value));
  37     break;
  38
  39   case OptionValue::eTypeArgs:
  40     // "definition.default_uint_value" is always a OptionValue::Type
  41     m_value_sp.reset(new OptionValueArgs());
  42     break;
  43
  44   case OptionValue::eTypeArray:
  45     // "definition.default_uint_value" is always a OptionValue::Type
  46     m_value_sp.reset(new OptionValueArray(OptionValue::ConvertTypeToMask(
  47         (OptionValue::Type)definition.default_uint_value)));
  48     break;
  49
  50   case OptionValue::eTypeBoolean:
  51     // "definition.default_uint_value" is the default boolean value if
  52     // "definition.default_cstr_value" is NULL, otherwise interpret
  53     // "definition.default_cstr_value" as a string value that represents the
  54     // default value.
  55     if (definition.default_cstr_value)
  56       m_value_sp.reset(new OptionValueBoolean(Args::StringToBoolean(
  57           llvm::StringRef(definition.default_cstr_value), false, nullptr)));
  58     else
  59       m_value_sp.reset(
  60           new OptionValueBoolean(definition.default_uint_value != 0));
  61     break;
  62
  63   case OptionValue::eTypeChar: {
  64     llvm::StringRef s(definition.default_cstr_value ? definition.default_cstr_value : "");
  65     m_value_sp = std::make_shared<OptionValueChar>(Args::StringToChar(s, '\0', nullptr));
  66     break;
  67   }
  68   case OptionValue::eTypeDictionary:
  69     // "definition.default_uint_value" is always a OptionValue::Type
  70     m_value_sp.reset(new OptionValueDictionary(OptionValue::ConvertTypeToMask(
  71         (OptionValue::Type)definition.default_uint_value)));
  72     break;
  73
  74   case OptionValue::eTypeEnum:
  75     // "definition.default_uint_value" is the default enumeration value if
  76     // "definition.default_cstr_value" is NULL, otherwise interpret
  77     // "definition.default_cstr_value" as a string value that represents the
  78     // default
  79     // value.
  80     {
  81       OptionValueEnumeration *enum_value = new OptionValueEnumeration(
  82           definition.enum_values, definition.default_uint_value);
  83       m_value_sp.reset(enum_value);
  84       if (definition.default_cstr_value) {
  85         if (enum_value
  86                 ->SetValueFromString(
  87                     llvm::StringRef(definition.default_cstr_value))
  88                 .Success()) {
  89           enum_value->SetDefaultValue(enum_value->GetCurrentValue());
  90           // Call Clear() since we don't want the value to appear as
  91           // having been set since we called SetValueFromString() above.
  92           // Clear will set the current value to the default and clear
  93           // the boolean that says that the value has been set.
  94           enum_value->Clear();
  95         }
  96       }
  97     }
  98     break;
  99
 100   case OptionValue::eTypeFileSpec: {
 101     // "definition.default_uint_value" represents if the
 102     // "definition.default_cstr_value" should
 103     // be resolved or not
 104     const bool resolve = definition.default_uint_value != 0;
 105     m_value_sp.reset(new OptionValueFileSpec(
 106         FileSpec(definition.default_cstr_value, resolve), resolve));
 107     break;
 108   }
 109
 110   case OptionValue::eTypeFileSpecList:
 111     // "definition.default_uint_value" is not used for a
 112     // OptionValue::eTypeFileSpecList
 113     m_value_sp.reset(new OptionValueFileSpecList());
 114     break;
 115
 116   case OptionValue::eTypeFormat:
 117     // "definition.default_uint_value" is the default format enumeration value
 118     // if
 119     // "definition.default_cstr_value" is NULL, otherwise interpret
 120     // "definition.default_cstr_value" as a string value that represents the
 121     // default
 122     // value.
 123     {
 124       Format new_format = eFormatInvalid;
 125       if (definition.default_cstr_value)
 126         Args::StringToFormat(definition.default_cstr_value, new_format,
 127                              nullptr);
 128       else
 129         new_format = (Format)definition.default_uint_value;
 130       m_value_sp.reset(new OptionValueFormat(new_format));
 131     }
 132     break;
 133
 134   case OptionValue::eTypeLanguage:
 135     // "definition.default_uint_value" is the default language enumeration value
 136     // if
 137     // "definition.default_cstr_value" is NULL, otherwise interpret
 138     // "definition.default_cstr_value" as a string value that represents the
 139     // default
 140     // value.
 141     {
 142       LanguageType new_lang = eLanguageTypeUnknown;
 143       if (definition.default_cstr_value)
 144         Language::GetLanguageTypeFromString(
 145             llvm::StringRef(definition.default_cstr_value));
 146       else
 147         new_lang = (LanguageType)definition.default_uint_value;
 148       m_value_sp.reset(new OptionValueLanguage(new_lang));
 149     }
 150     break;
 151
 152   case OptionValue::eTypeFormatEntity:
 153     // "definition.default_cstr_value" as a string value that represents the
 154     // default
 155     m_value_sp.reset(
 156         new OptionValueFormatEntity(definition.default_cstr_value));
 157     break;
 158
 159   case OptionValue::eTypePathMap:
 160     // "definition.default_uint_value" tells us if notifications should occur
 161     // for
 162     // path mappings
 163     m_value_sp.reset(
 164         new OptionValuePathMappings(definition.default_uint_value != 0));
 165     break;
 166
 167   case OptionValue::eTypeRegex:
 168     // "definition.default_uint_value" is used to the regular expression flags
 169     // "definition.default_cstr_value" the default regular expression value
 170     // value.
 171     m_value_sp.reset(new OptionValueRegex(definition.default_cstr_value));
 172     break;
 173
 174   case OptionValue::eTypeSInt64:
 175     // "definition.default_uint_value" is the default integer value if
 176     // "definition.default_cstr_value" is NULL, otherwise interpret
 177     // "definition.default_cstr_value" as a string value that represents the
 178     // default
 179     // value.
 180     m_value_sp.reset(new OptionValueSInt64(
 181         definition.default_cstr_value
 182             ? StringConvert::ToSInt64(definition.default_cstr_value)
 183             : definition.default_uint_value));
 184     break;
 185
 186   case OptionValue::eTypeUInt64:
 187     // "definition.default_uint_value" is the default unsigned integer value if
 188     // "definition.default_cstr_value" is NULL, otherwise interpret
 189     // "definition.default_cstr_value" as a string value that represents the
 190     // default
 191     // value.
 192     m_value_sp.reset(new OptionValueUInt64(
 193         definition.default_cstr_value
 194             ? StringConvert::ToUInt64(definition.default_cstr_value)
 195             : definition.default_uint_value));
 196     break;
 197
 198   case OptionValue::eTypeUUID:
 199     // "definition.default_uint_value" is not used for a OptionValue::eTypeUUID
 200     // "definition.default_cstr_value" can contain a default UUID value
 201     {
 202       UUID uuid;
 203       if (definition.default_cstr_value)
 204         uuid.SetFromCString(definition.default_cstr_value);
 205       m_value_sp.reset(new OptionValueUUID(uuid));
 206     }
 207     break;
 208
 209   case OptionValue::eTypeString:
 210     // "definition.default_uint_value" can contain the string option flags OR'ed
 211     // together
 212     // "definition.default_cstr_value" can contain a default string value
 213     {
 214       OptionValueString *string_value =
 215           new OptionValueString(definition.default_cstr_value);
 216       if (definition.default_uint_value != 0)
 217         string_value->GetOptions().Reset(definition.default_uint_value);
 218       m_value_sp.reset(string_value);
 219     }
 220     break;
 221   }
 222 }
 223
 224 Property::Property(const ConstString &name, const ConstString &desc,
 225                    bool is_global, const lldb::OptionValueSP &value_sp)
 226     : m_name(name), m_description(desc), m_value_sp(value_sp),
 227       m_is_global(is_global) {}
 228
 229 bool Property::DumpQualifiedName(Stream &strm) const {
 230   if (m_name) {
 231     if (m_value_sp->DumpQualifiedName(strm))
 232       strm.PutChar('.');
 233     strm << m_name;
 234     return true;
 235   }
 236   return false;
 237 }
 238
 239 void Property::Dump(const ExecutionContext *exe_ctx, Stream &strm,
 240                     uint32_t dump_mask) const {
 241   if (m_value_sp) {
 242     const bool dump_desc = dump_mask & OptionValue::eDumpOptionDescription;
 243     const bool transparent = m_value_sp->ValueIsTransparent();
 244     if (dump_desc || !transparent) {
 245       if ((dump_mask & OptionValue::eDumpOptionName) && m_name) {
 246         DumpQualifiedName(strm);
 247         if (dump_mask & ~OptionValue::eDumpOptionName)
 248           strm.PutChar(' ');
 249       }
 250     }
 251     if (dump_desc) {
 252       llvm::StringRef desc = GetDescription();
 253       if (!desc.empty())
 254         strm << "-- " << desc;
 255
 256       if (transparent && (dump_mask == (OptionValue::eDumpOptionName |
 257                                         OptionValue::eDumpOptionDescription)))
 258         strm.EOL();
 259     }
 260     m_value_sp->DumpValue(exe_ctx, strm, dump_mask);
 261   }
 262 }
 263
 264 void Property::DumpDescription(CommandInterpreter &interpreter, Stream &strm,
 265                                uint32_t output_width,
 266                                bool display_qualified_name) const {
 267   if (!m_value_sp)
 268     return;
 269   llvm::StringRef desc = GetDescription();
 270
 271   if (desc.empty())
 272     return;
 273
 274   StreamString qualified_name;
 275   const OptionValueProperties *sub_properties = m_value_sp->GetAsProperties();
 276   if (sub_properties) {
 277     strm.EOL();
 278
 279     if (m_value_sp->DumpQualifiedName(qualified_name))
 280       strm.Printf("'%s' variables:\n\n", qualified_name.GetData());
 281     sub_properties->DumpAllDescriptions(interpreter, strm);
 282   } else {
 283     if (display_qualified_name) {
 284       StreamString qualified_name;
 285       DumpQualifiedName(qualified_name);
 286       interpreter.OutputFormattedHelpText(strm, qualified_name.GetString(),
 287                                           "--", desc, output_width);
 288     } else {
 289       interpreter.OutputFormattedHelpText(strm, m_name.GetStringRef(), "--",
 290                                           desc, output_width);
 291     }
 292   }
 293 }
 294
 295 void Property::SetValueChangedCallback(OptionValueChangedCallback callback,
 296                                        void *baton) {
 297   if (m_value_sp)
 298     m_value_sp->SetValueChangedCallback(callback, baton);
 299 }