1 //===-- OptionValueArray.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/OptionValueArray.h"
11 
12 #include "lldb/Host/StringConvert.h"
13 #include "lldb/Utility/Args.h"
14 #include "lldb/Utility/Stream.h"
15 
16 using namespace lldb;
17 using namespace lldb_private;
18 
DumpValue(const ExecutionContext * exe_ctx,Stream & strm,uint32_t dump_mask)19 void OptionValueArray::DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
20                                  uint32_t dump_mask) {
21   const Type array_element_type = ConvertTypeMaskToType(m_type_mask);
22   if (dump_mask & eDumpOptionType) {
23     if ((GetType() == eTypeArray) && (m_type_mask != eTypeInvalid))
24       strm.Printf("(%s of %ss)", GetTypeAsCString(),
25                   GetBuiltinTypeAsCString(array_element_type));
26     else
27       strm.Printf("(%s)", GetTypeAsCString());
28   }
29   if (dump_mask & eDumpOptionValue) {
30     const bool one_line = dump_mask & eDumpOptionCommand;
31     const uint32_t size = m_values.size();
32     if (dump_mask & eDumpOptionType)
33       strm.Printf(" =%s", (m_values.size() > 0 && !one_line) ? "\n" : "");
34     if (!one_line)
35       strm.IndentMore();
36     for (uint32_t i = 0; i < size; ++i) {
37       if (!one_line) {
38         strm.Indent();
39         strm.Printf("[%u]: ", i);
40       }
41       const uint32_t extra_dump_options = m_raw_value_dump ? eDumpOptionRaw : 0;
42       switch (array_element_type) {
43       default:
44       case eTypeArray:
45       case eTypeDictionary:
46       case eTypeProperties:
47       case eTypeFileSpecList:
48       case eTypePathMap:
49         m_values[i]->DumpValue(exe_ctx, strm, dump_mask | extra_dump_options);
50         break;
51 
52       case eTypeBoolean:
53       case eTypeChar:
54       case eTypeEnum:
55       case eTypeFileSpec:
56       case eTypeFormat:
57       case eTypeSInt64:
58       case eTypeString:
59       case eTypeUInt64:
60       case eTypeUUID:
61         // No need to show the type for dictionaries of simple items
62         m_values[i]->DumpValue(exe_ctx, strm, (dump_mask & (~eDumpOptionType)) |
63                                                   extra_dump_options);
64         break;
65       }
66 
67       if (!one_line) {
68         if (i < (size - 1))
69           strm.EOL();
70       } else {
71         strm << ' ';
72       }
73     }
74     if (!one_line)
75       strm.IndentLess();
76   }
77 }
78 
SetValueFromString(llvm::StringRef value,VarSetOperationType op)79 Status OptionValueArray::SetValueFromString(llvm::StringRef value,
80                                             VarSetOperationType op) {
81   Args args(value.str());
82   Status error = SetArgs(args, op);
83   if (error.Success())
84     NotifyValueChanged();
85   return error;
86 }
87 
88 lldb::OptionValueSP
GetSubValue(const ExecutionContext * exe_ctx,llvm::StringRef name,bool will_modify,Status & error) const89 OptionValueArray::GetSubValue(const ExecutionContext *exe_ctx,
90                               llvm::StringRef name, bool will_modify,
91                               Status &error) const {
92   if (name.empty() || name.front() != '[') {
93     error.SetErrorStringWithFormat(
94       "invalid value path '%s', %s values only support '[<index>]' subvalues "
95       "where <index> is a positive or negative array index",
96       name.str().c_str(), GetTypeAsCString());
97     return nullptr;
98   }
99 
100   name = name.drop_front();
101   llvm::StringRef index, sub_value;
102   std::tie(index, sub_value) = name.split(']');
103   if (index.size() == name.size()) {
104     // Couldn't find a closing bracket
105     return nullptr;
106   }
107 
108   const size_t array_count = m_values.size();
109   int32_t idx = 0;
110   if (index.getAsInteger(0, idx))
111     return nullptr;
112 
113   uint32_t new_idx = UINT32_MAX;
114   if (idx < 0) {
115     // Access from the end of the array if the index is negative
116     new_idx = array_count - idx;
117   } else {
118     // Just a standard index
119     new_idx = idx;
120   }
121 
122   if (new_idx < array_count) {
123     if (m_values[new_idx]) {
124       if (!sub_value.empty())
125         return m_values[new_idx]->GetSubValue(exe_ctx, sub_value,
126                                               will_modify, error);
127       else
128         return m_values[new_idx];
129     }
130   } else {
131     if (array_count == 0)
132       error.SetErrorStringWithFormat(
133           "index %i is not valid for an empty array", idx);
134     else if (idx > 0)
135       error.SetErrorStringWithFormat(
136           "index %i out of range, valid values are 0 through %" PRIu64,
137           idx, (uint64_t)(array_count - 1));
138     else
139       error.SetErrorStringWithFormat("negative index %i out of range, "
140                                       "valid values are -1 through "
141                                       "-%" PRIu64,
142                                       idx, (uint64_t)array_count);
143   }
144   return OptionValueSP();
145 }
146 
GetArgs(Args & args) const147 size_t OptionValueArray::GetArgs(Args &args) const {
148   args.Clear();
149   const uint32_t size = m_values.size();
150   for (uint32_t i = 0; i < size; ++i) {
151     llvm::StringRef string_value = m_values[i]->GetStringValue();
152     if (!string_value.empty())
153       args.AppendArgument(string_value);
154   }
155 
156   return args.GetArgumentCount();
157 }
158 
SetArgs(const Args & args,VarSetOperationType op)159 Status OptionValueArray::SetArgs(const Args &args, VarSetOperationType op) {
160   Status error;
161   const size_t argc = args.GetArgumentCount();
162   switch (op) {
163   case eVarSetOperationInvalid:
164     error.SetErrorString("unsupported operation");
165     break;
166 
167   case eVarSetOperationInsertBefore:
168   case eVarSetOperationInsertAfter:
169     if (argc > 1) {
170       uint32_t idx =
171           StringConvert::ToUInt32(args.GetArgumentAtIndex(0), UINT32_MAX);
172       const uint32_t count = GetSize();
173       if (idx > count) {
174         error.SetErrorStringWithFormat(
175             "invalid insert array index %u, index must be 0 through %u", idx,
176             count);
177       } else {
178         if (op == eVarSetOperationInsertAfter)
179           ++idx;
180         for (size_t i = 1; i < argc; ++i, ++idx) {
181           lldb::OptionValueSP value_sp(CreateValueFromCStringForTypeMask(
182               args.GetArgumentAtIndex(i), m_type_mask, error));
183           if (value_sp) {
184             if (error.Fail())
185               return error;
186             if (idx >= m_values.size())
187               m_values.push_back(value_sp);
188             else
189               m_values.insert(m_values.begin() + idx, value_sp);
190           } else {
191             error.SetErrorString(
192                 "array of complex types must subclass OptionValueArray");
193             return error;
194           }
195         }
196       }
197     } else {
198       error.SetErrorString("insert operation takes an array index followed by "
199                            "one or more values");
200     }
201     break;
202 
203   case eVarSetOperationRemove:
204     if (argc > 0) {
205       const uint32_t size = m_values.size();
206       std::vector<int> remove_indexes;
207       bool all_indexes_valid = true;
208       size_t i;
209       for (i = 0; i < argc; ++i) {
210         const size_t idx =
211             StringConvert::ToSInt32(args.GetArgumentAtIndex(i), INT32_MAX);
212         if (idx >= size) {
213           all_indexes_valid = false;
214           break;
215         } else
216           remove_indexes.push_back(idx);
217       }
218 
219       if (all_indexes_valid) {
220         size_t num_remove_indexes = remove_indexes.size();
221         if (num_remove_indexes) {
222           // Sort and then erase in reverse so indexes are always valid
223           if (num_remove_indexes > 1) {
224             llvm::sort(remove_indexes.begin(), remove_indexes.end());
225             for (std::vector<int>::const_reverse_iterator
226                      pos = remove_indexes.rbegin(),
227                      end = remove_indexes.rend();
228                  pos != end; ++pos) {
229               m_values.erase(m_values.begin() + *pos);
230             }
231           } else {
232             // Only one index
233             m_values.erase(m_values.begin() + remove_indexes.front());
234           }
235         }
236       } else {
237         error.SetErrorStringWithFormat(
238             "invalid array index '%s', aborting remove operation",
239             args.GetArgumentAtIndex(i));
240       }
241     } else {
242       error.SetErrorString("remove operation takes one or more array indices");
243     }
244     break;
245 
246   case eVarSetOperationClear:
247     Clear();
248     break;
249 
250   case eVarSetOperationReplace:
251     if (argc > 1) {
252       uint32_t idx =
253           StringConvert::ToUInt32(args.GetArgumentAtIndex(0), UINT32_MAX);
254       const uint32_t count = GetSize();
255       if (idx > count) {
256         error.SetErrorStringWithFormat(
257             "invalid replace array index %u, index must be 0 through %u", idx,
258             count);
259       } else {
260         for (size_t i = 1; i < argc; ++i, ++idx) {
261           lldb::OptionValueSP value_sp(CreateValueFromCStringForTypeMask(
262               args.GetArgumentAtIndex(i), m_type_mask, error));
263           if (value_sp) {
264             if (error.Fail())
265               return error;
266             if (idx < count)
267               m_values[idx] = value_sp;
268             else
269               m_values.push_back(value_sp);
270           } else {
271             error.SetErrorString(
272                 "array of complex types must subclass OptionValueArray");
273             return error;
274           }
275         }
276       }
277     } else {
278       error.SetErrorString("replace operation takes an array index followed by "
279                            "one or more values");
280     }
281     break;
282 
283   case eVarSetOperationAssign:
284     m_values.clear();
285     // Fall through to append case
286     LLVM_FALLTHROUGH;
287   case eVarSetOperationAppend:
288     for (size_t i = 0; i < argc; ++i) {
289       lldb::OptionValueSP value_sp(CreateValueFromCStringForTypeMask(
290           args.GetArgumentAtIndex(i), m_type_mask, error));
291       if (value_sp) {
292         if (error.Fail())
293           return error;
294         m_value_was_set = true;
295         AppendValue(value_sp);
296       } else {
297         error.SetErrorString(
298             "array of complex types must subclass OptionValueArray");
299       }
300     }
301     break;
302   }
303   return error;
304 }
305 
DeepCopy() const306 lldb::OptionValueSP OptionValueArray::DeepCopy() const {
307   OptionValueArray *copied_array =
308       new OptionValueArray(m_type_mask, m_raw_value_dump);
309   lldb::OptionValueSP copied_value_sp(copied_array);
310   *static_cast<OptionValue *>(copied_array) = *this;
311   copied_array->m_callback = m_callback;
312   const uint32_t size = m_values.size();
313   for (uint32_t i = 0; i < size; ++i) {
314     copied_array->AppendValue(m_values[i]->DeepCopy());
315   }
316   return copied_value_sp;
317 }
318