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