1 //===-- OptionValueDictionary.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/Interpreter/OptionValueDictionary.h"
11 
12 #include "llvm/ADT/StringRef.h"
13 #include "lldb/DataFormatters/FormatManager.h"
14 #include "lldb/Interpreter/OptionValueString.h"
15 #include "lldb/Utility/Args.h"
16 #include "lldb/Utility/State.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.GetCString());
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 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 
GetArgs(Args & args) const85 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 
SetArgs(const Args & args,VarSetOperationType op)97 Status OptionValueDictionary::SetArgs(const Args &args,
98                                       VarSetOperationType op) {
99   Status error;
100   const size_t argc = args.GetArgumentCount();
101   switch (op) {
102   case eVarSetOperationClear:
103     Clear();
104     break;
105 
106   case eVarSetOperationAppend:
107   case eVarSetOperationReplace:
108   case eVarSetOperationAssign:
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 
178   case eVarSetOperationRemove:
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 
194   case eVarSetOperationInsertBefore:
195   case eVarSetOperationInsertAfter:
196   case eVarSetOperationInvalid:
197     error = OptionValue::SetValueFromString(llvm::StringRef(), op);
198     break;
199   }
200   return error;
201 }
202 
SetValueFromString(llvm::StringRef value,VarSetOperationType op)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
GetSubValue(const ExecutionContext * exe_ctx,llvm::StringRef name,bool will_modify,Status & error) const213 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 
SetSubValue(const ExecutionContext * exe_ctx,VarSetOperationType op,llvm::StringRef name,llvm::StringRef value)263 Status OptionValueDictionary::SetSubValue(const ExecutionContext *exe_ctx,
264                                           VarSetOperationType op,
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
GetValueForKey(const ConstString & key) const280 OptionValueDictionary::GetValueForKey(const 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 
SetValueForKey(const ConstString & key,const lldb::OptionValueSP & value_sp,bool can_replace)288 bool OptionValueDictionary::SetValueForKey(const 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 
DeleteValueForKey(const ConstString & key)305 bool OptionValueDictionary::DeleteValueForKey(const 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 
DeepCopy() const314 lldb::OptionValueSP OptionValueDictionary::DeepCopy() const {
315   OptionValueDictionary *copied_dict =
316       new OptionValueDictionary(m_type_mask, m_raw_value_dump);
317   lldb::OptionValueSP copied_value_sp(copied_dict);
318   collection::const_iterator pos, end = m_values.end();
319   for (pos = m_values.begin(); pos != end; ++pos) {
320     StreamString strm;
321     strm.Printf("%s=", pos->first.GetCString());
322     copied_dict->SetValueForKey(pos->first, pos->second->DeepCopy(), true);
323   }
324   return copied_value_sp;
325 }
326