Peter Collingbourne | c7d437c | 2014-01-31 23:46:14 +0000 | [diff] [blame] | 1 | //===-- LineEditor.cpp - line editor --------------------------------------===// |
| 2 | // |
Chandler Carruth | 2946cd7 | 2019-01-19 08:50:56 +0000 | [diff] [blame] | 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 |
Peter Collingbourne | c7d437c | 2014-01-31 23:46:14 +0000 | [diff] [blame] | 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" |
Eugene Zelenko | 35623fb | 2016-03-28 17:40:08 +0000 | [diff] [blame] | 14 | #include <algorithm> |
| 15 | #include <cassert> |
| 16 | #include <cstdio> |
Peter Collingbourne | c7d437c | 2014-01-31 23:46:14 +0000 | [diff] [blame] | 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; |
Peter Collingbourne | 45b4c49 | 2014-02-04 20:04:46 +0000 | [diff] [blame] | 106 | |
| 107 | FILE *Out; |
Peter Collingbourne | c7d437c | 2014-01-31 23:46:14 +0000 | [diff] [blame] | 108 | }; |
| 109 | |
Eugene Zelenko | 35623fb | 2016-03-28 17:40:08 +0000 | [diff] [blame] | 110 | namespace { |
| 111 | |
| 112 | const char *ElGetPromptFn(EditLine *EL) { |
Peter Collingbourne | c7d437c | 2014-01-31 23:46:14 +0000 | [diff] [blame] | 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. |
Eugene Zelenko | 35623fb | 2016-03-28 17:40:08 +0000 | [diff] [blame] | 123 | unsigned char ElCompletionFn(EditLine *EL, int ch) { |
Peter Collingbourne | c7d437c | 2014-01-31 23:46:14 +0000 | [diff] [blame] | 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. |
Peter Collingbourne | 45b4c49 | 2014-02-04 20:04:46 +0000 | [diff] [blame] | 128 | FILE *Out = Data->Out; |
Peter Collingbourne | c7d437c | 2014-01-31 23:46:14 +0000 | [diff] [blame] | 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'); |
Benjamin Kramer | 029750f | 2014-02-01 11:26:18 +0000 | [diff] [blame] | 137 | ::el_push(EL, const_cast<char *>(Prevs.c_str())); |
Peter Collingbourne | c7d437c | 2014-01-31 23:46:14 +0000 | [diff] [blame] | 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. |
Benjamin Kramer | 029750f | 2014-02-01 11:26:18 +0000 | [diff] [blame] | 164 | ::el_push(EL, const_cast<char *>("\05\t")); |
Peter Collingbourne | c7d437c | 2014-01-31 23:46:14 +0000 | [diff] [blame] | 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 | } |
Peter Collingbourne | c7d437c | 2014-01-31 23:46:14 +0000 | [diff] [blame] | 192 | } |
Benjamin Kramer | 029750f | 2014-02-01 11:26:18 +0000 | [diff] [blame] | 193 | return CC_ERROR; |
Peter Collingbourne | c7d437c | 2014-01-31 23:46:14 +0000 | [diff] [blame] | 194 | } |
| 195 | |
Eugene Zelenko | 35623fb | 2016-03-28 17:40:08 +0000 | [diff] [blame] | 196 | } // end anonymous namespace |
| 197 | |
Peter Collingbourne | c7d437c | 2014-01-31 23:46:14 +0000 | [diff] [blame] | 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; |
Peter Collingbourne | 45b4c49 | 2014-02-04 20:04:46 +0000 | [diff] [blame] | 206 | Data->Out = Out; |
Peter Collingbourne | c7d437c | 2014-01-31 23:46:14 +0000 | [diff] [blame] | 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 | |
Peter Collingbourne | c7d437c | 2014-01-31 23:46:14 +0000 | [diff] [blame] | 237 | ::history_end(Data->Hist); |
| 238 | ::el_end(Data->EL); |
Peter Collingbourne | 45b4c49 | 2014-02-04 20:04:46 +0000 | [diff] [blame] | 239 | ::fwrite("\n", 1, 1, Data->Out); |
Peter Collingbourne | c7d437c | 2014-01-31 23:46:14 +0000 | [diff] [blame] | 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 | |
Eugene Zelenko | 35623fb | 2016-03-28 17:40:08 +0000 | [diff] [blame] | 277 | #else // HAVE_LIBEDIT |
Peter Collingbourne | c7d437c | 2014-01-31 23:46:14 +0000 | [diff] [blame] | 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 | |
Eugene Zelenko | 35623fb | 2016-03-28 17:40:08 +0000 | [diff] [blame] | 324 | #endif // HAVE_LIBEDIT |