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" // for Stream
14 #include "lldb/Utility/StreamString.h"
15 #include "llvm/ADT/ArrayRef.h" // for ArrayRef, makeArrayRef
16 
17 #include <algorithm> // for min
18 #include <stdint.h>  // for SIZE_MAX, uint32_t
19 #include <string.h>  // for size_t, strcspn, NULL
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 NULL;
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 }
269