1 //===-- OptionValueDictionary.cpp -----------------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "lldb/Interpreter/OptionValueDictionary.h" 10 11 #include "lldb/DataFormatters/FormatManager.h" 12 #include "lldb/Interpreter/OptionValueEnumeration.h" 13 #include "lldb/Interpreter/OptionValueString.h" 14 #include "lldb/Utility/Args.h" 15 #include "lldb/Utility/State.h" 16 #include "llvm/ADT/StringRef.h" 17 18 using namespace lldb; 19 using namespace lldb_private; 20 21 void OptionValueDictionary::DumpValue(const ExecutionContext *exe_ctx, 22 Stream &strm, uint32_t dump_mask) { 23 const Type dict_type = ConvertTypeMaskToType(m_type_mask); 24 if (dump_mask & eDumpOptionType) { 25 if (m_type_mask != eTypeInvalid) 26 strm.Printf("(%s of %ss)", GetTypeAsCString(), 27 GetBuiltinTypeAsCString(dict_type)); 28 else 29 strm.Printf("(%s)", GetTypeAsCString()); 30 } 31 if (dump_mask & eDumpOptionValue) { 32 const bool one_line = dump_mask & eDumpOptionCommand; 33 if (dump_mask & eDumpOptionType) 34 strm.PutCString(" ="); 35 36 if (!one_line) 37 strm.IndentMore(); 38 39 // m_values is not guaranteed to be sorted alphabetically, so for 40 // consistentcy we will sort them here before dumping 41 std::map<llvm::StringRef, OptionValue *> sorted_values; 42 for (const auto &value : m_values) { 43 sorted_values[value.first()] = value.second.get(); 44 } 45 for (const auto &value : sorted_values) { 46 OptionValue *option_value = value.second; 47 48 if (one_line) 49 strm << ' '; 50 else 51 strm.EOL(); 52 53 strm.Indent(value.first); 54 55 const uint32_t extra_dump_options = m_raw_value_dump ? eDumpOptionRaw : 0; 56 switch (dict_type) { 57 default: 58 case eTypeArray: 59 case eTypeDictionary: 60 case eTypeProperties: 61 case eTypeFileSpecList: 62 case eTypePathMap: 63 strm.PutChar(' '); 64 option_value->DumpValue(exe_ctx, strm, dump_mask | extra_dump_options); 65 break; 66 67 case eTypeBoolean: 68 case eTypeChar: 69 case eTypeEnum: 70 case eTypeFileLineColumn: 71 case eTypeFileSpec: 72 case eTypeFormat: 73 case eTypeSInt64: 74 case eTypeString: 75 case eTypeUInt64: 76 case eTypeUUID: 77 // No need to show the type for dictionaries of simple items 78 strm.PutCString("="); 79 option_value->DumpValue(exe_ctx, strm, 80 (dump_mask & (~eDumpOptionType)) | 81 extra_dump_options); 82 break; 83 } 84 } 85 if (!one_line) 86 strm.IndentLess(); 87 } 88 } 89 90 llvm::json::Value 91 OptionValueDictionary::ToJSON(const ExecutionContext *exe_ctx) { 92 llvm::json::Object dict; 93 for (const auto &value : m_values) { 94 dict.try_emplace(value.first(), value.second->ToJSON(exe_ctx)); 95 } 96 return dict; 97 } 98 99 size_t OptionValueDictionary::GetArgs(Args &args) const { 100 args.Clear(); 101 for (const auto &value : m_values) { 102 StreamString strm; 103 strm.Printf("%s=", value.first().data()); 104 value.second->DumpValue(nullptr, strm, eDumpOptionValue | eDumpOptionRaw); 105 args.AppendArgument(strm.GetString()); 106 } 107 return args.GetArgumentCount(); 108 } 109 110 Status OptionValueDictionary::SetArgs(const Args &args, 111 VarSetOperationType op) { 112 Status error; 113 const size_t argc = args.GetArgumentCount(); 114 switch (op) { 115 case eVarSetOperationClear: 116 Clear(); 117 break; 118 119 case eVarSetOperationAppend: 120 case eVarSetOperationReplace: 121 case eVarSetOperationAssign: 122 if (argc == 0) { 123 error = Status::FromErrorString( 124 "assign operation takes one or more key=value arguments"); 125 return error; 126 } 127 for (const auto &entry : args) { 128 if (entry.ref().empty()) { 129 error = Status::FromErrorString("empty argument"); 130 return error; 131 } 132 if (!entry.ref().contains('=')) { 133 error = Status::FromErrorString( 134 "assign operation takes one or more key=value arguments"); 135 return error; 136 } 137 138 llvm::StringRef key, value; 139 std::tie(key, value) = entry.ref().split('='); 140 bool key_valid = false; 141 if (key.empty()) { 142 error = Status::FromErrorString("empty dictionary key"); 143 return error; 144 } 145 146 if (key.front() == '[') { 147 // Key name starts with '[', so the key value must be in single or 148 // double quotes like: ['<key>'] ["<key>"] 149 if ((key.size() > 2) && (key.back() == ']')) { 150 // Strip leading '[' and trailing ']' 151 key = key.substr(1, key.size() - 2); 152 const char quote_char = key.front(); 153 if ((quote_char == '\'') || (quote_char == '"')) { 154 if ((key.size() > 2) && (key.back() == quote_char)) { 155 // Strip the quotes 156 key = key.substr(1, key.size() - 2); 157 key_valid = true; 158 } 159 } else { 160 // square brackets, no quotes 161 key_valid = true; 162 } 163 } 164 } else { 165 // No square brackets or quotes 166 key_valid = true; 167 } 168 if (!key_valid) { 169 error = Status::FromErrorStringWithFormat( 170 "invalid key \"%s\", the key must be a bare string or " 171 "surrounded by brackets with optional quotes: [<key>] or " 172 "['<key>'] or [\"<key>\"]", 173 key.str().c_str()); 174 return error; 175 } 176 177 if (m_type_mask == 1u << eTypeEnum) { 178 auto enum_value = 179 std::make_shared<OptionValueEnumeration>(m_enum_values, 0); 180 error = enum_value->SetValueFromString(value); 181 if (error.Fail()) 182 return error; 183 m_value_was_set = true; 184 SetValueForKey(key, enum_value, true); 185 } else { 186 lldb::OptionValueSP value_sp(CreateValueFromCStringForTypeMask( 187 value.str().c_str(), m_type_mask, error)); 188 if (value_sp) { 189 if (error.Fail()) 190 return error; 191 m_value_was_set = true; 192 SetValueForKey(key, value_sp, true); 193 } else { 194 error = Status::FromErrorString( 195 "dictionaries that can contain multiple types " 196 "must subclass OptionValueArray"); 197 } 198 } 199 } 200 break; 201 202 case eVarSetOperationRemove: 203 if (argc > 0) { 204 for (size_t i = 0; i < argc; ++i) { 205 llvm::StringRef key(args.GetArgumentAtIndex(i)); 206 if (!DeleteValueForKey(key)) { 207 error = Status::FromErrorStringWithFormat( 208 "no value found named '%s', aborting remove operation", 209 key.data()); 210 break; 211 } 212 } 213 } else { 214 error = Status::FromErrorString( 215 "remove operation takes one or more key arguments"); 216 } 217 break; 218 219 case eVarSetOperationInsertBefore: 220 case eVarSetOperationInsertAfter: 221 case eVarSetOperationInvalid: 222 error = OptionValue::SetValueFromString(llvm::StringRef(), op); 223 break; 224 } 225 return error; 226 } 227 228 Status OptionValueDictionary::SetValueFromString(llvm::StringRef value, 229 VarSetOperationType op) { 230 Args args(value.str()); 231 Status error = SetArgs(args, op); 232 if (error.Success()) 233 NotifyValueChanged(); 234 return error; 235 } 236 237 lldb::OptionValueSP 238 OptionValueDictionary::GetSubValue(const ExecutionContext *exe_ctx, 239 llvm::StringRef name, Status &error) const { 240 lldb::OptionValueSP value_sp; 241 if (name.empty()) 242 return nullptr; 243 244 llvm::StringRef left, temp; 245 std::tie(left, temp) = name.split('['); 246 if (left.size() == name.size()) { 247 error = Status::FromErrorStringWithFormat( 248 "invalid value path '%s', %s values only " 249 "support '[<key>]' subvalues where <key> " 250 "a string value optionally delimited by " 251 "single or double quotes", 252 name.str().c_str(), GetTypeAsCString()); 253 return nullptr; 254 } 255 assert(!temp.empty()); 256 257 llvm::StringRef key, quote_char; 258 259 if (temp[0] == '\"' || temp[0] == '\'') { 260 quote_char = temp.take_front(); 261 temp = temp.drop_front(); 262 } 263 264 llvm::StringRef sub_name; 265 std::tie(key, sub_name) = temp.split(']'); 266 267 if (!key.consume_back(quote_char) || key.empty()) { 268 error = Status::FromErrorStringWithFormat( 269 "invalid value path '%s', " 270 "key names must be formatted as ['<key>'] where <key> " 271 "is a string that doesn't contain quotes and the quote" 272 " char is optional", 273 name.str().c_str()); 274 return nullptr; 275 } 276 277 value_sp = GetValueForKey(key); 278 if (!value_sp) { 279 error = Status::FromErrorStringWithFormat( 280 "dictionary does not contain a value for the key name '%s'", 281 key.str().c_str()); 282 return nullptr; 283 } 284 285 if (sub_name.empty()) 286 return value_sp; 287 return value_sp->GetSubValue(exe_ctx, sub_name, error); 288 } 289 290 Status OptionValueDictionary::SetSubValue(const ExecutionContext *exe_ctx, 291 VarSetOperationType op, 292 llvm::StringRef name, 293 llvm::StringRef value) { 294 Status error; 295 lldb::OptionValueSP value_sp(GetSubValue(exe_ctx, name, error)); 296 if (value_sp) 297 error = value_sp->SetValueFromString(value, op); 298 else { 299 if (error.AsCString() == nullptr) 300 error = Status::FromErrorStringWithFormat("invalid value path '%s'", 301 name.str().c_str()); 302 } 303 return error; 304 } 305 306 lldb::OptionValueSP 307 OptionValueDictionary::GetValueForKey(llvm::StringRef key) const { 308 lldb::OptionValueSP value_sp; 309 auto pos = m_values.find(key); 310 if (pos != m_values.end()) 311 value_sp = pos->second; 312 return value_sp; 313 } 314 315 bool OptionValueDictionary::SetValueForKey(llvm::StringRef key, 316 const lldb::OptionValueSP &value_sp, 317 bool can_replace) { 318 // Make sure the value_sp object is allowed to contain values of the type 319 // passed in... 320 if (value_sp && (m_type_mask & value_sp->GetTypeAsMask())) { 321 if (!can_replace) { 322 auto pos = m_values.find(key); 323 if (pos != m_values.end()) 324 return false; 325 } 326 m_values[key] = value_sp; 327 return true; 328 } 329 return false; 330 } 331 332 bool OptionValueDictionary::DeleteValueForKey(llvm::StringRef key) { 333 auto pos = m_values.find(key); 334 if (pos != m_values.end()) { 335 m_values.erase(pos); 336 return true; 337 } 338 return false; 339 } 340 341 OptionValueSP 342 OptionValueDictionary::DeepCopy(const OptionValueSP &new_parent) const { 343 auto copy_sp = OptionValue::DeepCopy(new_parent); 344 // copy_sp->GetAsDictionary cannot be used here as it doesn't work for derived 345 // types that override GetType returning a different value. 346 auto *dict_value_ptr = static_cast<OptionValueDictionary *>(copy_sp.get()); 347 lldbassert(dict_value_ptr); 348 349 for (auto &value : dict_value_ptr->m_values) 350 value.second = value.second->DeepCopy(copy_sp); 351 352 return copy_sp; 353 } 354