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