Peter Collingbourne | c7d437c | 2014-01-31 23:46:14 +0000 | [diff] [blame] | 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 <stdio.h> |
| 16 | #ifdef HAVE_LIBEDIT |
| 17 | #include <histedit.h> |
| 18 | #endif |
| 19 | |
| 20 | using namespace llvm; |
| 21 | |
| 22 | std::string LineEditor::getDefaultHistoryPath(StringRef ProgName) { |
| 23 | SmallString<32> Path; |
| 24 | if (sys::path::home_directory(Path)) { |
| 25 | sys::path::append(Path, "." + ProgName + "-history"); |
| 26 | return Path.str(); |
| 27 | } |
| 28 | return std::string(); |
| 29 | } |
| 30 | |
| 31 | LineEditor::CompleterConcept::~CompleterConcept() {} |
| 32 | LineEditor::ListCompleterConcept::~ListCompleterConcept() {} |
| 33 | |
| 34 | std::string LineEditor::ListCompleterConcept::getCommonPrefix( |
| 35 | const std::vector<Completion> &Comps) { |
| 36 | assert(!Comps.empty()); |
| 37 | |
| 38 | std::string CommonPrefix = Comps[0].TypedText; |
| 39 | for (std::vector<Completion>::const_iterator I = Comps.begin() + 1, |
| 40 | E = Comps.end(); |
| 41 | I != E; ++I) { |
| 42 | size_t Len = std::min(CommonPrefix.size(), I->TypedText.size()); |
| 43 | size_t CommonLen = 0; |
| 44 | for (; CommonLen != Len; ++CommonLen) { |
| 45 | if (CommonPrefix[CommonLen] != I->TypedText[CommonLen]) |
| 46 | break; |
| 47 | } |
| 48 | CommonPrefix.resize(CommonLen); |
| 49 | } |
| 50 | return CommonPrefix; |
| 51 | } |
| 52 | |
| 53 | LineEditor::CompletionAction |
| 54 | LineEditor::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 (std::vector<Completion>::iterator I = Comps.begin(), E = Comps.end(); |
| 72 | I != E; ++I) |
| 73 | Action.Completions.push_back(I->DisplayText); |
| 74 | } else { |
| 75 | Action.Kind = CompletionAction::AK_Insert; |
| 76 | Action.Text = CommonPrefix; |
| 77 | } |
| 78 | |
| 79 | return Action; |
| 80 | } |
| 81 | |
| 82 | LineEditor::CompletionAction LineEditor::getCompletionAction(StringRef Buffer, |
| 83 | size_t Pos) const { |
| 84 | if (!Completer) { |
| 85 | CompletionAction Action; |
| 86 | Action.Kind = CompletionAction::AK_ShowCompletions; |
| 87 | return Action; |
| 88 | } |
| 89 | |
| 90 | return Completer->complete(Buffer, Pos); |
| 91 | } |
| 92 | |
| 93 | #ifdef HAVE_LIBEDIT |
| 94 | |
| 95 | // libedit-based implementation. |
| 96 | |
| 97 | struct LineEditor::InternalData { |
| 98 | LineEditor *LE; |
| 99 | |
| 100 | History *Hist; |
| 101 | EditLine *EL; |
| 102 | |
| 103 | unsigned PrevCount; |
| 104 | std::string ContinuationOutput; |
Peter Collingbourne | 45b4c49 | 2014-02-04 20:04:46 +0000 | [diff] [blame] | 105 | |
| 106 | FILE *Out; |
Peter Collingbourne | c7d437c | 2014-01-31 23:46:14 +0000 | [diff] [blame] | 107 | }; |
| 108 | |
| 109 | static const char *ElGetPromptFn(EditLine *EL) { |
| 110 | LineEditor::InternalData *Data; |
| 111 | if (el_get(EL, EL_CLIENTDATA, &Data) == 0) |
| 112 | return Data->LE->getPrompt().c_str(); |
| 113 | return "> "; |
| 114 | } |
| 115 | |
| 116 | // Handles tab completion. |
| 117 | // |
| 118 | // This function is really horrible. But since the alternative is to get into |
| 119 | // the line editor business, here we are. |
| 120 | static unsigned char ElCompletionFn(EditLine *EL, int ch) { |
| 121 | LineEditor::InternalData *Data; |
| 122 | if (el_get(EL, EL_CLIENTDATA, &Data) == 0) { |
| 123 | if (!Data->ContinuationOutput.empty()) { |
| 124 | // This is the continuation of the AK_ShowCompletions branch below. |
Peter Collingbourne | 45b4c49 | 2014-02-04 20:04:46 +0000 | [diff] [blame] | 125 | FILE *Out = Data->Out; |
Peter Collingbourne | c7d437c | 2014-01-31 23:46:14 +0000 | [diff] [blame] | 126 | |
| 127 | // Print the required output (see below). |
| 128 | ::fwrite(Data->ContinuationOutput.c_str(), |
| 129 | Data->ContinuationOutput.size(), 1, Out); |
| 130 | |
| 131 | // Push a sequence of Ctrl-B characters to move the cursor back to its |
| 132 | // original position. |
| 133 | std::string Prevs(Data->PrevCount, '\02'); |
Benjamin Kramer | 029750f | 2014-02-01 11:26:18 +0000 | [diff] [blame] | 134 | ::el_push(EL, const_cast<char *>(Prevs.c_str())); |
Peter Collingbourne | c7d437c | 2014-01-31 23:46:14 +0000 | [diff] [blame] | 135 | |
| 136 | Data->ContinuationOutput.clear(); |
| 137 | |
| 138 | return CC_REFRESH; |
| 139 | } |
| 140 | |
| 141 | const LineInfo *LI = ::el_line(EL); |
| 142 | LineEditor::CompletionAction Action = Data->LE->getCompletionAction( |
| 143 | StringRef(LI->buffer, LI->lastchar - LI->buffer), |
| 144 | LI->cursor - LI->buffer); |
| 145 | switch (Action.Kind) { |
| 146 | case LineEditor::CompletionAction::AK_Insert: |
| 147 | ::el_insertstr(EL, Action.Text.c_str()); |
| 148 | return CC_REFRESH; |
| 149 | |
| 150 | case LineEditor::CompletionAction::AK_ShowCompletions: |
| 151 | if (Action.Completions.empty()) { |
| 152 | return CC_REFRESH_BEEP; |
| 153 | } else { |
| 154 | // Push a Ctrl-E and a tab. The Ctrl-E causes libedit to move the cursor |
| 155 | // to the end of the line, so that when we emit a newline we will be on |
| 156 | // a new blank line. The tab causes libedit to call this function again |
| 157 | // after moving the cursor. There doesn't seem to be anything we can do |
| 158 | // from here to cause libedit to move the cursor immediately. This will |
| 159 | // break horribly if the user has rebound their keys, so for now we do |
| 160 | // not permit user rebinding. |
Benjamin Kramer | 029750f | 2014-02-01 11:26:18 +0000 | [diff] [blame] | 161 | ::el_push(EL, const_cast<char *>("\05\t")); |
Peter Collingbourne | c7d437c | 2014-01-31 23:46:14 +0000 | [diff] [blame] | 162 | |
| 163 | // This assembles the output for the continuation block above. |
| 164 | raw_string_ostream OS(Data->ContinuationOutput); |
| 165 | |
| 166 | // Move cursor to a blank line. |
| 167 | OS << "\n"; |
| 168 | |
| 169 | // Emit the completions. |
| 170 | for (std::vector<std::string>::iterator I = Action.Completions.begin(), |
| 171 | E = Action.Completions.end(); |
| 172 | I != E; ++I) { |
| 173 | OS << *I << "\n"; |
| 174 | } |
| 175 | |
| 176 | // Fool libedit into thinking nothing has changed. Reprint its prompt |
| 177 | // and the user input. Note that the cursor will remain at the end of |
| 178 | // the line after this. |
| 179 | OS << Data->LE->getPrompt() |
| 180 | << StringRef(LI->buffer, LI->lastchar - LI->buffer); |
| 181 | |
| 182 | // This is the number of characters we need to tell libedit to go back: |
| 183 | // the distance between end of line and the original cursor position. |
| 184 | Data->PrevCount = LI->lastchar - LI->cursor; |
| 185 | |
| 186 | return CC_REFRESH; |
| 187 | } |
| 188 | } |
Peter Collingbourne | c7d437c | 2014-01-31 23:46:14 +0000 | [diff] [blame] | 189 | } |
Benjamin Kramer | 029750f | 2014-02-01 11:26:18 +0000 | [diff] [blame] | 190 | return CC_ERROR; |
Peter Collingbourne | c7d437c | 2014-01-31 23:46:14 +0000 | [diff] [blame] | 191 | } |
| 192 | |
| 193 | LineEditor::LineEditor(StringRef ProgName, StringRef HistoryPath, FILE *In, |
| 194 | FILE *Out, FILE *Err) |
| 195 | : Prompt((ProgName + "> ").str()), HistoryPath(HistoryPath), |
| 196 | Data(new InternalData) { |
| 197 | if (HistoryPath.empty()) |
| 198 | this->HistoryPath = getDefaultHistoryPath(ProgName); |
| 199 | |
| 200 | Data->LE = this; |
Peter Collingbourne | 45b4c49 | 2014-02-04 20:04:46 +0000 | [diff] [blame] | 201 | Data->Out = Out; |
Peter Collingbourne | c7d437c | 2014-01-31 23:46:14 +0000 | [diff] [blame] | 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 | |
| 229 | LineEditor::~LineEditor() { |
| 230 | saveHistory(); |
| 231 | |
Peter Collingbourne | c7d437c | 2014-01-31 23:46:14 +0000 | [diff] [blame] | 232 | ::history_end(Data->Hist); |
| 233 | ::el_end(Data->EL); |
Peter Collingbourne | 45b4c49 | 2014-02-04 20:04:46 +0000 | [diff] [blame] | 234 | ::fwrite("\n", 1, 1, Data->Out); |
Peter Collingbourne | c7d437c | 2014-01-31 23:46:14 +0000 | [diff] [blame] | 235 | } |
| 236 | |
| 237 | void LineEditor::saveHistory() { |
| 238 | if (!HistoryPath.empty()) { |
| 239 | HistEvent HE; |
| 240 | ::history(Data->Hist, &HE, H_SAVE, HistoryPath.c_str()); |
| 241 | } |
| 242 | } |
| 243 | |
| 244 | void LineEditor::loadHistory() { |
| 245 | if (!HistoryPath.empty()) { |
| 246 | HistEvent HE; |
| 247 | ::history(Data->Hist, &HE, H_LOAD, HistoryPath.c_str()); |
| 248 | } |
| 249 | } |
| 250 | |
| 251 | 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 Optional<std::string>(); |
| 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 |
| 273 | |
| 274 | // Simple fgets-based implementation. |
| 275 | |
| 276 | struct LineEditor::InternalData { |
| 277 | FILE *In; |
| 278 | FILE *Out; |
| 279 | }; |
| 280 | |
| 281 | LineEditor::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 | |
| 288 | LineEditor::~LineEditor() { |
| 289 | ::fwrite("\n", 1, 1, Data->Out); |
| 290 | } |
| 291 | |
| 292 | void LineEditor::saveHistory() {} |
| 293 | void LineEditor::loadHistory() {} |
| 294 | |
| 295 | 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 Optional<std::string>(); |
| 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 |