contrib/llvm/tools/lldb/source/Utility/StringList.cpp

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