lldb/source/Interpreter/OptionValueArray.cpp

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