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