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