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