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); 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 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: 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 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 void ReportException(TryCatch* try_catch); 121 static void Initialize(); 122 static void OnExit(); 123 static int* LookupCounter(const char* name); 124 static void* CreateHistogram(const char* name, 125 int min, 126 int max, 127 size_t buckets); 128 static void AddHistogramSample(void* histogram, int sample); 129 static void MapCounters(const char* name); 130 static Handle<String> ReadFile(const char* name); 131 static void RunShell(); 132 static int Main(int argc, char* argv[]); 133 static Handle<Array> GetCompletions(Handle<String> text, 134 Handle<String> full); 135 #ifdef ENABLE_DEBUGGER_SUPPORT 136 static Handle<Object> DebugMessageDetails(Handle<String> message); 137 static Handle<Value> DebugCommandToJSONRequest(Handle<String> command); 138 #endif 139 140 static Handle<Value> Print(const Arguments& args); 141 static Handle<Value> Write(const Arguments& args); 142 static Handle<Value> Yield(const Arguments& args); 143 static Handle<Value> Quit(const Arguments& args); 144 static Handle<Value> Version(const Arguments& args); 145 static Handle<Value> Read(const Arguments& args); 146 static Handle<Value> ReadLine(const Arguments& args); 147 static Handle<Value> Load(const Arguments& args); 148 // The OS object on the global object contains methods for performing 149 // operating system calls: 150 // 151 // os.system("program_name", ["arg1", "arg2", ...], timeout1, timeout2) will 152 // run the command, passing the arguments to the program. The standard output 153 // of the program will be picked up and returned as a multiline string. If 154 // timeout1 is present then it should be a number. -1 indicates no timeout 155 // and a positive number is used as a timeout in milliseconds that limits the 156 // time spent waiting between receiving output characters from the program. 157 // timeout2, if present, should be a number indicating the limit in 158 // milliseconds on the total running time of the program. Exceptions are 159 // thrown on timeouts or other errors or if the exit status of the program 160 // indicates an error. 161 // 162 // os.chdir(dir) changes directory to the given directory. Throws an 163 // exception/ on error. 164 // 165 // os.setenv(variable, value) sets an environment variable. Repeated calls to 166 // this method leak memory due to the API of setenv in the standard C library. 167 // 168 // os.umask(alue) calls the umask system call and returns the old umask. 169 // 170 // os.mkdirp(name, mask) creates a directory. The mask (if present) is anded 171 // with the current umask. Intermediate directories are created if necessary. 172 // An exception is not thrown if the directory already exists. Analogous to 173 // the "mkdir -p" command. 174 static Handle<Value> OSObject(const Arguments& args); 175 static Handle<Value> System(const Arguments& args); 176 static Handle<Value> ChangeDirectory(const Arguments& args); 177 static Handle<Value> SetEnvironment(const Arguments& args); 178 static Handle<Value> SetUMask(const Arguments& args); 179 static Handle<Value> MakeDirectory(const Arguments& args); 180 static Handle<Value> RemoveDirectory(const Arguments& args); 181 182 static void AddOSMethods(Handle<ObjectTemplate> os_template); 183 184 static Handle<Context> utility_context() { return utility_context_; } 185 186 static const char* kHistoryFileName; 187 static const char* kPrompt; 188 private: 189 static Persistent<Context> utility_context_; 190 static Persistent<Context> evaluation_context_; 191 static CounterMap* counter_map_; 192 // We statically allocate a set of local counters to be used if we 193 // don't want to store the stats in a memory-mapped file 194 static CounterCollection local_counters_; 195 static CounterCollection* counters_; 196 static i::OS::MemoryMappedFile* counters_file_; 197 static Counter* GetCounter(const char* name, bool is_histogram); 198 }; 199 200 201 class LineEditor { 202 public: 203 enum Type { DUMB = 0, READLINE = 1 }; 204 LineEditor(Type type, const char* name); 205 virtual ~LineEditor() { } 206 207 virtual i::SmartPointer<char> Prompt(const char* prompt) = 0; 208 virtual bool Open() { return true; } 209 virtual bool Close() { return true; } 210 virtual void AddHistory(const char* str) { } 211 212 const char* name() { return name_; } 213 static LineEditor* Get(); 214 private: 215 Type type_; 216 const char* name_; 217 LineEditor* next_; 218 static LineEditor* first_; 219 }; 220 221 222 } // namespace v8 223 224 225 #endif // V8_D8_H_ 226
