lib/LineEditor/LineEditor.cpp

   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
  21 using namespace llvm;
  22
  23 std::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 Path.str();
  28   }
  29   return std::string();
  30 }
  31
  32 LineEditor::CompleterConcept::~CompleterConcept() {}
  33 LineEditor::ListCompleterConcept::~ListCompleterConcept() {}
  34
  35 std::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
  54 LineEditor::CompletionAction
  55 LineEditor::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
  83 LineEditor::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
  98 struct 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
 110 namespace {
 111
 112 const 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.
 123 unsigned 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
 198 LineEditor::LineEditor(StringRef ProgName, StringRef HistoryPath, FILE *In,
 199                        FILE *Out, FILE *Err)
 200     : Prompt((ProgName + "> ").str()), HistoryPath(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
 234 LineEditor::~LineEditor() {
 235   saveHistory();
 236
 237   ::history_end(Data->Hist);
 238   ::el_end(Data->EL);
 239   ::fwrite("\n", 1, 1, Data->Out);
 240 }
 241
 242 void LineEditor::saveHistory() {
 243   if (!HistoryPath.empty()) {
 244     HistEvent HE;
 245     ::history(Data->Hist, &HE, H_SAVE, HistoryPath.c_str());
 246   }
 247 }
 248
 249 void LineEditor::loadHistory() {
 250   if (!HistoryPath.empty()) {
 251     HistEvent HE;
 252     ::history(Data->Hist, &HE, H_LOAD, HistoryPath.c_str());
 253   }
 254 }
 255
 256 Optional<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
 281 struct LineEditor::InternalData {
 282   FILE *In;
 283   FILE *Out;
 284 };
 285
 286 LineEditor::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
 293 LineEditor::~LineEditor() {
 294   ::fwrite("\n", 1, 1, Data->Out);
 295 }
 296
 297 void LineEditor::saveHistory() {}
 298 void LineEditor::loadHistory() {}
 299
 300 Optional<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