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