lldb/source/Interpreter/OptionValueDictionary.cpp

   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 }