LLVM 19.0.0git
LineEditor.cpp
Go to the documentation of this file.
1//===-- LineEditor.cpp - line editor --------------------------------------===//
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
10#include "llvm/ADT/STLExtras.h"
12#include "llvm/Config/config.h"
13#include "llvm/Support/Path.h"
15#include <algorithm>
16#include <cassert>
17#include <cstdio>
18#ifdef HAVE_LIBEDIT
19#include <histedit.h>
20#endif
21
22using namespace llvm;
23
25 SmallString<32> Path;
26 if (sys::path::home_directory(Path)) {
27 sys::path::append(Path, "." + ProgName + "-history");
28 return std::string(Path);
29 }
30 return std::string();
31}
32
33LineEditor::CompleterConcept::~CompleterConcept() = default;
34LineEditor::ListCompleterConcept::~ListCompleterConcept() = default;
35
36std::string LineEditor::ListCompleterConcept::getCommonPrefix(
37 const std::vector<Completion> &Comps) {
38 assert(!Comps.empty());
39
40 std::string CommonPrefix = Comps[0].TypedText;
41 for (const Completion &C : llvm::drop_begin(Comps)) {
42 size_t Len = std::min(CommonPrefix.size(), C.TypedText.size());
43 size_t CommonLen = 0;
44 for (; CommonLen != Len; ++CommonLen) {
45 if (CommonPrefix[CommonLen] != C.TypedText[CommonLen])
46 break;
47 }
48 CommonPrefix.resize(CommonLen);
49 }
50 return CommonPrefix;
51}
52
54LineEditor::ListCompleterConcept::complete(StringRef Buffer, size_t Pos) const {
55 CompletionAction Action;
56 std::vector<Completion> Comps = getCompletions(Buffer, Pos);
57 if (Comps.empty()) {
58 Action.Kind = CompletionAction::AK_ShowCompletions;
59 return Action;
60 }
61
62 std::string CommonPrefix = getCommonPrefix(Comps);
63
64 // If the common prefix is non-empty we can simply insert it. If there is a
65 // single completion, this will insert the full completion. If there is more
66 // than one, this might be enough information to jog the user's memory but if
67 // not the user can also hit tab again to see the completions because the
68 // common prefix will then be empty.
69 if (CommonPrefix.empty()) {
70 Action.Kind = CompletionAction::AK_ShowCompletions;
71 for (const Completion &Comp : Comps)
72 Action.Completions.push_back(Comp.DisplayText);
73 } else {
74 Action.Kind = CompletionAction::AK_Insert;
75 Action.Text = CommonPrefix;
76 }
77
78 return Action;
79}
80
82 size_t Pos) const {
83 if (!Completer) {
84 CompletionAction Action;
86 return Action;
87 }
88
89 return Completer->complete(Buffer, Pos);
90}
91
92#ifdef HAVE_LIBEDIT
93
94// libedit-based implementation.
95
97 LineEditor *LE;
98
99 History *Hist;
100 EditLine *EL;
101
102 unsigned PrevCount;
103 std::string ContinuationOutput;
104
105 FILE *Out;
106};
107
108namespace {
109
110const char *ElGetPromptFn(EditLine *EL) {
112 if (el_get(EL, EL_CLIENTDATA, &Data) == 0)
113 return Data->LE->getPrompt().c_str();
114 return "> ";
115}
116
117// Handles tab completion.
118//
119// This function is really horrible. But since the alternative is to get into
120// the line editor business, here we are.
121unsigned char ElCompletionFn(EditLine *EL, int ch) {
123 if (el_get(EL, EL_CLIENTDATA, &Data) == 0) {
124 if (!Data->ContinuationOutput.empty()) {
125 // This is the continuation of the AK_ShowCompletions branch below.
126 FILE *Out = Data->Out;
127
128 // Print the required output (see below).
129 ::fwrite(Data->ContinuationOutput.c_str(),
130 Data->ContinuationOutput.size(), 1, Out);
131
132 // Push a sequence of Ctrl-B characters to move the cursor back to its
133 // original position.
134 std::string Prevs(Data->PrevCount, '\02');
135 ::el_push(EL, const_cast<char *>(Prevs.c_str()));
136
137 Data->ContinuationOutput.clear();
138
139 return CC_REFRESH;
140 }
141
142 const LineInfo *LI = ::el_line(EL);
143 LineEditor::CompletionAction Action = Data->LE->getCompletionAction(
144 StringRef(LI->buffer, LI->lastchar - LI->buffer),
145 LI->cursor - LI->buffer);
146 switch (Action.Kind) {
148 ::el_insertstr(EL, Action.Text.c_str());
149 return CC_REFRESH;
150
152 if (Action.Completions.empty()) {
153 return CC_REFRESH_BEEP;
154 } else {
155 // Push a Ctrl-E and a tab. The Ctrl-E causes libedit to move the cursor
156 // to the end of the line, so that when we emit a newline we will be on
157 // a new blank line. The tab causes libedit to call this function again
158 // after moving the cursor. There doesn't seem to be anything we can do
159 // from here to cause libedit to move the cursor immediately. This will
160 // break horribly if the user has rebound their keys, so for now we do
161 // not permit user rebinding.
162 ::el_push(EL, const_cast<char *>("\05\t"));
163
164 // This assembles the output for the continuation block above.
165 raw_string_ostream OS(Data->ContinuationOutput);
166
167 // Move cursor to a blank line.
168 OS << "\n";
169
170 // Emit the completions.
171 for (const std::string &Completion : Action.Completions)
172 OS << Completion << "\n";
173
174 // Fool libedit into thinking nothing has changed. Reprint its prompt
175 // and the user input. Note that the cursor will remain at the end of
176 // the line after this.
177 OS << Data->LE->getPrompt()
178 << StringRef(LI->buffer, LI->lastchar - LI->buffer);
179
180 // This is the number of characters we need to tell libedit to go back:
181 // the distance between end of line and the original cursor position.
182 Data->PrevCount = LI->lastchar - LI->cursor;
183
184 return CC_REFRESH;
185 }
186 }
187 }
188 return CC_ERROR;
189}
190
191} // end anonymous namespace
192
193LineEditor::LineEditor(StringRef ProgName, StringRef HistoryPath, FILE *In,
194 FILE *Out, FILE *Err)
195 : Prompt((ProgName + "> ").str()), HistoryPath(std::string(HistoryPath)),
196 Data(new InternalData) {
197 if (HistoryPath.empty())
198 this->HistoryPath = getDefaultHistoryPath(ProgName);
199
200 Data->LE = this;
201 Data->Out = Out;
202
203 Data->Hist = ::history_init();
204 assert(Data->Hist);
205
206 Data->EL = ::el_init(ProgName.str().c_str(), In, Out, Err);
207 assert(Data->EL);
208
209 ::el_set(Data->EL, EL_PROMPT, ElGetPromptFn);
210 ::el_set(Data->EL, EL_EDITOR, "emacs");
211 ::el_set(Data->EL, EL_HIST, history, Data->Hist);
212 ::el_set(Data->EL, EL_ADDFN, "tab_complete", "Tab completion function",
213 ElCompletionFn);
214 ::el_set(Data->EL, EL_BIND, "\t", "tab_complete", NULL);
215 ::el_set(Data->EL, EL_BIND, "^r", "em-inc-search-prev",
216 NULL); // Cycle through backwards search, entering string
217 ::el_set(Data->EL, EL_BIND, "^w", "ed-delete-prev-word",
218 NULL); // Delete previous word, behave like bash does.
219 ::el_set(Data->EL, EL_BIND, "\033[3~", "ed-delete-next-char",
220 NULL); // Fix the delete key.
221 ::el_set(Data->EL, EL_CLIENTDATA, Data.get());
222
223 HistEvent HE;
224 ::history(Data->Hist, &HE, H_SETSIZE, 800);
225 ::history(Data->Hist, &HE, H_SETUNIQUE, 1);
226 loadHistory();
227}
228
230 saveHistory();
231
232 ::history_end(Data->Hist);
233 ::el_end(Data->EL);
234 ::fwrite("\n", 1, 1, Data->Out);
235}
236
238 if (!HistoryPath.empty()) {
239 HistEvent HE;
240 ::history(Data->Hist, &HE, H_SAVE, HistoryPath.c_str());
241 }
242}
243
245 if (!HistoryPath.empty()) {
246 HistEvent HE;
247 ::history(Data->Hist, &HE, H_LOAD, HistoryPath.c_str());
248 }
249}
250
251std::optional<std::string> LineEditor::readLine() const {
252 // Call el_gets to prompt the user and read the user's input.
253 int LineLen = 0;
254 const char *Line = ::el_gets(Data->EL, &LineLen);
255
256 // Either of these may mean end-of-file.
257 if (!Line || LineLen == 0)
258 return std::nullopt;
259
260 // Strip any newlines off the end of the string.
261 while (LineLen > 0 &&
262 (Line[LineLen - 1] == '\n' || Line[LineLen - 1] == '\r'))
263 --LineLen;
264
265 HistEvent HE;
266 if (LineLen > 0)
267 ::history(Data->Hist, &HE, H_ENTER, Line);
268
269 return std::string(Line, LineLen);
270}
271
272#else // HAVE_LIBEDIT
273
274// Simple fgets-based implementation.
275
277 FILE *In;
278 FILE *Out;
279};
280
281LineEditor::LineEditor(StringRef ProgName, StringRef HistoryPath, FILE *In,
282 FILE *Out, FILE *Err)
283 : Prompt((ProgName + "> ").str()), Data(new InternalData) {
284 Data->In = In;
285 Data->Out = Out;
286}
287
289 ::fwrite("\n", 1, 1, Data->Out);
290}
291
294
295std::optional<std::string> LineEditor::readLine() const {
296 ::fprintf(Data->Out, "%s", Prompt.c_str());
297
298 std::string Line;
299 do {
300 char Buf[64];
301 char *Res = ::fgets(Buf, sizeof(Buf), Data->In);
302 if (!Res) {
303 if (Line.empty())
304 return std::nullopt;
305 else
306 return Line;
307 }
308 Line.append(Buf);
309 } while (Line.empty() ||
310 (Line[Line.size() - 1] != '\n' && Line[Line.size() - 1] != '\r'));
311
312 while (!Line.empty() &&
313 (Line[Line.size() - 1] == '\n' || Line[Line.size() - 1] == '\r'))
314 Line.resize(Line.size() - 1);
315
316 return Line;
317}
318
319#endif // HAVE_LIBEDIT
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file contains some templates that are useful if you are working with the STL at all.
raw_pwrite_stream & OS
This file defines the SmallString class.
CompletionAction getCompletionAction(StringRef Buffer, size_t Pos) const
Use the current completer to produce a CompletionAction for the given completion request.
Definition: LineEditor.cpp:81
static std::string getDefaultHistoryPath(StringRef ProgName)
Definition: LineEditor.cpp:24
LineEditor(StringRef ProgName, StringRef HistoryPath="", FILE *In=stdin, FILE *Out=stdout, FILE *Err=stderr)
Create a LineEditor object.
Definition: LineEditor.cpp:281
std::optional< std::string > readLine() const
Reads a line.
Definition: LineEditor.cpp:295
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition: SmallString.h:26
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
std::string str() const
str - Get the contents as an std::string.
Definition: StringRef.h:222
constexpr bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:134
A raw_ostream that writes to an std::string.
Definition: raw_ostream.h:660
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
ManagedStatic< cl::opt< FnT >, OptCreatorT > Action
bool home_directory(SmallVectorImpl< char > &result)
Get the user's home directory.
void append(SmallVectorImpl< char > &path, const Twine &a, const Twine &b="", const Twine &c="", const Twine &d="")
Append to path.
Definition: Path.cpp:458
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
auto drop_begin(T &&RangeOrContainer, size_t N=1)
Return a range covering RangeOrContainer with the first N elements excluded.
Definition: STLExtras.h:329
Implement std::hash so that hash_code can be used in STL containers.
Definition: BitVector.h:858
The action to perform upon a completion request.
Definition: LineEditor.h:48
@ AK_ShowCompletions
Show Completions, or beep if the list is empty.
Definition: LineEditor.h:53
@ AK_Insert
Insert Text at the cursor position.
Definition: LineEditor.h:51