LLDB  mainline
OptionValueDictionary.cpp
Go to the documentation of this file.
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 
10 
11 #include "llvm/ADT/StringRef.h"
14 #include "lldb/Utility/Args.h"
15 #include "lldb/Utility/State.h"
16 
17 using namespace lldb;
18 using namespace lldb_private;
19 
21  Stream &strm, uint32_t dump_mask) {
22  const Type dict_type = ConvertTypeMaskToType(m_type_mask);
23  if (dump_mask & eDumpOptionType) {
24  if (m_type_mask != eTypeInvalid)
25  strm.Printf("(%s of %ss)", GetTypeAsCString(),
26  GetBuiltinTypeAsCString(dict_type));
27  else
28  strm.Printf("(%s)", GetTypeAsCString());
29  }
30  if (dump_mask & eDumpOptionValue) {
31  const bool one_line = dump_mask & eDumpOptionCommand;
32  if (dump_mask & eDumpOptionType)
33  strm.PutCString(" =");
34 
35  collection::iterator pos, end = m_values.end();
36 
37  if (!one_line)
38  strm.IndentMore();
39 
40  for (pos = m_values.begin(); pos != end; ++pos) {
41  OptionValue *option_value = pos->second.get();
42 
43  if (one_line)
44  strm << ' ';
45  else
46  strm.EOL();
47 
48  strm.Indent(pos->first.GetStringRef());
49 
50  const uint32_t extra_dump_options = m_raw_value_dump ? eDumpOptionRaw : 0;
51  switch (dict_type) {
52  default:
53  case eTypeArray:
54  case eTypeDictionary:
55  case eTypeProperties:
56  case eTypeFileSpecList:
57  case eTypePathMap:
58  strm.PutChar(' ');
59  option_value->DumpValue(exe_ctx, strm, dump_mask | extra_dump_options);
60  break;
61 
62  case eTypeBoolean:
63  case eTypeChar:
64  case eTypeEnum:
65  case eTypeFileLineColumn:
66  case eTypeFileSpec:
67  case eTypeFormat:
68  case eTypeSInt64:
69  case eTypeString:
70  case eTypeUInt64:
71  case eTypeUUID:
72  // No need to show the type for dictionaries of simple items
73  strm.PutCString("=");
74  option_value->DumpValue(exe_ctx, strm,
75  (dump_mask & (~eDumpOptionType)) |
76  extra_dump_options);
77  break;
78  }
79  }
80  if (!one_line)
81  strm.IndentLess();
82  }
83 }
84 
85 size_t OptionValueDictionary::GetArgs(Args &args) const {
86  args.Clear();
87  collection::const_iterator pos, end = m_values.end();
88  for (pos = m_values.begin(); pos != end; ++pos) {
89  StreamString strm;
90  strm.Printf("%s=", pos->first.GetCString());
91  pos->second->DumpValue(nullptr, strm, eDumpOptionValue | eDumpOptionRaw);
92  args.AppendArgument(strm.GetString());
93  }
94  return args.GetArgumentCount();
95 }
96 
97 Status OptionValueDictionary::SetArgs(const Args &args,
99  Status error;
100  const size_t argc = args.GetArgumentCount();
101  switch (op) {
103  Clear();
104  break;
105 
109  if (argc == 0) {
110  error.SetErrorString(
111  "assign operation takes one or more key=value arguments");
112  return error;
113  }
114  for (const auto &entry : args) {
115  if (entry.ref().empty()) {
116  error.SetErrorString("empty argument");
117  return error;
118  }
119  if (!entry.ref().contains('=')) {
120  error.SetErrorString(
121  "assign operation takes one or more key=value arguments");
122  return error;
123  }
124 
125  llvm::StringRef key, value;
126  std::tie(key, value) = entry.ref().split('=');
127  bool key_valid = false;
128  if (key.empty()) {
129  error.SetErrorString("empty dictionary key");
130  return error;
131  }
132 
133  if (key.front() == '[') {
134  // Key name starts with '[', so the key value must be in single or
135  // double quotes like: ['<key>'] ["<key>"]
136  if ((key.size() > 2) && (key.back() == ']')) {
137  // Strip leading '[' and trailing ']'
138  key = key.substr(1, key.size() - 2);
139  const char quote_char = key.front();
140  if ((quote_char == '\'') || (quote_char == '"')) {
141  if ((key.size() > 2) && (key.back() == quote_char)) {
142  // Strip the quotes
143  key = key.substr(1, key.size() - 2);
144  key_valid = true;
145  }
146  } else {
147  // square brackets, no quotes
148  key_valid = true;
149  }
150  }
151  } else {
152  // No square brackets or quotes
153  key_valid = true;
154  }
155  if (!key_valid) {
156  error.SetErrorStringWithFormat(
157  "invalid key \"%s\", the key must be a bare string or "
158  "surrounded by brackets with optional quotes: [<key>] or "
159  "['<key>'] or [\"<key>\"]",
160  key.str().c_str());
161  return error;
162  }
163 
164  lldb::OptionValueSP value_sp(CreateValueFromCStringForTypeMask(
165  value.str().c_str(), m_type_mask, error));
166  if (value_sp) {
167  if (error.Fail())
168  return error;
169  m_value_was_set = true;
170  SetValueForKey(ConstString(key), value_sp, true);
171  } else {
172  error.SetErrorString("dictionaries that can contain multiple types "
173  "must subclass OptionValueArray");
174  }
175  }
176  break;
177 
179  if (argc > 0) {
180  for (size_t i = 0; i < argc; ++i) {
181  ConstString key(args.GetArgumentAtIndex(i));
182  if (!DeleteValueForKey(key)) {
183  error.SetErrorStringWithFormat(
184  "no value found named '%s', aborting remove operation",
185  key.GetCString());
186  break;
187  }
188  }
189  } else {
190  error.SetErrorString("remove operation takes one or more key arguments");
191  }
192  break;
193 
197  error = OptionValue::SetValueFromString(llvm::StringRef(), op);
198  break;
199  }
200  return error;
201 }
202 
203 Status OptionValueDictionary::SetValueFromString(llvm::StringRef value,
204  VarSetOperationType op) {
205  Args args(value.str());
206  Status error = SetArgs(args, op);
207  if (error.Success())
208  NotifyValueChanged();
209  return error;
210 }
211 
212 lldb::OptionValueSP
213 OptionValueDictionary::GetSubValue(const ExecutionContext *exe_ctx,
214  llvm::StringRef name, bool will_modify,
215  Status &error) const {
216  lldb::OptionValueSP value_sp;
217  if (name.empty())
218  return nullptr;
219 
220  llvm::StringRef left, temp;
221  std::tie(left, temp) = name.split('[');
222  if (left.size() == name.size()) {
223  error.SetErrorStringWithFormat("invalid value path '%s', %s values only "
224  "support '[<key>]' subvalues where <key> "
225  "a string value optionally delimited by "
226  "single or double quotes",
227  name.str().c_str(), GetTypeAsCString());
228  return nullptr;
229  }
230  assert(!temp.empty());
231 
232  llvm::StringRef key, quote_char;
233 
234  if (temp[0] == '\"' || temp[0] == '\'') {
235  quote_char = temp.take_front();
236  temp = temp.drop_front();
237  }
238 
239  llvm::StringRef sub_name;
240  std::tie(key, sub_name) = temp.split(']');
241 
242  if (!key.consume_back(quote_char) || key.empty()) {
243  error.SetErrorStringWithFormat("invalid value path '%s', "
244  "key names must be formatted as ['<key>'] where <key> "
245  "is a string that doesn't contain quotes and the quote"
246  " char is optional", name.str().c_str());
247  return nullptr;
248  }
249 
250  value_sp = GetValueForKey(ConstString(key));
251  if (!value_sp) {
252  error.SetErrorStringWithFormat(
253  "dictionary does not contain a value for the key name '%s'",
254  key.str().c_str());
255  return nullptr;
256  }
257 
258  if (sub_name.empty())
259  return value_sp;
260  return value_sp->GetSubValue(exe_ctx, sub_name, will_modify, error);
261 }
262 
263 Status OptionValueDictionary::SetSubValue(const ExecutionContext *exe_ctx,
265  llvm::StringRef name,
266  llvm::StringRef value) {
267  Status error;
268  const bool will_modify = true;
269  lldb::OptionValueSP value_sp(GetSubValue(exe_ctx, name, will_modify, error));
270  if (value_sp)
271  error = value_sp->SetValueFromString(value, op);
272  else {
273  if (error.AsCString() == nullptr)
274  error.SetErrorStringWithFormat("invalid value path '%s'", name.str().c_str());
275  }
276  return error;
277 }
278 
279 lldb::OptionValueSP
280 OptionValueDictionary::GetValueForKey(ConstString key) const {
281  lldb::OptionValueSP value_sp;
282  collection::const_iterator pos = m_values.find(key);
283  if (pos != m_values.end())
284  value_sp = pos->second;
285  return value_sp;
286 }
287 
288 bool OptionValueDictionary::SetValueForKey(ConstString key,
289  const lldb::OptionValueSP &value_sp,
290  bool can_replace) {
291  // Make sure the value_sp object is allowed to contain values of the type
292  // passed in...
293  if (value_sp && (m_type_mask & value_sp->GetTypeAsMask())) {
294  if (!can_replace) {
295  collection::const_iterator pos = m_values.find(key);
296  if (pos != m_values.end())
297  return false;
298  }
299  m_values[key] = value_sp;
300  return true;
301  }
302  return false;
303 }
304 
305 bool OptionValueDictionary::DeleteValueForKey(ConstString key) {
306  collection::iterator pos = m_values.find(key);
307  if (pos != m_values.end()) {
308  m_values.erase(pos);
309  return true;
310  }
311  return false;
312 }
313 
314 OptionValueSP
315 OptionValueDictionary::DeepCopy(const OptionValueSP &new_parent) const {
316  auto copy_sp = OptionValue::DeepCopy(new_parent);
317  // copy_sp->GetAsDictionary cannot be used here as it doesn't work for derived
318  // types that override GetType returning a different value.
319  auto *dict_value_ptr = static_cast<OptionValueDictionary *>(copy_sp.get());
320  lldbassert(dict_value_ptr);
321 
322  for (auto &value : dict_value_ptr->m_values)
323  value.second = value.second->DeepCopy(copy_sp);
324 
325  return copy_sp;
326 }
lldb_private::eVarSetOperationInsertBefore
@ eVarSetOperationInsertBefore
Definition: lldb-private-enumerations.h:85
lldb_private::Stream::IndentLess
void IndentLess(unsigned amount=2)
Decrement the current indentation level.
Definition: Stream.cpp:171
lldb_private::eVarSetOperationReplace
@ eVarSetOperationReplace
Definition: lldb-private-enumerations.h:84
lldb_private::ExecutionContext
Definition: ExecutionContext.h:292
FormatManager.h
lldb_private::Args::AppendArgument
void AppendArgument(llvm::StringRef arg_str, char quote_char='\0')
Appends a new argument to the end of the list argument list.
Definition: Args.cpp:318
lldb_private::Args::Clear
void Clear()
Clear the arguments.
Definition: Args.cpp:374
lldb_private::Stream
Definition: Stream.h:28
lldb_private::Args
Definition: Args.h:33
OptionValueDictionary.h
lldb_private::StreamString::GetString
llvm::StringRef GetString() const
Definition: StreamString.cpp:51
error
static llvm::raw_ostream & error(Stream &strm)
Definition: CommandReturnObject.cpp:17
lldb_private::VarSetOperationType
VarSetOperationType
Settable state variable types.
Definition: lldb-private-enumerations.h:83
lldb_private::Stream::Indent
size_t Indent(llvm::StringRef s="")
Indent the current line in the stream.
Definition: Stream.cpp:130
Args.h
lldb_private::eVarSetOperationAppend
@ eVarSetOperationAppend
Definition: lldb-private-enumerations.h:88
lldb_private::ConstString
Definition: ConstString.h:40
lldb_private::StreamString
Definition: StreamString.h:23
OptionValueString.h
lldb_private::Stream::PutChar
size_t PutChar(char ch)
Definition: Stream.cpp:104
lldbassert
#define lldbassert(x)
Definition: LLDBAssert.h:15
lldb_private::Status
Definition: Status.h:44
lldb_private::OptionValue::Type
Type
Definition: OptionValue.h:26
uint32_t
lldb_private::Stream::IndentMore
void IndentMore(unsigned amount=2)
Increment the current indentation level.
Definition: Stream.cpp:168
lldb_private::Stream::EOL
size_t EOL()
Output and End of Line character to the stream.
Definition: Stream.cpp:128
lldb_private::OptionValue::DumpValue
virtual void DumpValue(const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask)=0
lldb_private::ConstString::GetCString
const char * GetCString() const
Get the string value as a C string.
Definition: ConstString.h:216
lldb_private::eVarSetOperationRemove
@ eVarSetOperationRemove
Definition: lldb-private-enumerations.h:87
lldb_private::Stream::Printf
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:107
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
lldb_private::OptionValueDictionary
Definition: OptionValueDictionary.h:18
State.h
lldb_private::eVarSetOperationInvalid
@ eVarSetOperationInvalid
Definition: lldb-private-enumerations.h:91
lldb_private::Stream::PutCString
size_t PutCString(llvm::StringRef cstr)
Output a C string to the stream.
Definition: Stream.cpp:63
lldb_private::OptionValue
Definition: OptionValue.h:24
lldb_private::Args::GetArgumentCount
size_t GetArgumentCount() const
Gets the number of arguments left in this command object.
Definition: Args.h:118
lldb
Definition: SBAddress.h:15
lldb_private::eVarSetOperationClear
@ eVarSetOperationClear
Definition: lldb-private-enumerations.h:89
DumpValue
static bool DumpValue(Stream &s, const SymbolContext *sc, const ExecutionContext *exe_ctx, const FormatEntity::Entry &entry, ValueObject *valobj)
Definition: FormatEntity.cpp:673
lldb_private::eVarSetOperationInsertAfter
@ eVarSetOperationInsertAfter
Definition: lldb-private-enumerations.h:86
lldb_private::eVarSetOperationAssign
@ eVarSetOperationAssign
Definition: lldb-private-enumerations.h:90