src/3rdparty/v8/src/d8-readline.cc

   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
  46 namespace v8 {
  47
  48
  49 class 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
  67 static ReadLineEditor read_line_editor;
  68 char ReadLineEditor::kWordBreakCharacters[] = {' ', '\t', '\n', '"',
  69     '\\', '\'', '`', '@', '.', '>', '<', '=', ';', '|', '&', '{', '(',
  70     '\0'};
  71
  72
  73 const char* ReadLineEditor::kHistoryFileName = ".d8_history";
  74 const int ReadLineEditor::kMaxHistoryEntries = 1000;
  75
  76
  77 bool 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
  88 bool ReadLineEditor::Close() {
  89   return write_history(kHistoryFileName) == 0;
  90 }
  91
  92
  93 Handle<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
 108 void 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
 125 char** 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
 134 char* 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