1// Copyright 2009 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#ifndef V8_D8_H_
29#define V8_D8_H_
30
31#include "v8.h"
32#include "hashmap.h"
33
34
35namespace v8 {
36
37
38namespace i = v8::internal;
39
40
41// A single counter in a counter collection.
42class Counter {
43 public:
44  static const int kMaxNameSize = 64;
45  int32_t* Bind(const char* name, bool histogram);
46  int32_t* ptr() { return &count_; }
47  int32_t count() { return count_; }
48  int32_t sample_total() { return sample_total_; }
49  bool is_histogram() { return is_histogram_; }
50  void AddSample(int32_t sample);
51 private:
52  int32_t count_;
53  int32_t sample_total_;
54  bool is_histogram_;
55  uint8_t name_[kMaxNameSize];
56};
57
58
59// A set of counters and associated information.  An instance of this
60// class is stored directly in the memory-mapped counters file if
61// the --map-counters options is used
62class CounterCollection {
63 public:
64  CounterCollection();
65  Counter* GetNextCounter();
66 private:
67  static const unsigned kMaxCounters = 256;
68  uint32_t magic_number_;
69  uint32_t max_counters_;
70  uint32_t max_name_size_;
71  uint32_t counters_in_use_;
72  Counter counters_[kMaxCounters];
73};
74
75
76class CounterMap {
77 public:
78  CounterMap(): hash_map_(Match) { }
79  Counter* Lookup(const char* name) {
80    i::HashMap::Entry* answer = hash_map_.Lookup(
81        const_cast<char*>(name),
82        Hash(name),
83        false);
84    if (!answer) return NULL;
85    return reinterpret_cast<Counter*>(answer->value);
86  }
87  void Set(const char* name, Counter* value) {
88    i::HashMap::Entry* answer = hash_map_.Lookup(
89        const_cast<char*>(name),
90        Hash(name),
91        true);
92    ASSERT(answer != NULL);
93    answer->value = value;
94  }
95  class Iterator {
96   public:
97    explicit Iterator(CounterMap* map)
98        : map_(&map->hash_map_), entry_(map_->Start()) { }
99    void Next() { entry_ = map_->Next(entry_); }
100    bool More() { return entry_ != NULL; }
101    const char* CurrentKey() { return static_cast<const char*>(entry_->key); }
102    Counter* CurrentValue() { return static_cast<Counter*>(entry_->value); }
103   private:
104    i::HashMap* map_;
105    i::HashMap::Entry* entry_;
106  };
107 private:
108  static int Hash(const char* name);
109  static bool Match(void* key1, void* key2);
110  i::HashMap hash_map_;
111};
112
113
114class Shell: public i::AllStatic {
115 public:
116  static bool ExecuteString(Handle<String> source,
117                            Handle<Value> name,
118                            bool print_result,
119                            bool report_exceptions);
120  static const char* ToCString(const v8::String::Utf8Value& value);
121  static void ReportException(TryCatch* try_catch);
122  static void Initialize();
123  static void OnExit();
124  static int* LookupCounter(const char* name);
125  static void* CreateHistogram(const char* name,
126                               int min,
127                               int max,
128                               size_t buckets);
129  static void AddHistogramSample(void* histogram, int sample);
130  static void MapCounters(const char* name);
131  static Handle<String> ReadFile(const char* name);
132  static void RunShell();
133  static int Main(int argc, char* argv[]);
134  static Handle<Array> GetCompletions(Handle<String> text,
135                                      Handle<String> full);
136#ifdef ENABLE_DEBUGGER_SUPPORT
137  static Handle<Object> DebugMessageDetails(Handle<String> message);
138  static Handle<Value> DebugCommandToJSONRequest(Handle<String> command);
139#endif
140
141#ifdef WIN32
142#undef Yield
143#endif
144
145  static Handle<Value> Print(const Arguments& args);
146  static Handle<Value> Write(const Arguments& args);
147  static Handle<Value> Yield(const Arguments& args);
148  static Handle<Value> Quit(const Arguments& args);
149  static Handle<Value> Version(const Arguments& args);
150  static Handle<Value> Read(const Arguments& args);
151  static Handle<Value> ReadLine(const Arguments& args);
152  static Handle<Value> Load(const Arguments& args);
153  // The OS object on the global object contains methods for performing
154  // operating system calls:
155  //
156  // os.system("program_name", ["arg1", "arg2", ...], timeout1, timeout2) will
157  // run the command, passing the arguments to the program.  The standard output
158  // of the program will be picked up and returned as a multiline string.  If
159  // timeout1 is present then it should be a number.  -1 indicates no timeout
160  // and a positive number is used as a timeout in milliseconds that limits the
161  // time spent waiting between receiving output characters from the program.
162  // timeout2, if present, should be a number indicating the limit in
163  // milliseconds on the total running time of the program.  Exceptions are
164  // thrown on timeouts or other errors or if the exit status of the program
165  // indicates an error.
166  //
167  // os.chdir(dir) changes directory to the given directory.  Throws an
168  // exception/ on error.
169  //
170  // os.setenv(variable, value) sets an environment variable.  Repeated calls to
171  // this method leak memory due to the API of setenv in the standard C library.
172  //
173  // os.umask(alue) calls the umask system call and returns the old umask.
174  //
175  // os.mkdirp(name, mask) creates a directory.  The mask (if present) is anded
176  // with the current umask.  Intermediate directories are created if necessary.
177  // An exception is not thrown if the directory already exists.  Analogous to
178  // the "mkdir -p" command.
179  static Handle<Value> OSObject(const Arguments& args);
180  static Handle<Value> System(const Arguments& args);
181  static Handle<Value> ChangeDirectory(const Arguments& args);
182  static Handle<Value> SetEnvironment(const Arguments& args);
183  static Handle<Value> UnsetEnvironment(const Arguments& args);
184  static Handle<Value> SetUMask(const Arguments& args);
185  static Handle<Value> MakeDirectory(const Arguments& args);
186  static Handle<Value> RemoveDirectory(const Arguments& args);
187
188  static void AddOSMethods(Handle<ObjectTemplate> os_template);
189
190  static Handle<Context> utility_context() { return utility_context_; }
191
192  static const char* kHistoryFileName;
193  static const char* kPrompt;
194 private:
195  static Persistent<Context> utility_context_;
196  static Persistent<Context> evaluation_context_;
197  static CounterMap* counter_map_;
198  // We statically allocate a set of local counters to be used if we
199  // don't want to store the stats in a memory-mapped file
200  static CounterCollection local_counters_;
201  static CounterCollection* counters_;
202  static i::OS::MemoryMappedFile* counters_file_;
203  static Counter* GetCounter(const char* name, bool is_histogram);
204};
205
206
207class LineEditor {
208 public:
209  enum Type { DUMB = 0, READLINE = 1 };
210  LineEditor(Type type, const char* name);
211  virtual ~LineEditor() { }
212
213  virtual i::SmartPointer<char> Prompt(const char* prompt) = 0;
214  virtual bool Open() { return true; }
215  virtual bool Close() { return true; }
216  virtual void AddHistory(const char* str) { }
217
218  const char* name() { return name_; }
219  static LineEditor* Get();
220 private:
221  Type type_;
222  const char* name_;
223  LineEditor* next_;
224  static LineEditor* first_;
225};
226
227
228}  // namespace v8
229
230
231#endif  // V8_D8_H_
232