1// Copyright 2012 the V8 project authors. All rights reserved. 2// Redistribution and use in source and binary forms, with or without 3// modification, are permitted provided that the following conditions are 4// met: 5// 6// * Redistributions of source code must retain the above copyright 7// notice, this list of conditions and the following disclaimer. 8// * Redistributions in binary form must reproduce the above 9// copyright notice, this list of conditions and the following 10// disclaimer in the documentation and/or other materials provided 11// with the distribution. 12// * Neither the name of Google Inc. nor the names of its 13// contributors may be used to endorse or promote products derived 14// from this software without specific prior written permission. 15// 16// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 17// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 18// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 19// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 20// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 21// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 22// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 23// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 24// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 25// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 26// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 28 29#include <cstdio> // NOLINT 30#include <readline/readline.h> // NOLINT 31#include <readline/history.h> // NOLINT 32 33// The readline includes leaves RETURN defined which breaks V8 compilation. 34#undef RETURN 35 36#include "d8.h" 37 38 39// There are incompatibilities between different versions and different 40// implementations of readline. This smooths out one known incompatibility. 41#if RL_READLINE_VERSION >= 0x0500 42#define completion_matches rl_completion_matches 43#endif 44 45 46namespace v8 { 47 48 49class ReadLineEditor: public LineEditor { 50 public: 51 ReadLineEditor() : LineEditor(LineEditor::READLINE, "readline") { } 52 virtual Handle<String> Prompt(const char* prompt); 53 virtual bool Open(); 54 virtual bool Close(); 55 virtual void AddHistory(const char* str); 56 57 static const char* kHistoryFileName; 58 static const int kMaxHistoryEntries; 59 60 private: 61 static char** AttemptedCompletion(const char* text, int start, int end); 62 static char* CompletionGenerator(const char* text, int state); 63 static char kWordBreakCharacters[]; 64}; 65 66 67static ReadLineEditor read_line_editor; 68char ReadLineEditor::kWordBreakCharacters[] = {' ', '\t', '\n', '"', 69 '\\', '\'', '`', '@', '.', '>', '<', '=', ';', '|', '&', '{', '(', 70 '\0'}; 71 72 73const char* ReadLineEditor::kHistoryFileName = ".d8_history"; 74const int ReadLineEditor::kMaxHistoryEntries = 1000; 75 76 77bool ReadLineEditor::Open() { 78 rl_initialize(); 79 rl_attempted_completion_function = AttemptedCompletion; 80 rl_completer_word_break_characters = kWordBreakCharacters; 81 rl_bind_key('\t', rl_complete); 82 using_history(); 83 stifle_history(kMaxHistoryEntries); 84 return read_history(kHistoryFileName) == 0; 85} 86 87 88bool ReadLineEditor::Close() { 89 return write_history(kHistoryFileName) == 0; 90} 91 92 93Handle<String> ReadLineEditor::Prompt(const char* prompt) { 94 char* result = NULL; 95 { // Release lock for blocking input. 96 Unlocker unlock(Isolate::GetCurrent()); 97 result = readline(prompt); 98 } 99 if (result != NULL) { 100 AddHistory(result); 101 } else { 102 return Handle<String>(); 103 } 104 return String::New(result); 105} 106 107 108void ReadLineEditor::AddHistory(const char* str) { 109 // Do not record empty input. 110 if (strlen(str) == 0) return; 111 // Remove duplicate history entry. 112 history_set_pos(history_length-1); 113 if (current_history()) { 114 do { 115 if (strcmp(current_history()->line, str) == 0) { 116 remove_history(where_history()); 117 break; 118 } 119 } while (previous_history()); 120 } 121 add_history(str); 122} 123 124 125char** ReadLineEditor::AttemptedCompletion(const char* text, 126 int start, 127 int end) { 128 char** result = completion_matches(text, CompletionGenerator); 129 rl_attempted_completion_over = true; 130 return result; 131} 132 133 134char* ReadLineEditor::CompletionGenerator(const char* text, int state) { 135 static unsigned current_index; 136 static Persistent<Array> current_completions; 137 if (state == 0) { 138 HandleScope scope; 139 Local<String> full_text = String::New(rl_line_buffer, rl_point); 140 Handle<Array> completions = 141 Shell::GetCompletions(String::New(text), full_text); 142 current_completions = Persistent<Array>::New(completions); 143 current_index = 0; 144 } 145 if (current_index < current_completions->Length()) { 146 HandleScope scope; 147 Handle<Integer> index = Integer::New(current_index); 148 Handle<Value> str_obj = current_completions->Get(index); 149 current_index++; 150 String::Utf8Value str(str_obj); 151 return strdup(*str); 152 } else { 153 current_completions.Dispose(); 154 current_completions.Clear(); 155 return NULL; 156 } 157} 158 159 160} // namespace v8 161