• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
35 namespace v8 {
36 
37 
38 namespace i = v8::internal;
39 
40 
41 // A single counter in a counter collection.
42 class Counter {
43  public:
44   static const int kMaxNameSize = 64;
45   int32_t* Bind(const char* name, bool histogram);
ptr()46   int32_t* ptr() { return &count_; }
count()47   int32_t count() { return count_; }
sample_total()48   int32_t sample_total() { return sample_total_; }
is_histogram()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
62 class 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 
76 class CounterMap {
77  public:
CounterMap()78   CounterMap(): hash_map_(Match) { }
Lookup(const char * name)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   }
Set(const char * name,Counter * value)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:
Iterator(CounterMap * map)97     explicit Iterator(CounterMap* map)
98         : map_(&map->hash_map_), entry_(map_->Start()) { }
Next()99     void Next() { entry_ = map_->Next(entry_); }
More()100     bool More() { return entry_ != NULL; }
CurrentKey()101     const char* CurrentKey() { return static_cast<const char*>(entry_->key); }
CurrentValue()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 
114 class 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 
utility_context()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 
207 class LineEditor {
208  public:
209   enum Type { DUMB = 0, READLINE = 1 };
210   LineEditor(Type type, const char* name);
~LineEditor()211   virtual ~LineEditor() { }
212 
213   virtual i::SmartPointer<char> Prompt(const char* prompt) = 0;
Open()214   virtual bool Open() { return true; }
Close()215   virtual bool Close() { return true; }
AddHistory(const char * str)216   virtual void AddHistory(const char* str) { }
217 
name()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