1 //===-- CommandHistory.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 <inttypes.h>
11
12 #include "lldb/Interpreter/CommandHistory.h"
13 #include "lldb/Host/StringConvert.h"
14
15 using namespace lldb;
16 using namespace lldb_private;
17
18
CommandHistory()19 CommandHistory::CommandHistory () :
20 m_mutex(Mutex::eMutexTypeRecursive),
21 m_history()
22 {}
23
~CommandHistory()24 CommandHistory::~CommandHistory ()
25 {}
26
27 size_t
GetSize() const28 CommandHistory::GetSize () const
29 {
30 Mutex::Locker locker(m_mutex);
31 return m_history.size();
32 }
33
34 bool
IsEmpty() const35 CommandHistory::IsEmpty () const
36 {
37 Mutex::Locker locker(m_mutex);
38 return m_history.empty();
39 }
40
41 const char*
FindString(const char * input_str) const42 CommandHistory::FindString (const char* input_str) const
43 {
44 Mutex::Locker locker(m_mutex);
45 if (!input_str)
46 return nullptr;
47 if (input_str[0] != g_repeat_char)
48 return nullptr;
49 if (input_str[1] == '-')
50 {
51 bool success;
52 size_t idx = StringConvert::ToUInt32 (input_str+2, 0, 0, &success);
53 if (!success)
54 return nullptr;
55 if (idx > m_history.size())
56 return nullptr;
57 idx = m_history.size() - idx;
58 return m_history[idx].c_str();
59
60 }
61 else if (input_str[1] == g_repeat_char)
62 {
63 if (m_history.empty())
64 return nullptr;
65 else
66 return m_history.back().c_str();
67 }
68 else
69 {
70 bool success;
71 uint32_t idx = StringConvert::ToUInt32 (input_str+1, 0, 0, &success);
72 if (!success)
73 return nullptr;
74 if (idx >= m_history.size())
75 return nullptr;
76 return m_history[idx].c_str();
77 }
78 }
79
80 const char*
GetStringAtIndex(size_t idx) const81 CommandHistory::GetStringAtIndex (size_t idx) const
82 {
83 Mutex::Locker locker(m_mutex);
84 if (idx < m_history.size())
85 return m_history[idx].c_str();
86 return nullptr;
87 }
88
89 const char*
operator [](size_t idx) const90 CommandHistory::operator [] (size_t idx) const
91 {
92 return GetStringAtIndex(idx);
93 }
94
95 const char*
GetRecentmostString() const96 CommandHistory::GetRecentmostString () const
97 {
98 Mutex::Locker locker(m_mutex);
99 if (m_history.empty())
100 return nullptr;
101 return m_history.back().c_str();
102 }
103
104 void
AppendString(const std::string & str,bool reject_if_dupe)105 CommandHistory::AppendString (const std::string& str,
106 bool reject_if_dupe)
107 {
108 Mutex::Locker locker(m_mutex);
109 if (reject_if_dupe)
110 {
111 if (!m_history.empty())
112 {
113 if (str == m_history.back())
114 return;
115 }
116 }
117 m_history.push_back(std::string(str));
118 }
119
120 void
Clear()121 CommandHistory::Clear ()
122 {
123 Mutex::Locker locker(m_mutex);
124 m_history.clear();
125 }
126
127 void
Dump(Stream & stream,size_t start_idx,size_t stop_idx) const128 CommandHistory::Dump (Stream& stream,
129 size_t start_idx,
130 size_t stop_idx) const
131 {
132 Mutex::Locker locker(m_mutex);
133 stop_idx = std::min(stop_idx, m_history.size() - 1);
134 for (size_t counter = start_idx;
135 counter <= stop_idx;
136 counter++)
137 {
138 const std::string hist_item = m_history[counter];
139 if (!hist_item.empty())
140 {
141 stream.Indent();
142 stream.Printf("%4" PRIu64 ": %s\n", (uint64_t)counter, hist_item.c_str());
143 }
144 }
145 }
146