contrib/llvm-project/lldb/source/Utility/StringList.cpp

   1 //===-- StringList.cpp ------------------------------------------*- C++ -*-===//
   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 <stdint.h>
  18 #include <string.h>
  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() {}
  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) { m_strings.push_back(s); }
  46
  47 void StringList::AppendString(const char *str, size_t str_len) {
  48   if (str)
  49     m_strings.push_back(std::string(str, str_len));
  50 }
  51
  52 void StringList::AppendString(llvm::StringRef str) {
  53   m_strings.push_back(str.str());
  54 }
  55
  56 void StringList::AppendList(const char **strv, int strc) {
  57   for (int i = 0; i < strc; ++i) {
  58     if (strv[i])
  59       m_strings.push_back(strv[i]);
  60   }
  61 }
  62
  63 void StringList::AppendList(StringList strings) {
  64   size_t len = strings.GetSize();
  65
  66   for (size_t i = 0; i < len; ++i)
  67     m_strings.push_back(strings.GetStringAtIndex(i));
  68 }
  69
  70 size_t StringList::GetSize() const { return m_strings.size(); }
  71
  72 size_t StringList::GetMaxStringLength() const {
  73   size_t max_length = 0;
  74   for (const auto &s : m_strings) {
  75     const size_t len = s.size();
  76     if (max_length < len)
  77       max_length = len;
  78   }
  79   return max_length;
  80 }
  81
  82 const char *StringList::GetStringAtIndex(size_t idx) const {
  83   if (idx < m_strings.size())
  84     return m_strings[idx].c_str();
  85   return nullptr;
  86 }
  87
  88 void StringList::Join(const char *separator, Stream &strm) {
  89   size_t size = GetSize();
  90
  91   if (size == 0)
  92     return;
  93
  94   for (uint32_t i = 0; i < size; ++i) {
  95     if (i > 0)
  96       strm.PutCString(separator);
  97     strm.PutCString(GetStringAtIndex(i));
  98   }
  99 }
 100
 101 void StringList::Clear() { m_strings.clear(); }
 102
 103 void StringList::LongestCommonPrefix(std::string &common_prefix) {
 104   common_prefix.clear();
 105   if (m_strings.empty())
 106     return;
 107
 108   auto args = llvm::makeArrayRef(m_strings);
 109   llvm::StringRef prefix = args.front();
 110   for (auto arg : args.drop_front()) {
 111     size_t count = 0;
 112     for (count = 0; count < std::min(prefix.size(), arg.size()); ++count) {
 113       if (prefix[count] != arg[count])
 114         break;
 115     }
 116     prefix = prefix.take_front(count);
 117   }
 118   common_prefix = prefix;
 119 }
 120
 121 void StringList::InsertStringAtIndex(size_t idx, const char *str) {
 122   if (str) {
 123     if (idx < m_strings.size())
 124       m_strings.insert(m_strings.begin() + idx, str);
 125     else
 126       m_strings.push_back(str);
 127   }
 128 }
 129
 130 void StringList::InsertStringAtIndex(size_t idx, const std::string &str) {
 131   if (idx < m_strings.size())
 132     m_strings.insert(m_strings.begin() + idx, str);
 133   else
 134     m_strings.push_back(str);
 135 }
 136
 137 void StringList::InsertStringAtIndex(size_t idx, std::string &&str) {
 138   if (idx < m_strings.size())
 139     m_strings.insert(m_strings.begin() + idx, str);
 140   else
 141     m_strings.push_back(str);
 142 }
 143
 144 void StringList::DeleteStringAtIndex(size_t idx) {
 145   if (idx < m_strings.size())
 146     m_strings.erase(m_strings.begin() + idx);
 147 }
 148
 149 size_t StringList::SplitIntoLines(const std::string &lines) {
 150   return SplitIntoLines(lines.c_str(), lines.size());
 151 }
 152
 153 size_t StringList::SplitIntoLines(const char *lines, size_t len) {
 154   const size_t orig_size = m_strings.size();
 155
 156   if (len == 0)
 157     return 0;
 158
 159   const char *k_newline_chars = "\r\n";
 160   const char *p = lines;
 161   const char *end = lines + len;
 162   while (p < end) {
 163     size_t count = strcspn(p, k_newline_chars);
 164     if (count == 0) {
 165       if (p[count] == '\r' || p[count] == '\n')
 166         m_strings.push_back(std::string());
 167       else
 168         break;
 169     } else {
 170       if (p + count > end)
 171         count = end - p;
 172       m_strings.push_back(std::string(p, count));
 173     }
 174     if (p[count] == '\r' && p[count + 1] == '\n')
 175       count++; // Skip an extra newline char for the DOS newline
 176     count++;   // Skip the newline character
 177     p += count;
 178   }
 179   return m_strings.size() - orig_size;
 180 }
 181
 182 void StringList::RemoveBlankLines() {
 183   if (GetSize() == 0)
 184     return;
 185
 186   size_t idx = 0;
 187   while (idx < m_strings.size()) {
 188     if (m_strings[idx].empty())
 189       DeleteStringAtIndex(idx);
 190     else
 191       idx++;
 192   }
 193 }
 194
 195 std::string StringList::CopyList(const char *item_preamble,
 196                                  const char *items_sep) const {
 197   StreamString strm;
 198   for (size_t i = 0; i < GetSize(); i++) {
 199     if (i && items_sep && items_sep[0])
 200       strm << items_sep;
 201     if (item_preamble)
 202       strm << item_preamble;
 203     strm << GetStringAtIndex(i);
 204   }
 205   return strm.GetString();
 206 }
 207
 208 StringList &StringList::operator<<(const char *str) {
 209   AppendString(str);
 210   return *this;
 211 }
 212
 213 StringList &StringList::operator<<(const std::string &str) {
 214   AppendString(str);
 215   return *this;
 216 }
 217
 218 StringList &StringList::operator<<(StringList strings) {
 219   AppendList(strings);
 220   return *this;
 221 }
 222
 223 StringList &StringList::operator=(const std::vector<std::string> &rhs) {
 224   m_strings.assign(rhs.begin(), rhs.end());
 225
 226   return *this;
 227 }
 228
 229 size_t StringList::AutoComplete(llvm::StringRef s, StringList &matches,
 230                                 size_t &exact_idx) const {
 231   matches.Clear();
 232   exact_idx = SIZE_MAX;
 233   if (s.empty()) {
 234     // No string, so it matches everything
 235     matches = *this;
 236     return matches.GetSize();
 237   }
 238
 239   const size_t s_len = s.size();
 240   const size_t num_strings = m_strings.size();
 241
 242   for (size_t i = 0; i < num_strings; ++i) {
 243     if (m_strings[i].find(s) == 0) {
 244       if (exact_idx == SIZE_MAX && m_strings[i].size() == s_len)
 245         exact_idx = matches.GetSize();
 246       matches.AppendString(m_strings[i]);
 247     }
 248   }
 249   return matches.GetSize();
 250 }
 251
 252 void StringList::LogDump(Log *log, const char *name) {
 253   if (!log)
 254     return;
 255
 256   StreamString strm;
 257   if (name)
 258     strm.Printf("Begin %s:\n", name);
 259   for (const auto &s : m_strings) {
 260     strm.Indent();
 261     strm.Printf("%s\n", s.c_str());
 262   }
 263   if (name)
 264     strm.Printf("End %s.\n", name);
 265
 266   LLDB_LOGV(log, "{0}", strm.GetData());
 267 }