d8-readline.cc 4.31 KB
Newer Older
1
// Copyright 2012 the V8 project authors. All rights reserved.
2 3
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
4

5
#include <stdio.h>  // NOLINT
6
#include <string.h> // NOLINT
antonm@chromium.org's avatar
antonm@chromium.org committed
7 8
#include <readline/readline.h> // NOLINT
#include <readline/history.h> // NOLINT
9

10 11
// The readline includes leaves RETURN defined which breaks V8 compilation.
#undef RETURN
12

13
#include "src/d8.h"
14

15
// There are incompatibilities between different versions and different
16
// implementations of readline.  This smooths out one known incompatibility.
17 18 19 20 21
#if RL_READLINE_VERSION >= 0x0500
#define completion_matches rl_completion_matches
#endif


22 23 24 25 26 27
namespace v8 {


class ReadLineEditor: public LineEditor {
 public:
  ReadLineEditor() : LineEditor(LineEditor::READLINE, "readline") { }
28
  virtual Handle<String> Prompt(const char* prompt);
29
  virtual bool Open(Isolate* isolate);
30 31
  virtual bool Close();
  virtual void AddHistory(const char* str);
32 33 34 35

  static const char* kHistoryFileName;
  static const int kMaxHistoryEntries;

36
 private:
37
#ifndef V8_SHARED
38 39
  static char** AttemptedCompletion(const char* text, int start, int end);
  static char* CompletionGenerator(const char* text, int state);
40
#endif  // V8_SHARED
41
  static char kWordBreakCharacters[];
42 43

  Isolate* isolate_;
44 45 46 47 48 49 50 51 52
};


static ReadLineEditor read_line_editor;
char ReadLineEditor::kWordBreakCharacters[] = {' ', '\t', '\n', '"',
    '\\', '\'', '`', '@', '.', '>', '<', '=', ';', '|', '&', '{', '(',
    '\0'};


53 54 55 56
const char* ReadLineEditor::kHistoryFileName = ".d8_history";
const int ReadLineEditor::kMaxHistoryEntries = 1000;


57 58 59
bool ReadLineEditor::Open(Isolate* isolate) {
  isolate_ = isolate;

60
  rl_initialize();
61 62 63 64 65 66

#ifdef V8_SHARED
  // Don't do completion on shared library mode
  // http://cnswww.cns.cwru.edu/php/chet/readline/readline.html#SEC24
  rl_bind_key('\t', rl_insert);
#else
67
  rl_attempted_completion_function = AttemptedCompletion;
68 69
#endif  // V8_SHARED

70 71 72
  rl_completer_word_break_characters = kWordBreakCharacters;
  rl_bind_key('\t', rl_complete);
  using_history();
73 74
  stifle_history(kMaxHistoryEntries);
  return read_history(kHistoryFileName) == 0;
75 76 77 78
}


bool ReadLineEditor::Close() {
79
  return write_history(kHistoryFileName) == 0;
80 81 82
}


83
Handle<String> ReadLineEditor::Prompt(const char* prompt) {
84
  char* result = NULL;
85
  result = readline(prompt);
86 87 88
  if (result == NULL) return Handle<String>();
  AddHistory(result);
  return String::NewFromUtf8(isolate_, result);
89 90 91 92
}


void ReadLineEditor::AddHistory(const char* str) {
93 94 95 96 97 98 99 100 101 102 103 104
  // Do not record empty input.
  if (strlen(str) == 0) return;
  // Remove duplicate history entry.
  history_set_pos(history_length-1);
  if (current_history()) {
    do {
      if (strcmp(current_history()->line, str) == 0) {
        remove_history(where_history());
        break;
      }
    } while (previous_history());
  }
105 106 107 108
  add_history(str);
}


109
#ifndef V8_SHARED
110 111 112
char** ReadLineEditor::AttemptedCompletion(const char* text,
                                           int start,
                                           int end) {
113
  char** result = completion_matches(text, CompletionGenerator);
114 115 116 117 118 119 120 121
  rl_attempted_completion_over = true;
  return result;
}


char* ReadLineEditor::CompletionGenerator(const char* text, int state) {
  static unsigned current_index;
  static Persistent<Array> current_completions;
122
  Isolate* isolate = read_line_editor.isolate_;
123
  HandleScope scope(isolate);
124
  Handle<Array> completions;
125
  if (state == 0) {
126 127 128 129 130 131 132
    Local<String> full_text = String::NewFromUtf8(isolate,
                                                  rl_line_buffer,
                                                  String::kNormalString,
                                                  rl_point);
    completions = Shell::GetCompletions(isolate,
                                        String::NewFromUtf8(isolate, text),
                                        full_text);
133
    current_completions.Reset(isolate, completions);
134
    current_index = 0;
135 136
  } else {
    completions = Local<Array>::New(isolate, current_completions);
137
  }
138
  if (current_index < completions->Length()) {
139
    Handle<Integer> index = Integer::New(isolate, current_index);
140
    Handle<Value> str_obj = completions->Get(index);
141 142 143 144
    current_index++;
    String::Utf8Value str(str_obj);
    return strdup(*str);
  } else {
145
    current_completions.Reset();
146 147 148
    return NULL;
  }
}
149
#endif  // V8_SHARED
150 151 152


}  // namespace v8