lldb/source/Utility/StringList.cpp

   1 //===-- StringList.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/Utility/StringList.h"
  10
  11 #include "lldb/Utility/Log.h"
  12 #include "lldb/Utility/Stream.h"
  13 #include "lldb/Utility/StreamString.h"
  14 #include "llvm/ADT/ArrayRef.h"
  15
  16 #include <algorithm>
  17 #include <cstdint>
  18 #include <cstring>
  19
  20 using namespace lldb_private;
  21
  22 StringList::StringList() : m_strings() {}
  23
  24 StringList::StringList(const char *str) : m_strings() {
  25   if (str)
  26     m_strings.push_back(str);
  27 }
  28
  29 StringList::StringList(const char **strv, int strc) : m_strings() {
  30   for (int i = 0; i < strc; ++i) {
  31     if (strv[i])
  32       m_strings.push_back(strv[i]);
  33   }
  34 }
  35
  36 StringList::~StringList() = default;
  37
  38 void StringList::AppendString(const char *str) {
  39   if (str)
  40     m_strings.push_back(str);
  41 }
  42
  43 void StringList::AppendString(const std::string &s) { m_strings.push_back(s); }
  44
  45 void StringList::AppendString(std::string &&s) {
  46   m_strings.push_back(std::move(s));
  47 }
  48
  49 void StringList::AppendString(const char *str, size_t str_len) {
  50   if (str)
  51     m_strings.push_back(std::string(str, str_len));
  52 }
  53
  54 void StringList::AppendString(llvm::StringRef str) {
  55   m_strings.push_back(str.str());
  56 }
  57
  58 void StringList::AppendString(const llvm::Twine &str) {
  59   m_strings.push_back(str.str());
  60 }
  61
  62 void StringList::AppendList(const char **strv, int strc) {
  63   for (int i = 0; i < strc; ++i) {
  64     if (strv[i])
  65       m_strings.push_back(strv[i]);
  66   }
  67 }
  68
  69 void StringList::AppendList(StringList strings) {
  70   m_strings.reserve(m_strings.size() + strings.GetSize());
  71   m_strings.insert(m_strings.end(), strings.begin(), strings.end());
  72 }
  73
  74 size_t StringList::GetSize() const { return m_strings.size(); }
  75
  76 size_t StringList::GetMaxStringLength() const {
  77   size_t max_length = 0;
  78   for (const auto &s : m_strings) {
  79     const size_t len = s.size();
  80     if (max_length < len)
  81       max_length = len;
  82   }
  83   return max_length;
  84 }
  85
  86 const char *StringList::GetStringAtIndex(size_t idx) const {
  87   if (idx < m_strings.size())
  88     return m_strings[idx].c_str();
  89   return nullptr;
  90 }
  91
  92 void StringList::Join(const char *separator, Stream &strm) {
  93   size_t size = GetSize();
  94
  95   if (size == 0)
  96     return;
  97
  98   for (uint32_t i = 0; i < size; ++i) {
  99     if (i > 0)
 100       strm.PutCString(separator);
 101     strm.PutCString(GetStringAtIndex(i));
 102   }
 103 }
 104
 105 void StringList::Clear() { m_strings.clear(); }
 106
 107 std::string StringList::LongestCommonPrefix() {
 108   if (m_strings.empty())
 109     return {};
 110
 111   auto args = llvm::ArrayRef(m_strings);
 112   llvm::StringRef prefix = args.front();
 113   for (auto arg : args.drop_front()) {
 114     size_t count = 0;
 115     for (count = 0; count < std::min(prefix.size(), arg.size()); ++count) {
 116       if (prefix[count] != arg[count])
 117         break;
 118     }
 119     prefix = prefix.take_front(count);
 120   }
 121   return prefix.str();
 122 }
 123
 124 void StringList::InsertStringAtIndex(size_t idx, const char *str) {
 125   if (str) {
 126     if (idx < m_strings.size())
 127       m_strings.insert(m_strings.begin() + idx, str);
 128     else
 129       m_strings.push_back(str);
 130   }
 131 }
 132
 133 void StringList::InsertStringAtIndex(size_t idx, const std::string &str) {
 134   if (idx < m_strings.size())
 135     m_strings.insert(m_strings.begin() + idx, str);
 136   else
 137     m_strings.push_back(str);
 138 }
 139
 140 void StringList::InsertStringAtIndex(size_t idx, std::string &&str) {
 141   if (idx < m_strings.size())
 142     m_strings.insert(m_strings.begin() + idx, std::move(str));
 143   else
 144     m_strings.push_back(std::move(str));
 145 }
 146
 147 void StringList::DeleteStringAtIndex(size_t idx) {
 148   if (idx < m_strings.size())
 149     m_strings.erase(m_strings.begin() + idx);
 150 }
 151
 152 size_t StringList::SplitIntoLines(const std::string &lines) {
 153   return SplitIntoLines(lines.c_str(), lines.size());
 154 }
 155
 156 size_t StringList::SplitIntoLines(const char *lines, size_t len) {
 157   const size_t orig_size = m_strings.size();
 158
 159   if (len == 0)
 160     return 0;
 161
 162   const char *k_newline_chars = "\r\n";
 163   const char *p = lines;
 164   const char *end = lines + len;
 165   while (p < end) {
 166     size_t count = strcspn(p, k_newline_chars);
 167     if (count == 0) {
 168       if (p[count] == '\r' || p[count] == '\n')
 169         m_strings.push_back(std::string());
 170       else
 171         break;
 172     } else {
 173       if (p + count > end)
 174         count = end - p;
 175       m_strings.push_back(std::string(p, count));
 176     }
 177     if (p[count] == '\r' && p[count + 1] == '\n')
 178       count++; // Skip an extra newline char for the DOS newline
 179     count++;   // Skip the newline character
 180     p += count;
 181   }
 182   return m_strings.size() - orig_size;
 183 }
 184
 185 void StringList::RemoveBlankLines() {
 186   if (GetSize() == 0)
 187     return;
 188
 189   size_t idx = 0;
 190   while (idx < m_strings.size()) {
 191     if (m_strings[idx].empty())
 192       DeleteStringAtIndex(idx);
 193     else
 194       idx++;
 195   }
 196 }
 197
 198 std::string StringList::CopyList(const char *item_preamble,
 199                                  const char *items_sep) const {
 200   StreamString strm;
 201   for (size_t i = 0; i < GetSize(); i++) {
 202     if (i && items_sep && items_sep[0])
 203       strm << items_sep;
 204     if (item_preamble)
 205       strm << item_preamble;
 206     strm << GetStringAtIndex(i);
 207   }
 208   return std::string(strm.GetString());
 209 }
 210
 211 StringList &StringList::operator<<(const char *str) {
 212   AppendString(str);
 213   return *this;
 214 }
 215
 216 StringList &StringList::operator<<(const std::string &str) {
 217   AppendString(str);
 218   return *this;
 219 }
 220
 221 StringList &StringList::operator<<(const StringList &strings) {
 222   AppendList(strings);
 223   return *this;
 224 }
 225
 226 StringList &StringList::operator=(const std::vector<std::string> &rhs) {
 227   m_strings.assign(rhs.begin(), rhs.end());
 228
 229   return *this;
 230 }
 231
 232 void StringList::LogDump(Log *log, const char *name) {
 233   if (!log)
 234     return;
 235
 236   StreamString strm;
 237   if (name)
 238     strm.Printf("Begin %s:\n", name);
 239   for (const auto &s : m_strings) {
 240     strm.Indent();
 241     strm.Printf("%s\n", s.c_str());
 242   }
 243   if (name)
 244     strm.Printf("End %s.\n", name);
 245
 246   LLDB_LOGV(log, "{0}", strm.GetData());
 247 }