blob: 2d30a1c39ab84e0de1f2d28d72a9e4207792e46e [file] [log] [blame]
erik.corry@gmail.comf2038fb2012-01-16 11:42:08 +00001// Copyright 2012 the V8 project authors. All rights reserved.
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00002// 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
ulan@chromium.orgd6899c32012-05-18 14:12:25 +000029// Defined when linking against shared lib on Windows.
30#if defined(USING_V8_SHARED) && !defined(V8_SHARED)
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +000031#define V8_SHARED
svenpanne@chromium.org84bcc552011-07-18 09:50:57 +000032#endif
33
svenpanne@chromium.org6d786c92011-06-15 10:58:27 +000034#ifdef COMPRESS_STARTUP_DATA_BZ2
35#include <bzlib.h>
36#endif
svenpanne@chromium.org84bcc552011-07-18 09:50:57 +000037
ager@chromium.orgbb29dc92009-03-24 13:25:23 +000038#include <errno.h>
svenpanne@chromium.org6d786c92011-06-15 10:58:27 +000039#include <stdlib.h>
svenpanne@chromium.org84bcc552011-07-18 09:50:57 +000040#include <string.h>
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +000041#include <sys/stat.h>
ager@chromium.orga74f0da2008-12-03 16:05:52 +000042
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +000043#ifdef V8_SHARED
svenpanne@chromium.org84bcc552011-07-18 09:50:57 +000044#include <assert.h>
45#include "../include/v8-testing.h"
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +000046#endif // V8_SHARED
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +000047
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +000048#include "d8.h"
svenpanne@chromium.org84bcc552011-07-18 09:50:57 +000049
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +000050#ifndef V8_SHARED
svenpanne@chromium.org84bcc552011-07-18 09:50:57 +000051#include "api.h"
52#include "checks.h"
christian.plesner.hansen@gmail.com37abdec2009-01-06 14:43:28 +000053#include "d8-debug.h"
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +000054#include "debug.h"
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +000055#include "natives.h"
ager@chromium.orgddb913d2009-01-27 10:01:48 +000056#include "platform.h"
svenpanne@chromium.org84bcc552011-07-18 09:50:57 +000057#include "v8.h"
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +000058#endif // V8_SHARED
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +000059
sgjesse@chromium.org6db88712011-07-11 11:41:22 +000060#if !defined(_WIN32) && !defined(_WIN64)
61#include <unistd.h> // NOLINT
62#endif
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +000063
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +000064#ifndef ASSERT
svenpanne@chromium.org84bcc552011-07-18 09:50:57 +000065#define ASSERT(condition) assert(condition)
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +000066#endif
svenpanne@chromium.org84bcc552011-07-18 09:50:57 +000067
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +000068namespace v8 {
69
ulan@chromium.org8e8d8822012-11-23 14:36:46 +000070
71static Handle<Value> Throw(const char* message) {
72 return ThrowException(String::New(message));
73}
74
75
76// TODO(rossberg): should replace these by proper uses of HasInstance,
77// once we figure out a good way to make the templates global.
78const char kArrayBufferMarkerPropName[] = "d8::_is_array_buffer_";
79const char kArrayMarkerPropName[] = "d8::_is_typed_array_";
80
81
82#define FOR_EACH_SYMBOL(V) \
83 V(ArrayBuffer, "ArrayBuffer") \
84 V(ArrayBufferMarkerPropName, kArrayBufferMarkerPropName) \
85 V(ArrayMarkerPropName, kArrayMarkerPropName) \
86 V(buffer, "buffer") \
87 V(byteLength, "byteLength") \
88 V(byteOffset, "byteOffset") \
89 V(BYTES_PER_ELEMENT, "BYTES_PER_ELEMENT") \
90 V(length, "length")
91
92
93class Symbols {
94 public:
95 explicit Symbols(Isolate* isolate) : isolate_(isolate) {
96 HandleScope scope;
97#define INIT_SYMBOL(name, value) \
mvstanton@chromium.orgd16d8532013-01-25 13:29:10 +000098 name##_ = Persistent<String>::New(isolate, String::NewSymbol(value));
ulan@chromium.org8e8d8822012-11-23 14:36:46 +000099 FOR_EACH_SYMBOL(INIT_SYMBOL)
100#undef INIT_SYMBOL
101 isolate->SetData(this);
102 }
103
104 ~Symbols() {
mvstanton@chromium.orgd16d8532013-01-25 13:29:10 +0000105#define DISPOSE_SYMBOL(name, value) name##_.Dispose(isolate_);
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000106 FOR_EACH_SYMBOL(DISPOSE_SYMBOL)
107#undef DISPOSE_SYMBOL
108 isolate_->SetData(NULL); // Not really needed, just to be sure...
109 }
110
111#define DEFINE_SYMBOL_GETTER(name, value) \
112 static Persistent<String> name(Isolate* isolate) { \
113 return reinterpret_cast<Symbols*>(isolate->GetData())->name##_; \
114 }
115 FOR_EACH_SYMBOL(DEFINE_SYMBOL_GETTER)
116#undef DEFINE_SYMBOL_GETTER
117
118 private:
119 Isolate* isolate_;
120#define DEFINE_MEMBER(name, value) Persistent<String> name##_;
121 FOR_EACH_SYMBOL(DEFINE_MEMBER)
122#undef DEFINE_MEMBER
123};
124
125
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +0000126LineEditor *LineEditor::current_ = NULL;
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000127
128
129LineEditor::LineEditor(Type type, const char* name)
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +0000130 : type_(type), name_(name) {
131 if (current_ == NULL || current_->type_ < type) current_ = this;
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000132}
133
134
135class DumbLineEditor: public LineEditor {
136 public:
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000137 explicit DumbLineEditor(Isolate* isolate)
138 : LineEditor(LineEditor::DUMB, "dumb"), isolate_(isolate) { }
ulan@chromium.org2efb9002012-01-19 15:36:35 +0000139 virtual Handle<String> Prompt(const char* prompt);
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000140 private:
141 Isolate* isolate_;
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000142};
143
144
ulan@chromium.org2efb9002012-01-19 15:36:35 +0000145Handle<String> DumbLineEditor::Prompt(const char* prompt) {
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000146 printf("%s", prompt);
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000147 return Shell::ReadFromStdin(isolate_);
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000148}
149
150
ulan@chromium.org2efb9002012-01-19 15:36:35 +0000151#ifndef V8_SHARED
kasperl@chromium.orgf5aa8372009-03-24 14:47:14 +0000152CounterMap* Shell::counter_map_;
ager@chromium.orga74f0da2008-12-03 16:05:52 +0000153i::OS::MemoryMappedFile* Shell::counters_file_ = NULL;
154CounterCollection Shell::local_counters_;
155CounterCollection* Shell::counters_ = &local_counters_;
sgjesse@chromium.org6db88712011-07-11 11:41:22 +0000156i::Mutex* Shell::context_mutex_(i::OS::CreateMutex());
svenpanne@chromium.org84bcc552011-07-18 09:50:57 +0000157Persistent<Context> Shell::utility_context_;
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +0000158#endif // V8_SHARED
svenpanne@chromium.org84bcc552011-07-18 09:50:57 +0000159
160Persistent<Context> Shell::evaluation_context_;
sgjesse@chromium.org6db88712011-07-11 11:41:22 +0000161ShellOptions Shell::options;
svenpanne@chromium.org84bcc552011-07-18 09:50:57 +0000162const char* Shell::kPrompt = "d8> ";
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000163
164
yangguo@chromium.org659ceec2012-01-26 07:37:54 +0000165const int MB = 1024 * 1024;
166
167
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +0000168#ifndef V8_SHARED
kasperl@chromium.orgf5aa8372009-03-24 14:47:14 +0000169bool CounterMap::Match(void* key1, void* key2) {
170 const char* name1 = reinterpret_cast<const char*>(key1);
171 const char* name2 = reinterpret_cast<const char*>(key2);
172 return strcmp(name1, name2) == 0;
173}
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +0000174#endif // V8_SHARED
kasperl@chromium.orgf5aa8372009-03-24 14:47:14 +0000175
176
iposva@chromium.org245aa852009-02-10 00:49:54 +0000177// Converts a V8 value to a C string.
ricow@chromium.orgc9c80822010-04-21 08:22:37 +0000178const char* Shell::ToCString(const v8::String::Utf8Value& value) {
iposva@chromium.org245aa852009-02-10 00:49:54 +0000179 return *value ? *value : "<string conversion failed>";
180}
181
182
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000183// Executes a string within the current v8 context.
184bool Shell::ExecuteString(Handle<String> source,
185 Handle<Value> name,
186 bool print_result,
187 bool report_exceptions) {
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +0000188#if !defined(V8_SHARED) && defined(ENABLE_DEBUGGER_SUPPORT)
svenpanne@chromium.org84bcc552011-07-18 09:50:57 +0000189 bool FLAG_debugger = i::FLAG_debugger;
190#else
191 bool FLAG_debugger = false;
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +0000192#endif // !V8_SHARED && ENABLE_DEBUGGER_SUPPORT
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000193 HandleScope handle_scope;
194 TryCatch try_catch;
sgjesse@chromium.org6db88712011-07-11 11:41:22 +0000195 options.script_executed = true;
svenpanne@chromium.org84bcc552011-07-18 09:50:57 +0000196 if (FLAG_debugger) {
christian.plesner.hansen@gmail.com37abdec2009-01-06 14:43:28 +0000197 // When debugging make exceptions appear to be uncaught.
198 try_catch.SetVerbose(true);
199 }
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000200 Handle<Script> script = Script::Compile(source, name);
201 if (script.IsEmpty()) {
202 // Print errors that happened during compilation.
svenpanne@chromium.org84bcc552011-07-18 09:50:57 +0000203 if (report_exceptions && !FLAG_debugger)
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000204 ReportException(&try_catch);
205 return false;
206 } else {
207 Handle<Value> result = script->Run();
208 if (result.IsEmpty()) {
kmillikin@chromium.org49edbdf2011-02-16 12:32:18 +0000209 ASSERT(try_catch.HasCaught());
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000210 // Print errors that happened during execution.
svenpanne@chromium.org84bcc552011-07-18 09:50:57 +0000211 if (report_exceptions && !FLAG_debugger)
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000212 ReportException(&try_catch);
213 return false;
214 } else {
kmillikin@chromium.org49edbdf2011-02-16 12:32:18 +0000215 ASSERT(!try_catch.HasCaught());
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000216 if (print_result && !result->IsUndefined()) {
217 // If all went well and the result wasn't undefined then print
218 // the returned value.
iposva@chromium.org245aa852009-02-10 00:49:54 +0000219 v8::String::Utf8Value str(result);
erik.corry@gmail.com394dbcf2011-10-27 07:38:48 +0000220 size_t count = fwrite(*str, sizeof(**str), str.length(), stdout);
221 (void) count; // Silence GCC-4.5.x "unused result" warning.
fschneider@chromium.org1805e212011-09-05 10:49:12 +0000222 printf("\n");
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000223 }
224 return true;
225 }
226 }
227}
228
229
230Handle<Value> Shell::Print(const Arguments& args) {
christian.plesner.hansen@gmail.com5a6af922009-08-12 14:20:51 +0000231 Handle<Value> val = Write(args);
232 printf("\n");
rossberg@chromium.org717967f2011-07-20 13:44:42 +0000233 fflush(stdout);
christian.plesner.hansen@gmail.com5a6af922009-08-12 14:20:51 +0000234 return val;
235}
236
237
238Handle<Value> Shell::Write(const Arguments& args) {
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000239 for (int i = 0; i < args.Length(); i++) {
240 HandleScope handle_scope;
christian.plesner.hansen@gmail.com5a6af922009-08-12 14:20:51 +0000241 if (i != 0) {
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000242 printf(" ");
243 }
ulan@chromium.org56c14af2012-09-20 12:51:09 +0000244
245 // Explicitly catch potential exceptions in toString().
246 v8::TryCatch try_catch;
247 Handle<String> str_obj = args[i]->ToString();
248 if (try_catch.HasCaught()) return try_catch.ReThrow();
249
250 v8::String::Utf8Value str(str_obj);
ricow@chromium.org2c99e282011-07-28 09:15:17 +0000251 int n = static_cast<int>(fwrite(*str, sizeof(**str), str.length(), stdout));
sgjesse@chromium.orgac6aa172009-12-04 12:29:05 +0000252 if (n != str.length()) {
253 printf("Error in fwrite\n");
lrn@chromium.org34e60782011-09-15 07:25:40 +0000254 Exit(1);
sgjesse@chromium.orgac6aa172009-12-04 12:29:05 +0000255 }
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000256 }
hpayer@chromium.org8432c912013-02-28 15:55:26 +0000257 return Undefined(args.GetIsolate());
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000258}
259
260
ricow@chromium.org55ee8072011-09-08 16:33:10 +0000261Handle<Value> Shell::EnableProfiler(const Arguments& args) {
262 V8::ResumeProfiler();
hpayer@chromium.org8432c912013-02-28 15:55:26 +0000263 return Undefined(args.GetIsolate());
ricow@chromium.org55ee8072011-09-08 16:33:10 +0000264}
265
266
267Handle<Value> Shell::DisableProfiler(const Arguments& args) {
268 V8::PauseProfiler();
hpayer@chromium.org8432c912013-02-28 15:55:26 +0000269 return Undefined(args.GetIsolate());
ricow@chromium.org55ee8072011-09-08 16:33:10 +0000270}
271
272
ager@chromium.org65dad4b2009-04-23 08:48:43 +0000273Handle<Value> Shell::Read(const Arguments& args) {
ager@chromium.org65dad4b2009-04-23 08:48:43 +0000274 String::Utf8Value file(args[0]);
275 if (*file == NULL) {
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000276 return Throw("Error loading file");
ager@chromium.org65dad4b2009-04-23 08:48:43 +0000277 }
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000278 Handle<String> source = ReadFile(args.GetIsolate(), *file);
ager@chromium.org65dad4b2009-04-23 08:48:43 +0000279 if (source.IsEmpty()) {
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000280 return Throw("Error loading file");
ager@chromium.org65dad4b2009-04-23 08:48:43 +0000281 }
282 return source;
283}
284
285
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000286Handle<String> Shell::ReadFromStdin(Isolate* isolate) {
svenpanne@chromium.org84bcc552011-07-18 09:50:57 +0000287 static const int kBufferSize = 256;
288 char buffer[kBufferSize];
289 Handle<String> accumulator = String::New("");
svenpanne@chromium.org84bcc552011-07-18 09:50:57 +0000290 int length;
lrn@chromium.orgd4e9e222011-08-03 12:01:58 +0000291 while (true) {
292 // Continue reading if the line ends with an escape '\\' or the line has
293 // not been fully read into the buffer yet (does not end with '\n').
294 // If fgets gets an error, just give up.
jkummerow@chromium.org05ed9dd2012-01-23 14:42:48 +0000295 char* input = NULL;
296 { // Release lock for blocking input.
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000297 Unlocker unlock(isolate);
jkummerow@chromium.org05ed9dd2012-01-23 14:42:48 +0000298 input = fgets(buffer, kBufferSize, stdin);
299 }
300 if (input == NULL) return Handle<String>();
ricow@chromium.org2c99e282011-07-28 09:15:17 +0000301 length = static_cast<int>(strlen(buffer));
lrn@chromium.orgd4e9e222011-08-03 12:01:58 +0000302 if (length == 0) {
303 return accumulator;
304 } else if (buffer[length-1] != '\n') {
305 accumulator = String::Concat(accumulator, String::New(buffer, length));
306 } else if (length > 1 && buffer[length-2] == '\\') {
307 buffer[length-2] = '\n';
308 accumulator = String::Concat(accumulator, String::New(buffer, length-1));
309 } else {
310 return String::Concat(accumulator, String::New(buffer, length-1));
311 }
312 }
ager@chromium.orgadd848f2009-08-13 12:44:13 +0000313}
314
315
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000316Handle<Value> Shell::Load(const Arguments& args) {
317 for (int i = 0; i < args.Length(); i++) {
318 HandleScope handle_scope;
319 String::Utf8Value file(args[i]);
iposva@chromium.org245aa852009-02-10 00:49:54 +0000320 if (*file == NULL) {
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000321 return Throw("Error loading file");
iposva@chromium.org245aa852009-02-10 00:49:54 +0000322 }
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000323 Handle<String> source = ReadFile(args.GetIsolate(), *file);
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000324 if (source.IsEmpty()) {
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000325 return Throw("Error loading file");
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000326 }
kmillikin@chromium.org83e16822011-09-13 08:21:47 +0000327 if (!ExecuteString(source, String::New(*file), false, true)) {
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000328 return Throw("Error executing file");
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000329 }
330 }
hpayer@chromium.org8432c912013-02-28 15:55:26 +0000331 return Undefined(args.GetIsolate());
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000332}
333
yangguo@chromium.orgc74d6742012-06-29 15:15:45 +0000334static int32_t convertToInt(Local<Value> value_in, TryCatch* try_catch) {
yangguo@chromium.org5a11aaf2012-06-20 11:29:00 +0000335 if (value_in->IsInt32()) {
336 return value_in->Int32Value();
ricow@chromium.orgd2be9012011-06-01 06:00:58 +0000337 }
erik.corry@gmail.comf2038fb2012-01-16 11:42:08 +0000338
339 Local<Value> number = value_in->ToNumber();
340 if (try_catch->HasCaught()) return 0;
341
342 ASSERT(number->IsNumber());
343 Local<Int32> int32 = number->ToInt32();
344 if (try_catch->HasCaught() || int32.IsEmpty()) return 0;
345
yangguo@chromium.orgc74d6742012-06-29 15:15:45 +0000346 int32_t value = int32->Int32Value();
347 if (try_catch->HasCaught()) return 0;
348
349 return value;
350}
351
352
353static int32_t convertToUint(Local<Value> value_in, TryCatch* try_catch) {
354 int32_t raw_value = convertToInt(value_in, try_catch);
erik.corry@gmail.comf2038fb2012-01-16 11:42:08 +0000355 if (try_catch->HasCaught()) return 0;
356
357 if (raw_value < 0) {
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000358 Throw("Array length must not be negative.");
erik.corry@gmail.comf2038fb2012-01-16 11:42:08 +0000359 return 0;
360 }
361
svenpanne@chromium.org84bcc552011-07-18 09:50:57 +0000362 static const int kMaxLength = 0x3fffffff;
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +0000363#ifndef V8_SHARED
svenpanne@chromium.org84bcc552011-07-18 09:50:57 +0000364 ASSERT(kMaxLength == i::ExternalArray::kMaxLength);
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +0000365#endif // V8_SHARED
erik.corry@gmail.comf2038fb2012-01-16 11:42:08 +0000366 if (raw_value > static_cast<int32_t>(kMaxLength)) {
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000367 Throw("Array length exceeds maximum length.");
erik.corry@gmail.comf2038fb2012-01-16 11:42:08 +0000368 }
yangguo@chromium.org5a11aaf2012-06-20 11:29:00 +0000369 return raw_value;
erik.corry@gmail.comf2038fb2012-01-16 11:42:08 +0000370}
371
372
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000373Handle<Value> Shell::CreateExternalArrayBuffer(Isolate* isolate,
374 Handle<Object> buffer,
yangguo@chromium.orgc74d6742012-06-29 15:15:45 +0000375 int32_t length) {
rossberg@chromium.org400388e2012-06-06 09:29:22 +0000376 static const int32_t kMaxSize = 0x7fffffff;
377 // Make sure the total size fits into a (signed) int.
378 if (length < 0 || length > kMaxSize) {
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000379 return Throw("ArrayBuffer exceeds maximum size (2G)");
rossberg@chromium.org400388e2012-06-06 09:29:22 +0000380 }
381 uint8_t* data = new uint8_t[length];
382 if (data == NULL) {
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000383 return Throw("Memory allocation failed");
rossberg@chromium.org400388e2012-06-06 09:29:22 +0000384 }
385 memset(data, 0, length);
386
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000387 buffer->SetHiddenValue(Symbols::ArrayBufferMarkerPropName(isolate), True());
mvstanton@chromium.orgd16d8532013-01-25 13:29:10 +0000388 Persistent<Object> persistent_array =
389 Persistent<Object>::New(isolate, buffer);
390 persistent_array.MakeWeak(isolate, data, ExternalArrayWeakCallback);
391 persistent_array.MarkIndependent(isolate);
rossberg@chromium.org400388e2012-06-06 09:29:22 +0000392 V8::AdjustAmountOfExternalAllocatedMemory(length);
393
394 buffer->SetIndexedPropertiesToExternalArrayData(
395 data, v8::kExternalByteArray, length);
hpayer@chromium.org8432c912013-02-28 15:55:26 +0000396 buffer->Set(Symbols::byteLength(isolate),
397 Int32::New(length, isolate),
398 ReadOnly);
rossberg@chromium.org400388e2012-06-06 09:29:22 +0000399
400 return buffer;
401}
402
403
yangguo@chromium.orgc74d6742012-06-29 15:15:45 +0000404Handle<Value> Shell::ArrayBuffer(const Arguments& args) {
405 if (!args.IsConstructCall()) {
406 Handle<Value>* rec_args = new Handle<Value>[args.Length()];
407 for (int i = 0; i < args.Length(); ++i) rec_args[i] = args[i];
408 Handle<Value> result = args.Callee()->NewInstance(args.Length(), rec_args);
409 delete[] rec_args;
410 return result;
411 }
412
rossberg@chromium.org400388e2012-06-06 09:29:22 +0000413 if (args.Length() == 0) {
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000414 return Throw("ArrayBuffer constructor must have one argument");
rossberg@chromium.org400388e2012-06-06 09:29:22 +0000415 }
416 TryCatch try_catch;
417 int32_t length = convertToUint(args[0], &try_catch);
svenpanne@chromium.org619781a2012-07-05 08:22:44 +0000418 if (try_catch.HasCaught()) return try_catch.ReThrow();
rossberg@chromium.org400388e2012-06-06 09:29:22 +0000419
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000420 return CreateExternalArrayBuffer(args.GetIsolate(), args.This(), length);
yangguo@chromium.orgc74d6742012-06-29 15:15:45 +0000421}
422
423
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000424Handle<Object> Shell::CreateExternalArray(Isolate* isolate,
425 Handle<Object> array,
yangguo@chromium.orgc74d6742012-06-29 15:15:45 +0000426 Handle<Object> buffer,
427 ExternalArrayType type,
428 int32_t length,
429 int32_t byteLength,
430 int32_t byteOffset,
431 int32_t element_size) {
432 ASSERT(element_size == 1 || element_size == 2 ||
433 element_size == 4 || element_size == 8);
434 ASSERT(byteLength == length * element_size);
435
436 void* data = buffer->GetIndexedPropertiesExternalArrayData();
437 ASSERT(data != NULL);
438
439 array->SetIndexedPropertiesToExternalArrayData(
440 static_cast<uint8_t*>(data) + byteOffset, type, length);
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000441 array->SetHiddenValue(Symbols::ArrayMarkerPropName(isolate),
hpayer@chromium.org8432c912013-02-28 15:55:26 +0000442 Int32::New(type, isolate));
443 array->Set(Symbols::byteLength(isolate),
444 Int32::New(byteLength, isolate),
445 ReadOnly);
446 array->Set(Symbols::byteOffset(isolate),
447 Int32::New(byteOffset, isolate),
448 ReadOnly);
449 array->Set(Symbols::length(isolate),
450 Int32::New(length, isolate),
451 ReadOnly);
452 array->Set(Symbols::BYTES_PER_ELEMENT(isolate),
453 Int32::New(element_size, isolate));
454 array->Set(Symbols::buffer(isolate),
455 buffer,
456 ReadOnly);
yangguo@chromium.orgc74d6742012-06-29 15:15:45 +0000457
458 return array;
rossberg@chromium.org400388e2012-06-06 09:29:22 +0000459}
460
erik.corry@gmail.comf2038fb2012-01-16 11:42:08 +0000461
462Handle<Value> Shell::CreateExternalArray(const Arguments& args,
463 ExternalArrayType type,
rossberg@chromium.org400388e2012-06-06 09:29:22 +0000464 int32_t element_size) {
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000465 Isolate* isolate = args.GetIsolate();
yangguo@chromium.orgc74d6742012-06-29 15:15:45 +0000466 if (!args.IsConstructCall()) {
467 Handle<Value>* rec_args = new Handle<Value>[args.Length()];
468 for (int i = 0; i < args.Length(); ++i) rec_args[i] = args[i];
469 Handle<Value> result = args.Callee()->NewInstance(args.Length(), rec_args);
470 delete[] rec_args;
471 return result;
472 }
473
ricow@chromium.org7ad65222011-12-19 12:13:11 +0000474 TryCatch try_catch;
rossberg@chromium.org400388e2012-06-06 09:29:22 +0000475 ASSERT(element_size == 1 || element_size == 2 ||
476 element_size == 4 || element_size == 8);
477
yangguo@chromium.orgc74d6742012-06-29 15:15:45 +0000478 // All of the following constructors are supported:
erik.corry@gmail.comf2038fb2012-01-16 11:42:08 +0000479 // TypedArray(unsigned long length)
yangguo@chromium.orgc74d6742012-06-29 15:15:45 +0000480 // TypedArray(type[] array)
481 // TypedArray(TypedArray array)
erik.corry@gmail.comf2038fb2012-01-16 11:42:08 +0000482 // TypedArray(ArrayBuffer buffer,
483 // optional unsigned long byteOffset,
484 // optional unsigned long length)
rossberg@chromium.org400388e2012-06-06 09:29:22 +0000485 Handle<Object> buffer;
486 int32_t length;
487 int32_t byteLength;
488 int32_t byteOffset;
yangguo@chromium.orgc74d6742012-06-29 15:15:45 +0000489 bool init_from_array = false;
rossberg@chromium.org400388e2012-06-06 09:29:22 +0000490 if (args.Length() == 0) {
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000491 return Throw("Array constructor must have at least one argument");
rossberg@chromium.org400388e2012-06-06 09:29:22 +0000492 }
493 if (args[0]->IsObject() &&
yangguo@chromium.orgc74d6742012-06-29 15:15:45 +0000494 !args[0]->ToObject()->GetHiddenValue(
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000495 Symbols::ArrayBufferMarkerPropName(isolate)).IsEmpty()) {
yangguo@chromium.orgc74d6742012-06-29 15:15:45 +0000496 // Construct from ArrayBuffer.
rossberg@chromium.org400388e2012-06-06 09:29:22 +0000497 buffer = args[0]->ToObject();
498 int32_t bufferLength =
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000499 convertToUint(buffer->Get(Symbols::byteLength(isolate)), &try_catch);
svenpanne@chromium.org619781a2012-07-05 08:22:44 +0000500 if (try_catch.HasCaught()) return try_catch.ReThrow();
erik.corry@gmail.comf2038fb2012-01-16 11:42:08 +0000501
verwaest@chromium.org37141392012-05-31 13:27:02 +0000502 if (args.Length() < 2 || args[1]->IsUndefined()) {
503 byteOffset = 0;
504 } else {
505 byteOffset = convertToUint(args[1], &try_catch);
svenpanne@chromium.org619781a2012-07-05 08:22:44 +0000506 if (try_catch.HasCaught()) return try_catch.ReThrow();
rossberg@chromium.org400388e2012-06-06 09:29:22 +0000507 if (byteOffset > bufferLength) {
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000508 return Throw("byteOffset out of bounds");
verwaest@chromium.org37141392012-05-31 13:27:02 +0000509 }
510 if (byteOffset % element_size != 0) {
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000511 return Throw("byteOffset must be multiple of element size");
ricow@chromium.org7ad65222011-12-19 12:13:11 +0000512 }
513 }
erik.corry@gmail.comf2038fb2012-01-16 11:42:08 +0000514
verwaest@chromium.org37141392012-05-31 13:27:02 +0000515 if (args.Length() < 3 || args[2]->IsUndefined()) {
rossberg@chromium.org400388e2012-06-06 09:29:22 +0000516 byteLength = bufferLength - byteOffset;
517 length = byteLength / element_size;
verwaest@chromium.org37141392012-05-31 13:27:02 +0000518 if (byteLength % element_size != 0) {
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000519 return Throw("buffer size must be multiple of element size");
erik.corry@gmail.comf2038fb2012-01-16 11:42:08 +0000520 }
verwaest@chromium.org37141392012-05-31 13:27:02 +0000521 } else {
522 length = convertToUint(args[2], &try_catch);
svenpanne@chromium.org619781a2012-07-05 08:22:44 +0000523 if (try_catch.HasCaught()) return try_catch.ReThrow();
rossberg@chromium.org400388e2012-06-06 09:29:22 +0000524 byteLength = length * element_size;
525 if (byteOffset + byteLength > bufferLength) {
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000526 return Throw("length out of bounds");
rossberg@chromium.org400388e2012-06-06 09:29:22 +0000527 }
erik.corry@gmail.comf2038fb2012-01-16 11:42:08 +0000528 }
verwaest@chromium.org37141392012-05-31 13:27:02 +0000529 } else {
yangguo@chromium.orgc74d6742012-06-29 15:15:45 +0000530 if (args[0]->IsObject() &&
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000531 args[0]->ToObject()->Has(Symbols::length(isolate))) {
yangguo@chromium.orgc74d6742012-06-29 15:15:45 +0000532 // Construct from array.
jkummerow@chromium.org59297c72013-01-09 16:32:23 +0000533 Local<Value> value = args[0]->ToObject()->Get(Symbols::length(isolate));
534 if (try_catch.HasCaught()) return try_catch.ReThrow();
535 length = convertToUint(value, &try_catch);
svenpanne@chromium.org619781a2012-07-05 08:22:44 +0000536 if (try_catch.HasCaught()) return try_catch.ReThrow();
yangguo@chromium.orgc74d6742012-06-29 15:15:45 +0000537 init_from_array = true;
538 } else {
539 // Construct from size.
540 length = convertToUint(args[0], &try_catch);
svenpanne@chromium.org619781a2012-07-05 08:22:44 +0000541 if (try_catch.HasCaught()) return try_catch.ReThrow();
yangguo@chromium.orgc74d6742012-06-29 15:15:45 +0000542 }
verwaest@chromium.org37141392012-05-31 13:27:02 +0000543 byteLength = length * element_size;
544 byteOffset = 0;
yangguo@chromium.orgc74d6742012-06-29 15:15:45 +0000545
546 Handle<Object> global = Context::GetCurrent()->Global();
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000547 Handle<Value> array_buffer = global->Get(Symbols::ArrayBuffer(isolate));
yangguo@chromium.orgc74d6742012-06-29 15:15:45 +0000548 ASSERT(!try_catch.HasCaught() && array_buffer->IsFunction());
hpayer@chromium.org8432c912013-02-28 15:55:26 +0000549 Handle<Value> buffer_args[] = { Uint32::New(byteLength, isolate) };
yangguo@chromium.orgc74d6742012-06-29 15:15:45 +0000550 Handle<Value> result = Handle<Function>::Cast(array_buffer)->NewInstance(
551 1, buffer_args);
552 if (try_catch.HasCaught()) return result;
rossberg@chromium.org400388e2012-06-06 09:29:22 +0000553 buffer = result->ToObject();
vegorov@chromium.org3cf47312011-06-29 13:20:01 +0000554 }
erik.corry@gmail.comf2038fb2012-01-16 11:42:08 +0000555
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000556 Handle<Object> array =
557 CreateExternalArray(isolate, args.This(), buffer, type, length,
558 byteLength, byteOffset, element_size);
erik.corry@gmail.comf2038fb2012-01-16 11:42:08 +0000559
yangguo@chromium.orgc74d6742012-06-29 15:15:45 +0000560 if (init_from_array) {
561 Handle<Object> init = args[0]->ToObject();
yangguo@chromium.org9768bf12013-01-11 14:51:07 +0000562 for (int i = 0; i < length; ++i) {
563 Local<Value> value = init->Get(i);
564 if (try_catch.HasCaught()) return try_catch.ReThrow();
565 array->Set(i, value);
566 }
yangguo@chromium.orgc74d6742012-06-29 15:15:45 +0000567 }
rossberg@chromium.org400388e2012-06-06 09:29:22 +0000568
ricow@chromium.orgd2be9012011-06-01 06:00:58 +0000569 return array;
570}
571
572
svenpanne@chromium.org619781a2012-07-05 08:22:44 +0000573Handle<Value> Shell::ArrayBufferSlice(const Arguments& args) {
yangguo@chromium.orgc74d6742012-06-29 15:15:45 +0000574 TryCatch try_catch;
575
576 if (!args.This()->IsObject()) {
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000577 return Throw("'slice' invoked on non-object receiver");
yangguo@chromium.orgc74d6742012-06-29 15:15:45 +0000578 }
579
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000580 Isolate* isolate = args.GetIsolate();
yangguo@chromium.orgc74d6742012-06-29 15:15:45 +0000581 Local<Object> self = args.This();
svenpanne@chromium.org619781a2012-07-05 08:22:44 +0000582 Local<Value> marker =
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000583 self->GetHiddenValue(Symbols::ArrayBufferMarkerPropName(isolate));
yangguo@chromium.orgc74d6742012-06-29 15:15:45 +0000584 if (marker.IsEmpty()) {
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000585 return Throw("'slice' invoked on wrong receiver type");
yangguo@chromium.orgc74d6742012-06-29 15:15:45 +0000586 }
587
yangguo@chromium.orgc74d6742012-06-29 15:15:45 +0000588 int32_t length =
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000589 convertToUint(self->Get(Symbols::byteLength(isolate)), &try_catch);
svenpanne@chromium.org619781a2012-07-05 08:22:44 +0000590 if (try_catch.HasCaught()) return try_catch.ReThrow();
yangguo@chromium.orgc74d6742012-06-29 15:15:45 +0000591
592 if (args.Length() == 0) {
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000593 return Throw("'slice' must have at least one argument");
yangguo@chromium.orgc74d6742012-06-29 15:15:45 +0000594 }
595 int32_t begin = convertToInt(args[0], &try_catch);
svenpanne@chromium.org619781a2012-07-05 08:22:44 +0000596 if (try_catch.HasCaught()) return try_catch.ReThrow();
yangguo@chromium.orgc74d6742012-06-29 15:15:45 +0000597 if (begin < 0) begin += length;
598 if (begin < 0) begin = 0;
599 if (begin > length) begin = length;
600
601 int32_t end;
602 if (args.Length() < 2 || args[1]->IsUndefined()) {
603 end = length;
604 } else {
605 end = convertToInt(args[1], &try_catch);
svenpanne@chromium.org619781a2012-07-05 08:22:44 +0000606 if (try_catch.HasCaught()) return try_catch.ReThrow();
607 if (end < 0) end += length;
608 if (end < 0) end = 0;
609 if (end > length) end = length;
610 if (end < begin) end = begin;
611 }
612
613 Local<Function> constructor = Local<Function>::Cast(self->GetConstructor());
hpayer@chromium.org8432c912013-02-28 15:55:26 +0000614 Handle<Value> new_args[] = { Uint32::New(end - begin, isolate) };
svenpanne@chromium.org619781a2012-07-05 08:22:44 +0000615 Handle<Value> result = constructor->NewInstance(1, new_args);
616 if (try_catch.HasCaught()) return result;
617 Handle<Object> buffer = result->ToObject();
618 uint8_t* dest =
619 static_cast<uint8_t*>(buffer->GetIndexedPropertiesExternalArrayData());
620 uint8_t* src = begin + static_cast<uint8_t*>(
621 self->GetIndexedPropertiesExternalArrayData());
622 memcpy(dest, src, end - begin);
623
624 return buffer;
625}
626
627
628Handle<Value> Shell::ArraySubArray(const Arguments& args) {
629 TryCatch try_catch;
630
631 if (!args.This()->IsObject()) {
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000632 return Throw("'subarray' invoked on non-object receiver");
svenpanne@chromium.org619781a2012-07-05 08:22:44 +0000633 }
634
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000635 Isolate* isolate = args.GetIsolate();
svenpanne@chromium.org619781a2012-07-05 08:22:44 +0000636 Local<Object> self = args.This();
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000637 Local<Value> marker =
638 self->GetHiddenValue(Symbols::ArrayMarkerPropName(isolate));
svenpanne@chromium.org619781a2012-07-05 08:22:44 +0000639 if (marker.IsEmpty()) {
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000640 return Throw("'subarray' invoked on wrong receiver type");
svenpanne@chromium.org619781a2012-07-05 08:22:44 +0000641 }
642
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000643 Handle<Object> buffer = self->Get(Symbols::buffer(isolate))->ToObject();
svenpanne@chromium.org619781a2012-07-05 08:22:44 +0000644 if (try_catch.HasCaught()) return try_catch.ReThrow();
645 int32_t length =
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000646 convertToUint(self->Get(Symbols::length(isolate)), &try_catch);
svenpanne@chromium.org619781a2012-07-05 08:22:44 +0000647 if (try_catch.HasCaught()) return try_catch.ReThrow();
648 int32_t byteOffset =
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000649 convertToUint(self->Get(Symbols::byteOffset(isolate)), &try_catch);
svenpanne@chromium.org619781a2012-07-05 08:22:44 +0000650 if (try_catch.HasCaught()) return try_catch.ReThrow();
651 int32_t element_size =
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000652 convertToUint(self->Get(Symbols::BYTES_PER_ELEMENT(isolate)), &try_catch);
svenpanne@chromium.org619781a2012-07-05 08:22:44 +0000653 if (try_catch.HasCaught()) return try_catch.ReThrow();
654
655 if (args.Length() == 0) {
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000656 return Throw("'subarray' must have at least one argument");
svenpanne@chromium.org619781a2012-07-05 08:22:44 +0000657 }
658 int32_t begin = convertToInt(args[0], &try_catch);
659 if (try_catch.HasCaught()) return try_catch.ReThrow();
660 if (begin < 0) begin += length;
661 if (begin < 0) begin = 0;
662 if (begin > length) begin = length;
663
664 int32_t end;
665 if (args.Length() < 2 || args[1]->IsUndefined()) {
666 end = length;
667 } else {
668 end = convertToInt(args[1], &try_catch);
669 if (try_catch.HasCaught()) return try_catch.ReThrow();
yangguo@chromium.orgc74d6742012-06-29 15:15:45 +0000670 if (end < 0) end += length;
671 if (end < 0) end = 0;
672 if (end > length) end = length;
673 if (end < begin) end = begin;
674 }
675
676 length = end - begin;
677 byteOffset += begin * element_size;
678
679 Local<Function> constructor = Local<Function>::Cast(self->GetConstructor());
680 Handle<Value> construct_args[] = {
hpayer@chromium.org8432c912013-02-28 15:55:26 +0000681 buffer, Uint32::New(byteOffset, isolate), Uint32::New(length, isolate)
yangguo@chromium.orgc74d6742012-06-29 15:15:45 +0000682 };
683 return constructor->NewInstance(3, construct_args);
684}
685
686
svenpanne@chromium.org619781a2012-07-05 08:22:44 +0000687Handle<Value> Shell::ArraySet(const Arguments& args) {
688 TryCatch try_catch;
689
690 if (!args.This()->IsObject()) {
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000691 return Throw("'set' invoked on non-object receiver");
svenpanne@chromium.org619781a2012-07-05 08:22:44 +0000692 }
693
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000694 Isolate* isolate = args.GetIsolate();
svenpanne@chromium.org619781a2012-07-05 08:22:44 +0000695 Local<Object> self = args.This();
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000696 Local<Value> marker =
697 self->GetHiddenValue(Symbols::ArrayMarkerPropName(isolate));
svenpanne@chromium.org619781a2012-07-05 08:22:44 +0000698 if (marker.IsEmpty()) {
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000699 return Throw("'set' invoked on wrong receiver type");
svenpanne@chromium.org619781a2012-07-05 08:22:44 +0000700 }
701 int32_t length =
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000702 convertToUint(self->Get(Symbols::length(isolate)), &try_catch);
svenpanne@chromium.org619781a2012-07-05 08:22:44 +0000703 if (try_catch.HasCaught()) return try_catch.ReThrow();
704 int32_t element_size =
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000705 convertToUint(self->Get(Symbols::BYTES_PER_ELEMENT(isolate)), &try_catch);
svenpanne@chromium.org619781a2012-07-05 08:22:44 +0000706 if (try_catch.HasCaught()) return try_catch.ReThrow();
707
708 if (args.Length() == 0) {
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000709 return Throw("'set' must have at least one argument");
svenpanne@chromium.org619781a2012-07-05 08:22:44 +0000710 }
711 if (!args[0]->IsObject() ||
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000712 !args[0]->ToObject()->Has(Symbols::length(isolate))) {
713 return Throw("'set' invoked with non-array argument");
svenpanne@chromium.org619781a2012-07-05 08:22:44 +0000714 }
715 Handle<Object> source = args[0]->ToObject();
716 int32_t source_length =
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000717 convertToUint(source->Get(Symbols::length(isolate)), &try_catch);
svenpanne@chromium.org619781a2012-07-05 08:22:44 +0000718 if (try_catch.HasCaught()) return try_catch.ReThrow();
719
720 int32_t offset;
721 if (args.Length() < 2 || args[1]->IsUndefined()) {
722 offset = 0;
723 } else {
724 offset = convertToUint(args[1], &try_catch);
725 if (try_catch.HasCaught()) return try_catch.ReThrow();
726 }
727 if (offset + source_length > length) {
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000728 return Throw("offset or source length out of bounds");
svenpanne@chromium.org619781a2012-07-05 08:22:44 +0000729 }
730
731 int32_t source_element_size;
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000732 if (source->GetHiddenValue(Symbols::ArrayMarkerPropName(isolate)).IsEmpty()) {
svenpanne@chromium.org619781a2012-07-05 08:22:44 +0000733 source_element_size = 0;
734 } else {
735 source_element_size =
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000736 convertToUint(source->Get(Symbols::BYTES_PER_ELEMENT(isolate)),
737 &try_catch);
svenpanne@chromium.org619781a2012-07-05 08:22:44 +0000738 if (try_catch.HasCaught()) return try_catch.ReThrow();
739 }
740
741 if (element_size == source_element_size &&
742 self->GetConstructor()->StrictEquals(source->GetConstructor())) {
743 // Use memmove on the array buffers.
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000744 Handle<Object> buffer = self->Get(Symbols::buffer(isolate))->ToObject();
svenpanne@chromium.org619781a2012-07-05 08:22:44 +0000745 if (try_catch.HasCaught()) return try_catch.ReThrow();
746 Handle<Object> source_buffer =
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000747 source->Get(Symbols::buffer(isolate))->ToObject();
svenpanne@chromium.org619781a2012-07-05 08:22:44 +0000748 if (try_catch.HasCaught()) return try_catch.ReThrow();
749 int32_t byteOffset =
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000750 convertToUint(self->Get(Symbols::byteOffset(isolate)), &try_catch);
svenpanne@chromium.org619781a2012-07-05 08:22:44 +0000751 if (try_catch.HasCaught()) return try_catch.ReThrow();
752 int32_t source_byteOffset =
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000753 convertToUint(source->Get(Symbols::byteOffset(isolate)), &try_catch);
svenpanne@chromium.org619781a2012-07-05 08:22:44 +0000754 if (try_catch.HasCaught()) return try_catch.ReThrow();
755
756 uint8_t* dest = byteOffset + offset * element_size + static_cast<uint8_t*>(
757 buffer->GetIndexedPropertiesExternalArrayData());
758 uint8_t* src = source_byteOffset + static_cast<uint8_t*>(
759 source_buffer->GetIndexedPropertiesExternalArrayData());
760 memmove(dest, src, source_length * element_size);
761 } else if (source_element_size == 0) {
762 // Source is not a typed array, copy element-wise sequentially.
763 for (int i = 0; i < source_length; ++i) {
764 self->Set(offset + i, source->Get(i));
765 if (try_catch.HasCaught()) return try_catch.ReThrow();
766 }
767 } else {
768 // Need to copy element-wise to make the right conversions.
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000769 Handle<Object> buffer = self->Get(Symbols::buffer(isolate))->ToObject();
svenpanne@chromium.org619781a2012-07-05 08:22:44 +0000770 if (try_catch.HasCaught()) return try_catch.ReThrow();
771 Handle<Object> source_buffer =
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000772 source->Get(Symbols::buffer(isolate))->ToObject();
svenpanne@chromium.org619781a2012-07-05 08:22:44 +0000773 if (try_catch.HasCaught()) return try_catch.ReThrow();
774
775 if (buffer->StrictEquals(source_buffer)) {
776 // Same backing store, need to handle overlap correctly.
777 // This gets a bit tricky in the case of different element sizes
778 // (which, of course, is extremely unlikely to ever occur in practice).
779 int32_t byteOffset =
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000780 convertToUint(self->Get(Symbols::byteOffset(isolate)), &try_catch);
svenpanne@chromium.org619781a2012-07-05 08:22:44 +0000781 if (try_catch.HasCaught()) return try_catch.ReThrow();
782 int32_t source_byteOffset =
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000783 convertToUint(source->Get(Symbols::byteOffset(isolate)), &try_catch);
svenpanne@chromium.org619781a2012-07-05 08:22:44 +0000784 if (try_catch.HasCaught()) return try_catch.ReThrow();
785
786 // Copy as much as we can from left to right.
787 int i = 0;
788 int32_t next_dest_offset = byteOffset + (offset + 1) * element_size;
789 int32_t next_src_offset = source_byteOffset + source_element_size;
790 while (i < length && next_dest_offset <= next_src_offset) {
791 self->Set(offset + i, source->Get(i));
792 ++i;
793 next_dest_offset += element_size;
794 next_src_offset += source_element_size;
795 }
796 // Of what's left, copy as much as we can from right to left.
797 int j = length - 1;
798 int32_t dest_offset = byteOffset + (offset + j) * element_size;
799 int32_t src_offset = source_byteOffset + j * source_element_size;
800 while (j >= i && dest_offset >= src_offset) {
801 self->Set(offset + j, source->Get(j));
802 --j;
803 dest_offset -= element_size;
804 src_offset -= source_element_size;
805 }
806 // There can be at most 8 entries left in the middle that need buffering
807 // (because the largest element_size is 8 times the smallest).
808 ASSERT(j+1 - i <= 8);
809 Handle<Value> temp[8];
810 for (int k = i; k <= j; ++k) {
811 temp[k - i] = source->Get(k);
812 }
813 for (int k = i; k <= j; ++k) {
814 self->Set(offset + k, temp[k - i]);
815 }
816 } else {
817 // Different backing stores, safe to copy element-wise sequentially.
818 for (int i = 0; i < source_length; ++i)
819 self->Set(offset + i, source->Get(i));
820 }
821 }
822
hpayer@chromium.org8432c912013-02-28 15:55:26 +0000823 return Undefined(args.GetIsolate());
svenpanne@chromium.org619781a2012-07-05 08:22:44 +0000824}
825
826
mvstanton@chromium.orgd16d8532013-01-25 13:29:10 +0000827void Shell::ExternalArrayWeakCallback(v8::Isolate* isolate,
828 Persistent<Value> object,
829 void* data) {
erik.corry@gmail.comf2038fb2012-01-16 11:42:08 +0000830 HandleScope scope;
mmassi@chromium.org7028c052012-06-13 11:51:58 +0000831 int32_t length =
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000832 object->ToObject()->Get(Symbols::byteLength(isolate))->Uint32Value();
mmassi@chromium.org7028c052012-06-13 11:51:58 +0000833 V8::AdjustAmountOfExternalAllocatedMemory(-length);
rossberg@chromium.org400388e2012-06-06 09:29:22 +0000834 delete[] static_cast<uint8_t*>(data);
mvstanton@chromium.orgd16d8532013-01-25 13:29:10 +0000835 object.Dispose(isolate);
ricow@chromium.orgd2be9012011-06-01 06:00:58 +0000836}
837
838
839Handle<Value> Shell::Int8Array(const Arguments& args) {
840 return CreateExternalArray(args, v8::kExternalByteArray, sizeof(int8_t));
841}
842
843
844Handle<Value> Shell::Uint8Array(const Arguments& args) {
845 return CreateExternalArray(args, kExternalUnsignedByteArray, sizeof(uint8_t));
846}
847
848
849Handle<Value> Shell::Int16Array(const Arguments& args) {
850 return CreateExternalArray(args, kExternalShortArray, sizeof(int16_t));
851}
852
853
854Handle<Value> Shell::Uint16Array(const Arguments& args) {
yangguo@chromium.orgc74d6742012-06-29 15:15:45 +0000855 return CreateExternalArray(
856 args, kExternalUnsignedShortArray, sizeof(uint16_t));
ricow@chromium.orgd2be9012011-06-01 06:00:58 +0000857}
858
svenpanne@chromium.org6d786c92011-06-15 10:58:27 +0000859
ricow@chromium.orgd2be9012011-06-01 06:00:58 +0000860Handle<Value> Shell::Int32Array(const Arguments& args) {
861 return CreateExternalArray(args, kExternalIntArray, sizeof(int32_t));
862}
863
864
865Handle<Value> Shell::Uint32Array(const Arguments& args) {
866 return CreateExternalArray(args, kExternalUnsignedIntArray, sizeof(uint32_t));
867}
868
869
870Handle<Value> Shell::Float32Array(const Arguments& args) {
yangguo@chromium.orgc74d6742012-06-29 15:15:45 +0000871 return CreateExternalArray(
872 args, kExternalFloatArray, sizeof(float)); // NOLINT
ricow@chromium.orgd2be9012011-06-01 06:00:58 +0000873}
874
875
876Handle<Value> Shell::Float64Array(const Arguments& args) {
yangguo@chromium.orgc74d6742012-06-29 15:15:45 +0000877 return CreateExternalArray(
878 args, kExternalDoubleArray, sizeof(double)); // NOLINT
ricow@chromium.orgd2be9012011-06-01 06:00:58 +0000879}
880
881
yangguo@chromium.orgc74d6742012-06-29 15:15:45 +0000882Handle<Value> Shell::Uint8ClampedArray(const Arguments& args) {
ricow@chromium.orgd2be9012011-06-01 06:00:58 +0000883 return CreateExternalArray(args, kExternalPixelArray, sizeof(uint8_t));
884}
885
886
ager@chromium.orgbb29dc92009-03-24 13:25:23 +0000887Handle<Value> Shell::Yield(const Arguments& args) {
yangguo@chromium.org46a2a512013-01-18 16:29:40 +0000888 v8::Unlocker unlocker(args.GetIsolate());
hpayer@chromium.org8432c912013-02-28 15:55:26 +0000889 return Undefined(args.GetIsolate());
ager@chromium.orgbb29dc92009-03-24 13:25:23 +0000890}
891
892
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000893Handle<Value> Shell::Quit(const Arguments& args) {
894 int exit_code = args[0]->Int32Value();
895 OnExit();
896 exit(exit_code);
hpayer@chromium.org8432c912013-02-28 15:55:26 +0000897 return Undefined(args.GetIsolate());
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000898}
899
900
901Handle<Value> Shell::Version(const Arguments& args) {
902 return String::New(V8::GetVersion());
903}
904
905
906void Shell::ReportException(v8::TryCatch* try_catch) {
907 HandleScope handle_scope;
jkummerow@chromium.org05ed9dd2012-01-23 14:42:48 +0000908#if !defined(V8_SHARED) && defined(ENABLE_DEBUGGER_SUPPORT)
909 bool enter_context = !Context::InContext();
910 if (enter_context) utility_context_->Enter();
911#endif // !V8_SHARED && ENABLE_DEBUGGER_SUPPORT
iposva@chromium.org245aa852009-02-10 00:49:54 +0000912 v8::String::Utf8Value exception(try_catch->Exception());
913 const char* exception_string = ToCString(exception);
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000914 Handle<Message> message = try_catch->Message();
915 if (message.IsEmpty()) {
916 // V8 didn't provide any extra information about this error; just
917 // print the exception.
iposva@chromium.org245aa852009-02-10 00:49:54 +0000918 printf("%s\n", exception_string);
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000919 } else {
920 // Print (filename):(line number): (message).
iposva@chromium.org245aa852009-02-10 00:49:54 +0000921 v8::String::Utf8Value filename(message->GetScriptResourceName());
922 const char* filename_string = ToCString(filename);
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000923 int linenum = message->GetLineNumber();
iposva@chromium.org245aa852009-02-10 00:49:54 +0000924 printf("%s:%i: %s\n", filename_string, linenum, exception_string);
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000925 // Print line of source code.
iposva@chromium.org245aa852009-02-10 00:49:54 +0000926 v8::String::Utf8Value sourceline(message->GetSourceLine());
927 const char* sourceline_string = ToCString(sourceline);
928 printf("%s\n", sourceline_string);
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000929 // Print wavy underline (GetUnderline is deprecated).
930 int start = message->GetStartColumn();
931 for (int i = 0; i < start; i++) {
932 printf(" ");
933 }
934 int end = message->GetEndColumn();
935 for (int i = start; i < end; i++) {
936 printf("^");
937 }
938 printf("\n");
danno@chromium.org40cb8782011-05-25 07:58:50 +0000939 v8::String::Utf8Value stack_trace(try_catch->StackTrace());
940 if (stack_trace.length() > 0) {
941 const char* stack_trace_string = ToCString(stack_trace);
942 printf("%s\n", stack_trace_string);
943 }
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000944 }
kmillikin@chromium.org83e16822011-09-13 08:21:47 +0000945 printf("\n");
jkummerow@chromium.org05ed9dd2012-01-23 14:42:48 +0000946#if !defined(V8_SHARED) && defined(ENABLE_DEBUGGER_SUPPORT)
947 if (enter_context) utility_context_->Exit();
948#endif // !V8_SHARED && ENABLE_DEBUGGER_SUPPORT
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000949}
950
951
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +0000952#ifndef V8_SHARED
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000953Handle<Array> Shell::GetCompletions(Handle<String> text, Handle<String> full) {
954 HandleScope handle_scope;
955 Context::Scope context_scope(utility_context_);
956 Handle<Object> global = utility_context_->Global();
957 Handle<Value> fun = global->Get(String::New("GetCompletions"));
958 static const int kArgc = 3;
959 Handle<Value> argv[kArgc] = { evaluation_context_->Global(), text, full };
960 Handle<Value> val = Handle<Function>::Cast(fun)->Call(global, kArgc, argv);
961 return handle_scope.Close(Handle<Array>::Cast(val));
962}
963
964
ager@chromium.org65dad4b2009-04-23 08:48:43 +0000965#ifdef ENABLE_DEBUGGER_SUPPORT
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000966Handle<Object> Shell::DebugMessageDetails(Handle<String> message) {
christian.plesner.hansen@gmail.com37abdec2009-01-06 14:43:28 +0000967 Context::Scope context_scope(utility_context_);
968 Handle<Object> global = utility_context_->Global();
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000969 Handle<Value> fun = global->Get(String::New("DebugMessageDetails"));
christian.plesner.hansen@gmail.com37abdec2009-01-06 14:43:28 +0000970 static const int kArgc = 1;
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000971 Handle<Value> argv[kArgc] = { message };
christian.plesner.hansen@gmail.com37abdec2009-01-06 14:43:28 +0000972 Handle<Value> val = Handle<Function>::Cast(fun)->Call(global, kArgc, argv);
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000973 return Handle<Object>::Cast(val);
christian.plesner.hansen@gmail.com37abdec2009-01-06 14:43:28 +0000974}
975
976
977Handle<Value> Shell::DebugCommandToJSONRequest(Handle<String> command) {
978 Context::Scope context_scope(utility_context_);
979 Handle<Object> global = utility_context_->Global();
980 Handle<Value> fun = global->Get(String::New("DebugCommandToJSONRequest"));
981 static const int kArgc = 1;
982 Handle<Value> argv[kArgc] = { command };
983 Handle<Value> val = Handle<Function>::Cast(fun)->Call(global, kArgc, argv);
984 return val;
985}
jkummerow@chromium.org05ed9dd2012-01-23 14:42:48 +0000986
987
988void Shell::DispatchDebugMessages() {
989 v8::Context::Scope scope(Shell::evaluation_context_);
990 v8::Debug::ProcessDebugMessages();
991}
svenpanne@chromium.org84bcc552011-07-18 09:50:57 +0000992#endif // ENABLE_DEBUGGER_SUPPORT
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +0000993#endif // V8_SHARED
christian.plesner.hansen@gmail.com37abdec2009-01-06 14:43:28 +0000994
995
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +0000996#ifndef V8_SHARED
kasperl@chromium.orgd1e3e722009-04-14 13:38:25 +0000997int32_t* Counter::Bind(const char* name, bool is_histogram) {
ager@chromium.orga74f0da2008-12-03 16:05:52 +0000998 int i;
999 for (i = 0; i < kMaxNameSize - 1 && name[i]; i++)
1000 name_[i] = static_cast<char>(name[i]);
1001 name_[i] = '\0';
kasperl@chromium.orgd1e3e722009-04-14 13:38:25 +00001002 is_histogram_ = is_histogram;
1003 return ptr();
1004}
1005
1006
1007void Counter::AddSample(int32_t sample) {
1008 count_++;
1009 sample_total_ += sample;
ager@chromium.orga74f0da2008-12-03 16:05:52 +00001010}
1011
1012
1013CounterCollection::CounterCollection() {
1014 magic_number_ = 0xDEADFACE;
1015 max_counters_ = kMaxCounters;
1016 max_name_size_ = Counter::kMaxNameSize;
1017 counters_in_use_ = 0;
1018}
1019
1020
1021Counter* CounterCollection::GetNextCounter() {
1022 if (counters_in_use_ == kMaxCounters) return NULL;
1023 return &counters_[counters_in_use_++];
1024}
1025
1026
1027void Shell::MapCounters(const char* name) {
svenpanne@chromium.org84bcc552011-07-18 09:50:57 +00001028 counters_file_ = i::OS::MemoryMappedFile::create(
1029 name, sizeof(CounterCollection), &local_counters_);
ager@chromium.orga74f0da2008-12-03 16:05:52 +00001030 void* memory = (counters_file_ == NULL) ?
1031 NULL : counters_file_->memory();
1032 if (memory == NULL) {
1033 printf("Could not map counters file %s\n", name);
lrn@chromium.org34e60782011-09-15 07:25:40 +00001034 Exit(1);
ager@chromium.orga74f0da2008-12-03 16:05:52 +00001035 }
1036 counters_ = static_cast<CounterCollection*>(memory);
1037 V8::SetCounterFunction(LookupCounter);
kasperl@chromium.orgd1e3e722009-04-14 13:38:25 +00001038 V8::SetCreateHistogramFunction(CreateHistogram);
1039 V8::SetAddHistogramSampleFunction(AddHistogramSample);
ager@chromium.orga74f0da2008-12-03 16:05:52 +00001040}
1041
1042
kasperl@chromium.orgf5aa8372009-03-24 14:47:14 +00001043int CounterMap::Hash(const char* name) {
1044 int h = 0;
1045 int c;
1046 while ((c = *name++) != 0) {
1047 h += h << 5;
1048 h += c;
1049 }
1050 return h;
1051}
1052
1053
kasperl@chromium.orgd1e3e722009-04-14 13:38:25 +00001054Counter* Shell::GetCounter(const char* name, bool is_histogram) {
kasperl@chromium.orgf5aa8372009-03-24 14:47:14 +00001055 Counter* counter = counter_map_->Lookup(name);
kasperl@chromium.orgd1e3e722009-04-14 13:38:25 +00001056
1057 if (counter == NULL) {
1058 counter = counters_->GetNextCounter();
1059 if (counter != NULL) {
1060 counter_map_->Set(name, counter);
1061 counter->Bind(name, is_histogram);
1062 }
1063 } else {
1064 ASSERT(counter->is_histogram() == is_histogram);
1065 }
1066 return counter;
1067}
1068
1069
1070int* Shell::LookupCounter(const char* name) {
1071 Counter* counter = GetCounter(name, false);
1072
kasperl@chromium.orgf5aa8372009-03-24 14:47:14 +00001073 if (counter != NULL) {
1074 return counter->ptr();
kasperl@chromium.orgd1e3e722009-04-14 13:38:25 +00001075 } else {
1076 return NULL;
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00001077 }
kasperl@chromium.orgd1e3e722009-04-14 13:38:25 +00001078}
1079
1080
1081void* Shell::CreateHistogram(const char* name,
1082 int min,
1083 int max,
1084 size_t buckets) {
1085 return GetCounter(name, true);
1086}
1087
1088
1089void Shell::AddHistogramSample(void* histogram, int sample) {
1090 Counter* counter = reinterpret_cast<Counter*>(histogram);
1091 counter->AddSample(sample);
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00001092}
1093
svenpanne@chromium.org84bcc552011-07-18 09:50:57 +00001094
yangguo@chromium.org46a2a512013-01-18 16:29:40 +00001095void Shell::InstallUtilityScript(Isolate* isolate) {
1096 Locker lock(isolate);
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00001097 HandleScope scope;
ager@chromium.org04921a82011-06-27 13:21:41 +00001098 // If we use the utility context, we have to set the security tokens so that
1099 // utility, evaluation and debug context can all access each other.
hpayer@chromium.org8432c912013-02-28 15:55:26 +00001100 utility_context_->SetSecurityToken(Undefined(isolate));
1101 evaluation_context_->SetSecurityToken(Undefined(isolate));
svenpanne@chromium.org6d786c92011-06-15 10:58:27 +00001102 Context::Scope utility_scope(utility_context_);
ager@chromium.org04921a82011-06-27 13:21:41 +00001103
1104#ifdef ENABLE_DEBUGGER_SUPPORT
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001105 if (i::FLAG_debugger) printf("JavaScript debugger enabled\n");
ager@chromium.org04921a82011-06-27 13:21:41 +00001106 // Install the debugger object in the utility scope
1107 i::Debug* debug = i::Isolate::Current()->debug();
1108 debug->Load();
1109 i::Handle<i::JSObject> js_debug
yangguo@chromium.org46839fb2012-08-28 09:06:19 +00001110 = i::Handle<i::JSObject>(debug->debug_context()->global_object());
ager@chromium.org04921a82011-06-27 13:21:41 +00001111 utility_context_->Global()->Set(String::New("$debug"),
1112 Utils::ToLocal(js_debug));
1113 debug->debug_context()->set_security_token(HEAP->undefined_value());
svenpanne@chromium.org84bcc552011-07-18 09:50:57 +00001114#endif // ENABLE_DEBUGGER_SUPPORT
ager@chromium.org04921a82011-06-27 13:21:41 +00001115
svenpanne@chromium.org6d786c92011-06-15 10:58:27 +00001116 // Run the d8 shell utility script in the utility context
1117 int source_index = i::NativesCollection<i::D8>::GetIndex("d8");
1118 i::Vector<const char> shell_source =
1119 i::NativesCollection<i::D8>::GetRawScriptSource(source_index);
1120 i::Vector<const char> shell_source_name =
1121 i::NativesCollection<i::D8>::GetScriptName(source_index);
1122 Handle<String> source = String::New(shell_source.start(),
1123 shell_source.length());
1124 Handle<String> name = String::New(shell_source_name.start(),
1125 shell_source_name.length());
1126 Handle<Script> script = Script::Compile(source, name);
1127 script->Run();
svenpanne@chromium.org6d786c92011-06-15 10:58:27 +00001128 // Mark the d8 shell script as native to avoid it showing up as normal source
1129 // in the debugger.
1130 i::Handle<i::Object> compiled_script = Utils::OpenHandle(*script);
1131 i::Handle<i::Script> script_object = compiled_script->IsJSFunction()
svenpanne@chromium.org84bcc552011-07-18 09:50:57 +00001132 ? i::Handle<i::Script>(i::Script::cast(
1133 i::JSFunction::cast(*compiled_script)->shared()->script()))
1134 : i::Handle<i::Script>(i::Script::cast(
1135 i::SharedFunctionInfo::cast(*compiled_script)->script()));
svenpanne@chromium.org6d786c92011-06-15 10:58:27 +00001136 script_object->set_type(i::Smi::FromInt(i::Script::TYPE_NATIVE));
sgjesse@chromium.org6db88712011-07-11 11:41:22 +00001137
1138#ifdef ENABLE_DEBUGGER_SUPPORT
1139 // Start the in-process debugger if requested.
1140 if (i::FLAG_debugger && !i::FLAG_debugger_agent) {
1141 v8::Debug::SetDebugEventListener(HandleDebugEvent);
1142 }
svenpanne@chromium.org84bcc552011-07-18 09:50:57 +00001143#endif // ENABLE_DEBUGGER_SUPPORT
svenpanne@chromium.org6d786c92011-06-15 10:58:27 +00001144}
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +00001145#endif // V8_SHARED
svenpanne@chromium.org6d786c92011-06-15 10:58:27 +00001146
ager@chromium.org04921a82011-06-27 13:21:41 +00001147
svenpanne@chromium.org6d786c92011-06-15 10:58:27 +00001148#ifdef COMPRESS_STARTUP_DATA_BZ2
1149class BZip2Decompressor : public v8::StartupDataDecompressor {
1150 public:
1151 virtual ~BZip2Decompressor() { }
1152
1153 protected:
1154 virtual int DecompressData(char* raw_data,
1155 int* raw_data_size,
1156 const char* compressed_data,
1157 int compressed_data_size) {
1158 ASSERT_EQ(v8::StartupData::kBZip2,
1159 v8::V8::GetCompressedStartupDataAlgorithm());
1160 unsigned int decompressed_size = *raw_data_size;
1161 int result =
1162 BZ2_bzBuffToBuffDecompress(raw_data,
1163 &decompressed_size,
1164 const_cast<char*>(compressed_data),
1165 compressed_data_size,
1166 0, 1);
1167 if (result == BZ_OK) {
1168 *raw_data_size = decompressed_size;
1169 }
1170 return result;
1171 }
1172};
1173#endif
1174
yangguo@chromium.orgc74d6742012-06-29 15:15:45 +00001175
svenpanne@chromium.org619781a2012-07-05 08:22:44 +00001176Handle<FunctionTemplate> Shell::CreateArrayBufferTemplate(
1177 InvocationCallback fun) {
1178 Handle<FunctionTemplate> buffer_template = FunctionTemplate::New(fun);
1179 Local<Template> proto_template = buffer_template->PrototypeTemplate();
1180 proto_template->Set(String::New("slice"),
1181 FunctionTemplate::New(ArrayBufferSlice));
1182 return buffer_template;
1183}
1184
1185
yangguo@chromium.orgc74d6742012-06-29 15:15:45 +00001186Handle<FunctionTemplate> Shell::CreateArrayTemplate(InvocationCallback fun) {
1187 Handle<FunctionTemplate> array_template = FunctionTemplate::New(fun);
1188 Local<Template> proto_template = array_template->PrototypeTemplate();
svenpanne@chromium.org619781a2012-07-05 08:22:44 +00001189 proto_template->Set(String::New("set"), FunctionTemplate::New(ArraySet));
1190 proto_template->Set(String::New("subarray"),
1191 FunctionTemplate::New(ArraySubArray));
yangguo@chromium.orgc74d6742012-06-29 15:15:45 +00001192 return array_template;
1193}
1194
1195
ulan@chromium.org8e8d8822012-11-23 14:36:46 +00001196Handle<ObjectTemplate> Shell::CreateGlobalTemplate(Isolate* isolate) {
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00001197 Handle<ObjectTemplate> global_template = ObjectTemplate::New();
1198 global_template->Set(String::New("print"), FunctionTemplate::New(Print));
christian.plesner.hansen@gmail.com5a6af922009-08-12 14:20:51 +00001199 global_template->Set(String::New("write"), FunctionTemplate::New(Write));
ager@chromium.org65dad4b2009-04-23 08:48:43 +00001200 global_template->Set(String::New("read"), FunctionTemplate::New(Read));
yangguo@chromium.orgcb9affa2012-05-15 12:16:38 +00001201 global_template->Set(String::New("readbuffer"),
1202 FunctionTemplate::New(ReadBuffer));
ager@chromium.orgadd848f2009-08-13 12:44:13 +00001203 global_template->Set(String::New("readline"),
1204 FunctionTemplate::New(ReadLine));
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00001205 global_template->Set(String::New("load"), FunctionTemplate::New(Load));
1206 global_template->Set(String::New("quit"), FunctionTemplate::New(Quit));
1207 global_template->Set(String::New("version"), FunctionTemplate::New(Version));
ricow@chromium.org55ee8072011-09-08 16:33:10 +00001208 global_template->Set(String::New("enableProfiler"),
1209 FunctionTemplate::New(EnableProfiler));
1210 global_template->Set(String::New("disableProfiler"),
1211 FunctionTemplate::New(DisableProfiler));
ager@chromium.org71daaf62009-04-01 07:22:49 +00001212
ricow@chromium.orgd2be9012011-06-01 06:00:58 +00001213 // Bind the handlers for external arrays.
yangguo@chromium.orgc74d6742012-06-29 15:15:45 +00001214 PropertyAttribute attr =
1215 static_cast<PropertyAttribute>(ReadOnly | DontDelete);
ulan@chromium.org8e8d8822012-11-23 14:36:46 +00001216 global_template->Set(Symbols::ArrayBuffer(isolate),
svenpanne@chromium.org619781a2012-07-05 08:22:44 +00001217 CreateArrayBufferTemplate(ArrayBuffer), attr);
ricow@chromium.orgd2be9012011-06-01 06:00:58 +00001218 global_template->Set(String::New("Int8Array"),
yangguo@chromium.orgc74d6742012-06-29 15:15:45 +00001219 CreateArrayTemplate(Int8Array), attr);
ricow@chromium.orgd2be9012011-06-01 06:00:58 +00001220 global_template->Set(String::New("Uint8Array"),
yangguo@chromium.orgc74d6742012-06-29 15:15:45 +00001221 CreateArrayTemplate(Uint8Array), attr);
ricow@chromium.orgd2be9012011-06-01 06:00:58 +00001222 global_template->Set(String::New("Int16Array"),
yangguo@chromium.orgc74d6742012-06-29 15:15:45 +00001223 CreateArrayTemplate(Int16Array), attr);
ricow@chromium.orgd2be9012011-06-01 06:00:58 +00001224 global_template->Set(String::New("Uint16Array"),
yangguo@chromium.orgc74d6742012-06-29 15:15:45 +00001225 CreateArrayTemplate(Uint16Array), attr);
ricow@chromium.orgd2be9012011-06-01 06:00:58 +00001226 global_template->Set(String::New("Int32Array"),
yangguo@chromium.orgc74d6742012-06-29 15:15:45 +00001227 CreateArrayTemplate(Int32Array), attr);
ricow@chromium.orgd2be9012011-06-01 06:00:58 +00001228 global_template->Set(String::New("Uint32Array"),
yangguo@chromium.orgc74d6742012-06-29 15:15:45 +00001229 CreateArrayTemplate(Uint32Array), attr);
ricow@chromium.orgd2be9012011-06-01 06:00:58 +00001230 global_template->Set(String::New("Float32Array"),
yangguo@chromium.orgc74d6742012-06-29 15:15:45 +00001231 CreateArrayTemplate(Float32Array), attr);
ricow@chromium.orgd2be9012011-06-01 06:00:58 +00001232 global_template->Set(String::New("Float64Array"),
yangguo@chromium.orgc74d6742012-06-29 15:15:45 +00001233 CreateArrayTemplate(Float64Array), attr);
1234 global_template->Set(String::New("Uint8ClampedArray"),
1235 CreateArrayTemplate(Uint8ClampedArray), attr);
ricow@chromium.orgd2be9012011-06-01 06:00:58 +00001236
jkummerow@chromium.org486075a2011-09-07 12:44:28 +00001237#if !defined(V8_SHARED) && !defined(_WIN32) && !defined(_WIN64)
ager@chromium.org71daaf62009-04-01 07:22:49 +00001238 Handle<ObjectTemplate> os_templ = ObjectTemplate::New();
1239 AddOSMethods(os_templ);
1240 global_template->Set(String::New("os"), os_templ);
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +00001241#endif // V8_SHARED
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00001242
svenpanne@chromium.org6d786c92011-06-15 10:58:27 +00001243 return global_template;
1244}
1245
ager@chromium.org04921a82011-06-27 13:21:41 +00001246
ulan@chromium.org8e8d8822012-11-23 14:36:46 +00001247void Shell::Initialize(Isolate* isolate) {
svenpanne@chromium.org6d786c92011-06-15 10:58:27 +00001248#ifdef COMPRESS_STARTUP_DATA_BZ2
1249 BZip2Decompressor startup_data_decompressor;
1250 int bz2_result = startup_data_decompressor.Decompress();
1251 if (bz2_result != BZ_OK) {
1252 fprintf(stderr, "bzip error code: %d\n", bz2_result);
lrn@chromium.org34e60782011-09-15 07:25:40 +00001253 Exit(1);
svenpanne@chromium.org6d786c92011-06-15 10:58:27 +00001254 }
1255#endif
1256
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +00001257#ifndef V8_SHARED
svenpanne@chromium.org6d786c92011-06-15 10:58:27 +00001258 Shell::counter_map_ = new CounterMap();
1259 // Set up counters
1260 if (i::StrLength(i::FLAG_map_counters) != 0)
1261 MapCounters(i::FLAG_map_counters);
yangguo@chromium.org304cc332012-07-24 07:59:48 +00001262 if (i::FLAG_dump_counters || i::FLAG_track_gc_object_stats) {
svenpanne@chromium.org6d786c92011-06-15 10:58:27 +00001263 V8::SetCounterFunction(LookupCounter);
1264 V8::SetCreateHistogramFunction(CreateHistogram);
1265 V8::SetAddHistogramSampleFunction(AddHistogramSample);
1266 }
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +00001267#endif // V8_SHARED
ulan@chromium.org8e8d8822012-11-23 14:36:46 +00001268}
ager@chromium.org04921a82011-06-27 13:21:41 +00001269
ulan@chromium.org8e8d8822012-11-23 14:36:46 +00001270
1271void Shell::InitializeDebugger(Isolate* isolate) {
1272 if (options.test_shell) return;
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +00001273#ifndef V8_SHARED
yangguo@chromium.org46a2a512013-01-18 16:29:40 +00001274 Locker lock(isolate);
svenpanne@chromium.org6d786c92011-06-15 10:58:27 +00001275 HandleScope scope;
ulan@chromium.org8e8d8822012-11-23 14:36:46 +00001276 Handle<ObjectTemplate> global_template = CreateGlobalTemplate(isolate);
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00001277 utility_context_ = Context::New(NULL, global_template);
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00001278
ager@chromium.org65dad4b2009-04-23 08:48:43 +00001279#ifdef ENABLE_DEBUGGER_SUPPORT
ager@chromium.org04921a82011-06-27 13:21:41 +00001280 // Start the debugger agent if requested.
1281 if (i::FLAG_debugger_agent) {
1282 v8::Debug::EnableAgent("d8 shell", i::FLAG_debugger_port, true);
jkummerow@chromium.org05ed9dd2012-01-23 14:42:48 +00001283 v8::Debug::SetDebugMessageDispatchHandler(DispatchDebugMessages, true);
ager@chromium.org04921a82011-06-27 13:21:41 +00001284 }
svenpanne@chromium.org84bcc552011-07-18 09:50:57 +00001285#endif // ENABLE_DEBUGGER_SUPPORT
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +00001286#endif // V8_SHARED
svenpanne@chromium.org6d786c92011-06-15 10:58:27 +00001287}
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00001288
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00001289
ulan@chromium.org8e8d8822012-11-23 14:36:46 +00001290Persistent<Context> Shell::CreateEvaluationContext(Isolate* isolate) {
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +00001291#ifndef V8_SHARED
sgjesse@chromium.org6db88712011-07-11 11:41:22 +00001292 // This needs to be a critical section since this is not thread-safe
1293 i::ScopedLock lock(context_mutex_);
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +00001294#endif // V8_SHARED
svenpanne@chromium.org6d786c92011-06-15 10:58:27 +00001295 // Initialize the global objects
ulan@chromium.org8e8d8822012-11-23 14:36:46 +00001296 Handle<ObjectTemplate> global_template = CreateGlobalTemplate(isolate);
sgjesse@chromium.org6db88712011-07-11 11:41:22 +00001297 Persistent<Context> context = Context::New(NULL, global_template);
whesse@chromium.org4acdc2c2011-08-15 13:01:23 +00001298 ASSERT(!context.IsEmpty());
sgjesse@chromium.org6db88712011-07-11 11:41:22 +00001299 Context::Scope scope(context);
ager@chromium.orga74f0da2008-12-03 16:05:52 +00001300
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +00001301#ifndef V8_SHARED
whesse@chromium.org7b260152011-06-20 15:33:18 +00001302 i::JSArguments js_args = i::FLAG_js_arguments;
1303 i::Handle<i::FixedArray> arguments_array =
1304 FACTORY->NewFixedArray(js_args.argc());
1305 for (int j = 0; j < js_args.argc(); j++) {
1306 i::Handle<i::String> arg =
1307 FACTORY->NewStringFromUtf8(i::CStrVector(js_args[j]));
1308 arguments_array->set(j, *arg);
1309 }
1310 i::Handle<i::JSArray> arguments_jsarray =
1311 FACTORY->NewJSArrayWithElements(arguments_array);
sgjesse@chromium.org6db88712011-07-11 11:41:22 +00001312 context->Global()->Set(String::New("arguments"),
svenpanne@chromium.org84bcc552011-07-18 09:50:57 +00001313 Utils::ToLocal(arguments_jsarray));
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +00001314#endif // V8_SHARED
sgjesse@chromium.org6db88712011-07-11 11:41:22 +00001315 return context;
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00001316}
1317
1318
lrn@chromium.org34e60782011-09-15 07:25:40 +00001319void Shell::Exit(int exit_code) {
1320 // Use _exit instead of exit to avoid races between isolate
1321 // threads and static destructors.
1322 fflush(stdout);
1323 fflush(stderr);
1324 _exit(exit_code);
1325}
1326
1327
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +00001328#ifndef V8_SHARED
mstarzinger@chromium.org1b3afd12011-11-29 14:28:56 +00001329struct CounterAndKey {
1330 Counter* counter;
1331 const char* key;
1332};
1333
1334
1335int CompareKeys(const void* a, const void* b) {
1336 return strcmp(static_cast<const CounterAndKey*>(a)->key,
1337 static_cast<const CounterAndKey*>(b)->key);
1338}
jkummerow@chromium.org59297c72013-01-09 16:32:23 +00001339#endif // V8_SHARED
mstarzinger@chromium.org1b3afd12011-11-29 14:28:56 +00001340
1341
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00001342void Shell::OnExit() {
jkummerow@chromium.org59297c72013-01-09 16:32:23 +00001343 LineEditor* line_editor = LineEditor::Get();
1344 if (line_editor) line_editor->Close();
1345#ifndef V8_SHARED
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00001346 if (i::FLAG_dump_counters) {
mstarzinger@chromium.org1b3afd12011-11-29 14:28:56 +00001347 int number_of_counters = 0;
kasperl@chromium.orgf5aa8372009-03-24 14:47:14 +00001348 for (CounterMap::Iterator i(counter_map_); i.More(); i.Next()) {
mstarzinger@chromium.org1b3afd12011-11-29 14:28:56 +00001349 number_of_counters++;
1350 }
1351 CounterAndKey* counters = new CounterAndKey[number_of_counters];
1352 int j = 0;
1353 for (CounterMap::Iterator i(counter_map_); i.More(); i.Next(), j++) {
1354 counters[j].counter = i.CurrentValue();
1355 counters[j].key = i.CurrentKey();
1356 }
1357 qsort(counters, number_of_counters, sizeof(counters[0]), CompareKeys);
jkummerow@chromium.org28583c92012-07-16 11:31:55 +00001358 printf("+----------------------------------------------------------------+"
1359 "-------------+\n");
1360 printf("| Name |"
1361 " Value |\n");
1362 printf("+----------------------------------------------------------------+"
1363 "-------------+\n");
mstarzinger@chromium.org1b3afd12011-11-29 14:28:56 +00001364 for (j = 0; j < number_of_counters; j++) {
1365 Counter* counter = counters[j].counter;
1366 const char* key = counters[j].key;
kasperl@chromium.orgd1e3e722009-04-14 13:38:25 +00001367 if (counter->is_histogram()) {
jkummerow@chromium.org28583c92012-07-16 11:31:55 +00001368 printf("| c:%-60s | %11i |\n", key, counter->count());
1369 printf("| t:%-60s | %11i |\n", key, counter->sample_total());
kasperl@chromium.orgd1e3e722009-04-14 13:38:25 +00001370 } else {
jkummerow@chromium.org28583c92012-07-16 11:31:55 +00001371 printf("| %-62s | %11i |\n", key, counter->count());
kasperl@chromium.orgd1e3e722009-04-14 13:38:25 +00001372 }
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00001373 }
jkummerow@chromium.org28583c92012-07-16 11:31:55 +00001374 printf("+----------------------------------------------------------------+"
1375 "-------------+\n");
mstarzinger@chromium.org1b3afd12011-11-29 14:28:56 +00001376 delete [] counters;
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00001377 }
hpayer@chromium.org7c3372b2013-02-13 17:26:04 +00001378 delete context_mutex_;
jkummerow@chromium.org1456e702012-03-30 08:38:13 +00001379 delete counters_file_;
1380 delete counter_map_;
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +00001381#endif // V8_SHARED
jkummerow@chromium.org59297c72013-01-09 16:32:23 +00001382}
1383
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +00001384
1385
1386static FILE* FOpen(const char* path, const char* mode) {
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001387#if defined(_MSC_VER) && (defined(_WIN32) || defined(_WIN64))
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +00001388 FILE* result;
1389 if (fopen_s(&result, path, mode) == 0) {
1390 return result;
1391 } else {
1392 return NULL;
1393 }
1394#else
1395 FILE* file = fopen(path, mode);
1396 if (file == NULL) return NULL;
1397 struct stat file_stat;
1398 if (fstat(fileno(file), &file_stat) != 0) return NULL;
1399 bool is_regular_file = ((file_stat.st_mode & S_IFREG) != 0);
1400 if (is_regular_file) return file;
1401 fclose(file);
1402 return NULL;
1403#endif
1404}
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00001405
1406
ulan@chromium.org8e8d8822012-11-23 14:36:46 +00001407static char* ReadChars(Isolate* isolate, const char* name, int* size_out) {
sgjesse@chromium.org6db88712011-07-11 11:41:22 +00001408 // Release the V8 lock while reading files.
ulan@chromium.org8e8d8822012-11-23 14:36:46 +00001409 v8::Unlocker unlocker(isolate);
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +00001410 FILE* file = FOpen(name, "rb");
ager@chromium.orgddb913d2009-01-27 10:01:48 +00001411 if (file == NULL) return NULL;
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00001412
1413 fseek(file, 0, SEEK_END);
1414 int size = ftell(file);
1415 rewind(file);
1416
1417 char* chars = new char[size + 1];
1418 chars[size] = '\0';
1419 for (int i = 0; i < size;) {
ricow@chromium.org2c99e282011-07-28 09:15:17 +00001420 int read = static_cast<int>(fread(&chars[i], 1, size - i, file));
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00001421 i += read;
1422 }
1423 fclose(file);
ager@chromium.orgddb913d2009-01-27 10:01:48 +00001424 *size_out = size;
1425 return chars;
1426}
1427
1428
yangguo@chromium.orgcb9affa2012-05-15 12:16:38 +00001429Handle<Value> Shell::ReadBuffer(const Arguments& args) {
mmassi@chromium.org7028c052012-06-13 11:51:58 +00001430 ASSERT(sizeof(char) == sizeof(uint8_t)); // NOLINT
yangguo@chromium.orgcb9affa2012-05-15 12:16:38 +00001431 String::Utf8Value filename(args[0]);
1432 int length;
1433 if (*filename == NULL) {
ulan@chromium.org8e8d8822012-11-23 14:36:46 +00001434 return Throw("Error loading file");
yangguo@chromium.orgcb9affa2012-05-15 12:16:38 +00001435 }
rossberg@chromium.org400388e2012-06-06 09:29:22 +00001436
ulan@chromium.org8e8d8822012-11-23 14:36:46 +00001437 uint8_t* data = reinterpret_cast<uint8_t*>(
1438 ReadChars(args.GetIsolate(), *filename, &length));
yangguo@chromium.orgcb9affa2012-05-15 12:16:38 +00001439 if (data == NULL) {
ulan@chromium.org8e8d8822012-11-23 14:36:46 +00001440 return Throw("Error reading file");
yangguo@chromium.orgcb9affa2012-05-15 12:16:38 +00001441 }
ulan@chromium.org8e8d8822012-11-23 14:36:46 +00001442 Isolate* isolate = args.GetIsolate();
yangguo@chromium.orgcb9affa2012-05-15 12:16:38 +00001443 Handle<Object> buffer = Object::New();
ulan@chromium.org8e8d8822012-11-23 14:36:46 +00001444 buffer->SetHiddenValue(Symbols::ArrayBufferMarkerPropName(isolate), True());
mvstanton@chromium.orgd16d8532013-01-25 13:29:10 +00001445 Persistent<Object> persistent_buffer =
1446 Persistent<Object>::New(isolate, buffer);
1447 persistent_buffer.MakeWeak(isolate, data, ExternalArrayWeakCallback);
1448 persistent_buffer.MarkIndependent(isolate);
rossberg@chromium.org400388e2012-06-06 09:29:22 +00001449 V8::AdjustAmountOfExternalAllocatedMemory(length);
yangguo@chromium.orgcb9affa2012-05-15 12:16:38 +00001450
1451 buffer->SetIndexedPropertiesToExternalArrayData(
rossberg@chromium.org400388e2012-06-06 09:29:22 +00001452 data, kExternalUnsignedByteArray, length);
ulan@chromium.org8e8d8822012-11-23 14:36:46 +00001453 buffer->Set(Symbols::byteLength(isolate),
hpayer@chromium.org8432c912013-02-28 15:55:26 +00001454 Int32::New(static_cast<int32_t>(length), isolate), ReadOnly);
yangguo@chromium.orgcb9affa2012-05-15 12:16:38 +00001455 return buffer;
1456}
1457
1458
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +00001459#ifndef V8_SHARED
ager@chromium.org381abbb2009-02-25 13:23:22 +00001460static char* ReadToken(char* data, char token) {
1461 char* next = i::OS::StrChr(data, token);
1462 if (next != NULL) {
1463 *next = '\0';
1464 return (next + 1);
1465 }
1466
1467 return NULL;
1468}
1469
1470
1471static char* ReadLine(char* data) {
1472 return ReadToken(data, '\n');
1473}
1474
1475
1476static char* ReadWord(char* data) {
1477 return ReadToken(data, ' ');
1478}
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +00001479#endif // V8_SHARED
ager@chromium.org381abbb2009-02-25 13:23:22 +00001480
1481
ager@chromium.orgddb913d2009-01-27 10:01:48 +00001482// Reads a file into a v8 string.
ulan@chromium.org8e8d8822012-11-23 14:36:46 +00001483Handle<String> Shell::ReadFile(Isolate* isolate, const char* name) {
ager@chromium.orgddb913d2009-01-27 10:01:48 +00001484 int size = 0;
ulan@chromium.org8e8d8822012-11-23 14:36:46 +00001485 char* chars = ReadChars(isolate, name, &size);
ager@chromium.orgddb913d2009-01-27 10:01:48 +00001486 if (chars == NULL) return Handle<String>();
yangguo@chromium.org9768bf12013-01-11 14:51:07 +00001487 Handle<String> result = String::New(chars, size);
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00001488 delete[] chars;
1489 return result;
1490}
1491
1492
ulan@chromium.org8e8d8822012-11-23 14:36:46 +00001493void Shell::RunShell(Isolate* isolate) {
yangguo@chromium.org46a2a512013-01-18 16:29:40 +00001494 Locker locker(isolate);
svenpanne@chromium.org84bcc552011-07-18 09:50:57 +00001495 Context::Scope context_scope(evaluation_context_);
jkummerow@chromium.org486075a2011-09-07 12:44:28 +00001496 HandleScope outer_scope;
svenpanne@chromium.org84bcc552011-07-18 09:50:57 +00001497 Handle<String> name = String::New("(d8)");
ulan@chromium.org8e8d8822012-11-23 14:36:46 +00001498 LineEditor* console = LineEditor::Get();
lrn@chromium.org34e60782011-09-15 07:25:40 +00001499 printf("V8 version %s [console: %s]\n", V8::GetVersion(), console->name());
lrn@chromium.org34e60782011-09-15 07:25:40 +00001500 console->Open();
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00001501 while (true) {
jkummerow@chromium.org486075a2011-09-07 12:44:28 +00001502 HandleScope inner_scope;
ulan@chromium.org2efb9002012-01-19 15:36:35 +00001503 Handle<String> input = console->Prompt(Shell::kPrompt);
1504 if (input.IsEmpty()) break;
1505 ExecuteString(input, name, true, true);
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00001506 }
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00001507 printf("\n");
1508}
1509
1510
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +00001511#ifndef V8_SHARED
ager@chromium.orgddb913d2009-01-27 10:01:48 +00001512class ShellThread : public i::Thread {
1513 public:
lrn@chromium.org34e60782011-09-15 07:25:40 +00001514 // Takes ownership of the underlying char array of |files|.
svenpanne@chromium.org83130cf2012-11-30 10:13:25 +00001515 ShellThread(Isolate* isolate, char* files)
svenpanne@chromium.org84bcc552011-07-18 09:50:57 +00001516 : Thread("d8:ShellThread"),
svenpanne@chromium.org83130cf2012-11-30 10:13:25 +00001517 isolate_(isolate), files_(files) { }
lrn@chromium.org34e60782011-09-15 07:25:40 +00001518
1519 ~ShellThread() {
1520 delete[] files_;
1521 }
1522
ager@chromium.orgddb913d2009-01-27 10:01:48 +00001523 virtual void Run();
1524 private:
ulan@chromium.org8e8d8822012-11-23 14:36:46 +00001525 Isolate* isolate_;
lrn@chromium.org34e60782011-09-15 07:25:40 +00001526 char* files_;
ager@chromium.orgddb913d2009-01-27 10:01:48 +00001527};
1528
1529
1530void ShellThread::Run() {
lrn@chromium.org34e60782011-09-15 07:25:40 +00001531 char* ptr = files_;
ager@chromium.orgddb913d2009-01-27 10:01:48 +00001532 while ((ptr != NULL) && (*ptr != '\0')) {
1533 // For each newline-separated line.
ager@chromium.org381abbb2009-02-25 13:23:22 +00001534 char* next_line = ReadLine(ptr);
ager@chromium.orgddb913d2009-01-27 10:01:48 +00001535
ager@chromium.org381abbb2009-02-25 13:23:22 +00001536 if (*ptr == '#') {
1537 // Skip comment lines.
1538 ptr = next_line;
1539 continue;
1540 }
1541
sgjesse@chromium.org6db88712011-07-11 11:41:22 +00001542 // Prepare the context for this thread.
yangguo@chromium.org46a2a512013-01-18 16:29:40 +00001543 Locker locker(isolate_);
lrn@chromium.org34e60782011-09-15 07:25:40 +00001544 HandleScope outer_scope;
ulan@chromium.org8e8d8822012-11-23 14:36:46 +00001545 Persistent<Context> thread_context =
1546 Shell::CreateEvaluationContext(isolate_);
ager@chromium.org381abbb2009-02-25 13:23:22 +00001547 Context::Scope context_scope(thread_context);
1548
1549 while ((ptr != NULL) && (*ptr != '\0')) {
lrn@chromium.org34e60782011-09-15 07:25:40 +00001550 HandleScope inner_scope;
ager@chromium.org381abbb2009-02-25 13:23:22 +00001551 char* filename = ptr;
1552 ptr = ReadWord(ptr);
1553
1554 // Skip empty strings.
1555 if (strlen(filename) == 0) {
lrn@chromium.org34e60782011-09-15 07:25:40 +00001556 continue;
ager@chromium.org381abbb2009-02-25 13:23:22 +00001557 }
1558
ulan@chromium.org8e8d8822012-11-23 14:36:46 +00001559 Handle<String> str = Shell::ReadFile(isolate_, filename);
ager@chromium.org381abbb2009-02-25 13:23:22 +00001560 if (str.IsEmpty()) {
lrn@chromium.org34e60782011-09-15 07:25:40 +00001561 printf("File '%s' not found\n", filename);
1562 Shell::Exit(1);
ager@chromium.org381abbb2009-02-25 13:23:22 +00001563 }
1564
1565 Shell::ExecuteString(str, String::New(filename), false, false);
1566 }
1567
mvstanton@chromium.orgd16d8532013-01-25 13:29:10 +00001568 thread_context.Dispose(thread_context->GetIsolate());
ager@chromium.org381abbb2009-02-25 13:23:22 +00001569 ptr = next_line;
1570 }
ager@chromium.orgddb913d2009-01-27 10:01:48 +00001571}
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +00001572#endif // V8_SHARED
ager@chromium.orgddb913d2009-01-27 10:01:48 +00001573
ager@chromium.orgbb29dc92009-03-24 13:25:23 +00001574
kmillikin@chromium.org83e16822011-09-13 08:21:47 +00001575SourceGroup::~SourceGroup() {
1576#ifndef V8_SHARED
1577 delete next_semaphore_;
1578 next_semaphore_ = NULL;
1579 delete done_semaphore_;
1580 done_semaphore_ = NULL;
1581 delete thread_;
1582 thread_ = NULL;
1583#endif // V8_SHARED
1584}
1585
1586
ulan@chromium.org8e8d8822012-11-23 14:36:46 +00001587void SourceGroup::Execute(Isolate* isolate) {
sgjesse@chromium.org6db88712011-07-11 11:41:22 +00001588 for (int i = begin_offset_; i < end_offset_; ++i) {
1589 const char* arg = argv_[i];
1590 if (strcmp(arg, "-e") == 0 && i + 1 < end_offset_) {
1591 // Execute argument given to -e option directly.
1592 HandleScope handle_scope;
1593 Handle<String> file_name = String::New("unnamed");
1594 Handle<String> source = String::New(argv_[i + 1]);
1595 if (!Shell::ExecuteString(source, file_name, false, true)) {
lrn@chromium.org34e60782011-09-15 07:25:40 +00001596 Shell::Exit(1);
sgjesse@chromium.org6db88712011-07-11 11:41:22 +00001597 }
1598 ++i;
1599 } else if (arg[0] == '-') {
1600 // Ignore other options. They have been parsed already.
1601 } else {
1602 // Use all other arguments as names of files to load and run.
1603 HandleScope handle_scope;
1604 Handle<String> file_name = String::New(arg);
ulan@chromium.org8e8d8822012-11-23 14:36:46 +00001605 Handle<String> source = ReadFile(isolate, arg);
sgjesse@chromium.org6db88712011-07-11 11:41:22 +00001606 if (source.IsEmpty()) {
1607 printf("Error reading '%s'\n", arg);
lrn@chromium.org34e60782011-09-15 07:25:40 +00001608 Shell::Exit(1);
sgjesse@chromium.org6db88712011-07-11 11:41:22 +00001609 }
1610 if (!Shell::ExecuteString(source, file_name, false, true)) {
lrn@chromium.org34e60782011-09-15 07:25:40 +00001611 Shell::Exit(1);
sgjesse@chromium.org6db88712011-07-11 11:41:22 +00001612 }
1613 }
1614 }
1615}
1616
1617
ulan@chromium.org8e8d8822012-11-23 14:36:46 +00001618Handle<String> SourceGroup::ReadFile(Isolate* isolate, const char* name) {
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +00001619 int size;
ulan@chromium.org8e8d8822012-11-23 14:36:46 +00001620 char* chars = ReadChars(isolate, name, &size);
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +00001621 if (chars == NULL) return Handle<String>();
sgjesse@chromium.org6db88712011-07-11 11:41:22 +00001622 Handle<String> result = String::New(chars, size);
1623 delete[] chars;
1624 return result;
1625}
1626
1627
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +00001628#ifndef V8_SHARED
sgjesse@chromium.org6db88712011-07-11 11:41:22 +00001629i::Thread::Options SourceGroup::GetThreadOptions() {
sgjesse@chromium.org6db88712011-07-11 11:41:22 +00001630 // On some systems (OSX 10.6) the stack size default is 0.5Mb or less
1631 // which is not enough to parse the big literal expressions used in tests.
1632 // The stack size should be at least StackGuard::kLimitSize + some
yangguo@chromium.org659ceec2012-01-26 07:37:54 +00001633 // OS-specific padding for thread startup code. 2Mbytes seems to be enough.
1634 return i::Thread::Options("IsolateThread", 2 * MB);
sgjesse@chromium.org6db88712011-07-11 11:41:22 +00001635}
1636
1637
1638void SourceGroup::ExecuteInThread() {
1639 Isolate* isolate = Isolate::New();
1640 do {
kmillikin@chromium.org83e16822011-09-13 08:21:47 +00001641 if (next_semaphore_ != NULL) next_semaphore_->Wait();
sgjesse@chromium.org6db88712011-07-11 11:41:22 +00001642 {
1643 Isolate::Scope iscope(isolate);
1644 Locker lock(isolate);
1645 HandleScope scope;
ulan@chromium.org8e8d8822012-11-23 14:36:46 +00001646 Symbols symbols(isolate);
1647 Persistent<Context> context = Shell::CreateEvaluationContext(isolate);
sgjesse@chromium.org6db88712011-07-11 11:41:22 +00001648 {
1649 Context::Scope cscope(context);
ulan@chromium.org8e8d8822012-11-23 14:36:46 +00001650 Execute(isolate);
sgjesse@chromium.org6db88712011-07-11 11:41:22 +00001651 }
mvstanton@chromium.orgd16d8532013-01-25 13:29:10 +00001652 context.Dispose(isolate);
yangguo@chromium.org46839fb2012-08-28 09:06:19 +00001653 if (Shell::options.send_idle_notification) {
1654 const int kLongIdlePauseInMs = 1000;
1655 V8::ContextDisposedNotification();
1656 V8::IdleNotification(kLongIdlePauseInMs);
1657 }
sgjesse@chromium.org6db88712011-07-11 11:41:22 +00001658 }
kmillikin@chromium.org83e16822011-09-13 08:21:47 +00001659 if (done_semaphore_ != NULL) done_semaphore_->Signal();
sgjesse@chromium.org6db88712011-07-11 11:41:22 +00001660 } while (!Shell::options.last_run);
1661 isolate->Dispose();
1662}
1663
1664
1665void SourceGroup::StartExecuteInThread() {
kmillikin@chromium.org83e16822011-09-13 08:21:47 +00001666 if (thread_ == NULL) {
1667 thread_ = new IsolateThread(this);
sgjesse@chromium.org6db88712011-07-11 11:41:22 +00001668 thread_->Start();
1669 }
1670 next_semaphore_->Signal();
1671}
1672
1673
1674void SourceGroup::WaitForThread() {
kmillikin@chromium.org83e16822011-09-13 08:21:47 +00001675 if (thread_ == NULL) return;
sgjesse@chromium.org6db88712011-07-11 11:41:22 +00001676 if (Shell::options.last_run) {
1677 thread_->Join();
sgjesse@chromium.org6db88712011-07-11 11:41:22 +00001678 } else {
1679 done_semaphore_->Wait();
1680 }
1681}
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +00001682#endif // V8_SHARED
sgjesse@chromium.org6db88712011-07-11 11:41:22 +00001683
1684
1685bool Shell::SetOptions(int argc, char* argv[]) {
sgjesse@chromium.org6db88712011-07-11 11:41:22 +00001686 for (int i = 0; i < argc; i++) {
1687 if (strcmp(argv[i], "--stress-opt") == 0) {
1688 options.stress_opt = true;
1689 argv[i] = NULL;
1690 } else if (strcmp(argv[i], "--stress-deopt") == 0) {
1691 options.stress_deopt = true;
1692 argv[i] = NULL;
1693 } else if (strcmp(argv[i], "--noalways-opt") == 0) {
1694 // No support for stressing if we can't use --always-opt.
1695 options.stress_opt = false;
1696 options.stress_deopt = false;
1697 } else if (strcmp(argv[i], "--shell") == 0) {
1698 options.interactive_shell = true;
1699 argv[i] = NULL;
1700 } else if (strcmp(argv[i], "--test") == 0) {
1701 options.test_shell = true;
1702 argv[i] = NULL;
yangguo@chromium.org46839fb2012-08-28 09:06:19 +00001703 } else if (strcmp(argv[i], "--send-idle-notification") == 0) {
1704 options.send_idle_notification = true;
1705 argv[i] = NULL;
sgjesse@chromium.org6db88712011-07-11 11:41:22 +00001706 } else if (strcmp(argv[i], "--preemption") == 0) {
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +00001707#ifdef V8_SHARED
svenpanne@chromium.org84bcc552011-07-18 09:50:57 +00001708 printf("D8 with shared library does not support multi-threading\n");
1709 return false;
1710#else
sgjesse@chromium.org6db88712011-07-11 11:41:22 +00001711 options.use_preemption = true;
1712 argv[i] = NULL;
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +00001713#endif // V8_SHARED
jkummerow@chromium.orgab7dad42012-02-07 12:07:34 +00001714 } else if (strcmp(argv[i], "--nopreemption") == 0) {
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +00001715#ifdef V8_SHARED
svenpanne@chromium.org84bcc552011-07-18 09:50:57 +00001716 printf("D8 with shared library does not support multi-threading\n");
1717 return false;
1718#else
sgjesse@chromium.org6db88712011-07-11 11:41:22 +00001719 options.use_preemption = false;
1720 argv[i] = NULL;
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +00001721#endif // V8_SHARED
sgjesse@chromium.org6db88712011-07-11 11:41:22 +00001722 } else if (strcmp(argv[i], "--preemption-interval") == 0) {
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +00001723#ifdef V8_SHARED
svenpanne@chromium.org84bcc552011-07-18 09:50:57 +00001724 printf("D8 with shared library does not support multi-threading\n");
1725 return false;
1726#else
sgjesse@chromium.org6db88712011-07-11 11:41:22 +00001727 if (++i < argc) {
1728 argv[i-1] = NULL;
1729 char* end = NULL;
1730 options.preemption_interval = strtol(argv[i], &end, 10); // NOLINT
1731 if (options.preemption_interval <= 0
1732 || *end != '\0'
1733 || errno == ERANGE) {
1734 printf("Invalid value for --preemption-interval '%s'\n", argv[i]);
1735 return false;
1736 }
1737 argv[i] = NULL;
1738 } else {
1739 printf("Missing value for --preemption-interval\n");
1740 return false;
1741 }
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +00001742#endif // V8_SHARED
sgjesse@chromium.org6db88712011-07-11 11:41:22 +00001743 } else if (strcmp(argv[i], "-f") == 0) {
1744 // Ignore any -f flags for compatibility with other stand-alone
1745 // JavaScript engines.
1746 continue;
1747 } else if (strcmp(argv[i], "--isolate") == 0) {
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +00001748#ifdef V8_SHARED
svenpanne@chromium.org84bcc552011-07-18 09:50:57 +00001749 printf("D8 with shared library does not support multi-threading\n");
1750 return false;
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +00001751#endif // V8_SHARED
sgjesse@chromium.org6db88712011-07-11 11:41:22 +00001752 options.num_isolates++;
lrn@chromium.org34e60782011-09-15 07:25:40 +00001753 } else if (strcmp(argv[i], "-p") == 0) {
1754#ifdef V8_SHARED
1755 printf("D8 with shared library does not support multi-threading\n");
1756 return false;
1757#else
1758 options.num_parallel_files++;
1759#endif // V8_SHARED
sgjesse@chromium.org6db88712011-07-11 11:41:22 +00001760 }
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +00001761#ifdef V8_SHARED
svenpanne@chromium.org84bcc552011-07-18 09:50:57 +00001762 else if (strcmp(argv[i], "--dump-counters") == 0) {
1763 printf("D8 with shared library does not include counters\n");
1764 return false;
svenpanne@chromium.org84bcc552011-07-18 09:50:57 +00001765 } else if (strcmp(argv[i], "--debugger") == 0) {
1766 printf("Javascript debugger not included\n");
1767 return false;
1768 }
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +00001769#endif // V8_SHARED
sgjesse@chromium.org6db88712011-07-11 11:41:22 +00001770 }
1771
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +00001772#ifndef V8_SHARED
sgjesse@chromium.org6db88712011-07-11 11:41:22 +00001773 // Run parallel threads if we are not using --isolate
lrn@chromium.org34e60782011-09-15 07:25:40 +00001774 options.parallel_files = new char*[options.num_parallel_files];
1775 int parallel_files_set = 0;
sgjesse@chromium.org6db88712011-07-11 11:41:22 +00001776 for (int i = 1; i < argc; i++) {
1777 if (argv[i] == NULL) continue;
1778 if (strcmp(argv[i], "-p") == 0 && i + 1 < argc) {
1779 if (options.num_isolates > 1) {
1780 printf("-p is not compatible with --isolate\n");
1781 return false;
1782 }
1783 argv[i] = NULL;
lrn@chromium.org34e60782011-09-15 07:25:40 +00001784 i++;
1785 options.parallel_files[parallel_files_set] = argv[i];
1786 parallel_files_set++;
sgjesse@chromium.org6db88712011-07-11 11:41:22 +00001787 argv[i] = NULL;
sgjesse@chromium.org6db88712011-07-11 11:41:22 +00001788 }
1789 }
lrn@chromium.org34e60782011-09-15 07:25:40 +00001790 if (parallel_files_set != options.num_parallel_files) {
1791 printf("-p requires a file containing a list of files as parameter\n");
1792 return false;
1793 }
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +00001794#endif // V8_SHARED
sgjesse@chromium.org6db88712011-07-11 11:41:22 +00001795
1796 v8::V8::SetFlagsFromCommandLine(&argc, argv, true);
1797
lrn@chromium.org34e60782011-09-15 07:25:40 +00001798 // Set up isolated source groups.
sgjesse@chromium.org6db88712011-07-11 11:41:22 +00001799 options.isolate_sources = new SourceGroup[options.num_isolates];
1800 SourceGroup* current = options.isolate_sources;
1801 current->Begin(argv, 1);
1802 for (int i = 1; i < argc; i++) {
1803 const char* str = argv[i];
1804 if (strcmp(str, "--isolate") == 0) {
1805 current->End(i);
1806 current++;
1807 current->Begin(argv, i + 1);
1808 } else if (strncmp(argv[i], "--", 2) == 0) {
1809 printf("Warning: unknown flag %s.\nTry --help for options\n", argv[i]);
1810 }
1811 }
1812 current->End(argc);
1813
1814 return true;
1815}
1816
1817
ulan@chromium.org8e8d8822012-11-23 14:36:46 +00001818int Shell::RunMain(Isolate* isolate, int argc, char* argv[]) {
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +00001819#ifndef V8_SHARED
ager@chromium.orgddb913d2009-01-27 10:01:48 +00001820 i::List<i::Thread*> threads(1);
lrn@chromium.org34e60782011-09-15 07:25:40 +00001821 if (options.parallel_files != NULL) {
1822 for (int i = 0; i < options.num_parallel_files; i++) {
1823 char* files = NULL;
ulan@chromium.org8e8d8822012-11-23 14:36:46 +00001824 { Locker lock(isolate);
lrn@chromium.org34e60782011-09-15 07:25:40 +00001825 int size = 0;
ulan@chromium.org8e8d8822012-11-23 14:36:46 +00001826 files = ReadChars(isolate, options.parallel_files[i], &size);
lrn@chromium.org34e60782011-09-15 07:25:40 +00001827 }
1828 if (files == NULL) {
1829 printf("File list '%s' not found\n", options.parallel_files[i]);
1830 Exit(1);
1831 }
svenpanne@chromium.org83130cf2012-11-30 10:13:25 +00001832 ShellThread* thread = new ShellThread(isolate, files);
svenpanne@chromium.org84bcc552011-07-18 09:50:57 +00001833 thread->Start();
1834 threads.Add(thread);
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00001835 }
lrn@chromium.org34e60782011-09-15 07:25:40 +00001836 }
svenpanne@chromium.org84bcc552011-07-18 09:50:57 +00001837 for (int i = 1; i < options.num_isolates; ++i) {
1838 options.isolate_sources[i].StartExecuteInThread();
1839 }
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +00001840#endif // V8_SHARED
svenpanne@chromium.org84bcc552011-07-18 09:50:57 +00001841 { // NOLINT
yangguo@chromium.org46a2a512013-01-18 16:29:40 +00001842 Locker lock(isolate);
sgjesse@chromium.org6db88712011-07-11 11:41:22 +00001843 HandleScope scope;
ulan@chromium.org8e8d8822012-11-23 14:36:46 +00001844 Persistent<Context> context = CreateEvaluationContext(isolate);
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001845 if (options.last_run) {
1846 // Keep using the same context in the interactive shell.
1847 evaluation_context_ = context;
1848#if !defined(V8_SHARED) && defined(ENABLE_DEBUGGER_SUPPORT)
1849 // If the interactive debugger is enabled make sure to activate
1850 // it before running the files passed on the command line.
1851 if (i::FLAG_debugger) {
yangguo@chromium.org46a2a512013-01-18 16:29:40 +00001852 InstallUtilityScript(isolate);
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001853 }
1854#endif // !V8_SHARED && ENABLE_DEBUGGER_SUPPORT
1855 }
sgjesse@chromium.org6db88712011-07-11 11:41:22 +00001856 {
1857 Context::Scope cscope(context);
ulan@chromium.org8e8d8822012-11-23 14:36:46 +00001858 options.isolate_sources[0].Execute(isolate);
sgjesse@chromium.org6db88712011-07-11 11:41:22 +00001859 }
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001860 if (!options.last_run) {
mvstanton@chromium.orgd16d8532013-01-25 13:29:10 +00001861 context.Dispose(isolate);
yangguo@chromium.org46839fb2012-08-28 09:06:19 +00001862 if (options.send_idle_notification) {
danno@chromium.org88aa0582012-03-23 15:11:57 +00001863 const int kLongIdlePauseInMs = 1000;
1864 V8::ContextDisposedNotification();
1865 V8::IdleNotification(kLongIdlePauseInMs);
1866 }
sgjesse@chromium.org6db88712011-07-11 11:41:22 +00001867 }
svenpanne@chromium.org84bcc552011-07-18 09:50:57 +00001868
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +00001869#ifndef V8_SHARED
ager@chromium.orgbb29dc92009-03-24 13:25:23 +00001870 // Start preemption if threads have been created and preemption is enabled.
lrn@chromium.org34e60782011-09-15 07:25:40 +00001871 if (threads.length() > 0
sgjesse@chromium.org6db88712011-07-11 11:41:22 +00001872 && options.use_preemption) {
1873 Locker::StartPreemption(options.preemption_interval);
ager@chromium.orgbb29dc92009-03-24 13:25:23 +00001874 }
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +00001875#endif // V8_SHARED
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00001876 }
svenpanne@chromium.org6d786c92011-06-15 10:58:27 +00001877
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +00001878#ifndef V8_SHARED
sgjesse@chromium.org6db88712011-07-11 11:41:22 +00001879 for (int i = 1; i < options.num_isolates; ++i) {
1880 options.isolate_sources[i].WaitForThread();
ager@chromium.orgddb913d2009-01-27 10:01:48 +00001881 }
sgjesse@chromium.org6db88712011-07-11 11:41:22 +00001882
lrn@chromium.org34e60782011-09-15 07:25:40 +00001883 for (int i = 0; i < threads.length(); i++) {
1884 i::Thread* thread = threads[i];
1885 thread->Join();
1886 delete thread;
1887 }
1888
1889 if (threads.length() > 0 && options.use_preemption) {
yangguo@chromium.org46a2a512013-01-18 16:29:40 +00001890 Locker lock(isolate);
lrn@chromium.org34e60782011-09-15 07:25:40 +00001891 Locker::StopPreemption();
1892 }
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +00001893#endif // V8_SHARED
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00001894 return 0;
1895}
1896
1897
svenpanne@chromium.org6d786c92011-06-15 10:58:27 +00001898int Shell::Main(int argc, char* argv[]) {
sgjesse@chromium.org6db88712011-07-11 11:41:22 +00001899 if (!SetOptions(argc, argv)) return 1;
svenpanne@chromium.org6d786c92011-06-15 10:58:27 +00001900 int result = 0;
ulan@chromium.org8e8d8822012-11-23 14:36:46 +00001901 Isolate* isolate = Isolate::GetCurrent();
hpayer@chromium.org7c3372b2013-02-13 17:26:04 +00001902 DumbLineEditor dumb_line_editor(isolate);
ulan@chromium.org8e8d8822012-11-23 14:36:46 +00001903 {
1904 Initialize(isolate);
1905 Symbols symbols(isolate);
1906 InitializeDebugger(isolate);
1907
1908 if (options.stress_opt || options.stress_deopt) {
1909 Testing::SetStressRunType(options.stress_opt
1910 ? Testing::kStressTypeOpt
1911 : Testing::kStressTypeDeopt);
1912 int stress_runs = Testing::GetStressRuns();
1913 for (int i = 0; i < stress_runs && result == 0; i++) {
1914 printf("============ Stress %d/%d ============\n", i + 1, stress_runs);
1915 Testing::PrepareStressRun(i);
1916 options.last_run = (i == stress_runs - 1);
1917 result = RunMain(isolate, argc, argv);
1918 }
1919 printf("======== Full Deoptimization =======\n");
1920 Testing::DeoptimizeAll();
jkummerow@chromium.org1145ef82012-02-02 16:21:15 +00001921#if !defined(V8_SHARED)
ulan@chromium.org8e8d8822012-11-23 14:36:46 +00001922 } else if (i::FLAG_stress_runs > 0) {
1923 int stress_runs = i::FLAG_stress_runs;
1924 for (int i = 0; i < stress_runs && result == 0; i++) {
1925 printf("============ Run %d/%d ============\n", i + 1, stress_runs);
1926 options.last_run = (i == stress_runs - 1);
1927 result = RunMain(isolate, argc, argv);
1928 }
jkummerow@chromium.org1145ef82012-02-02 16:21:15 +00001929#endif
ulan@chromium.org8e8d8822012-11-23 14:36:46 +00001930 } else {
1931 result = RunMain(isolate, argc, argv);
1932 }
svenpanne@chromium.org6d786c92011-06-15 10:58:27 +00001933
svenpanne@chromium.org84bcc552011-07-18 09:50:57 +00001934
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +00001935#if !defined(V8_SHARED) && defined(ENABLE_DEBUGGER_SUPPORT)
ulan@chromium.org8e8d8822012-11-23 14:36:46 +00001936 // Run remote debugger if requested, but never on --test
1937 if (i::FLAG_remote_debugger && !options.test_shell) {
yangguo@chromium.org46a2a512013-01-18 16:29:40 +00001938 InstallUtilityScript(isolate);
ulan@chromium.org8e8d8822012-11-23 14:36:46 +00001939 RunRemoteDebugger(i::FLAG_debugger_port);
1940 return 0;
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001941 }
1942#endif // !V8_SHARED && ENABLE_DEBUGGER_SUPPORT
svenpanne@chromium.org6d786c92011-06-15 10:58:27 +00001943
ulan@chromium.org8e8d8822012-11-23 14:36:46 +00001944 // Run interactive shell if explicitly requested or if no script has been
1945 // executed, but never on --test
1946
1947 if (( options.interactive_shell || !options.script_executed )
1948 && !options.test_shell ) {
1949#if !defined(V8_SHARED) && defined(ENABLE_DEBUGGER_SUPPORT)
1950 if (!i::FLAG_debugger) {
yangguo@chromium.org46a2a512013-01-18 16:29:40 +00001951 InstallUtilityScript(isolate);
ulan@chromium.org8e8d8822012-11-23 14:36:46 +00001952 }
1953#endif // !V8_SHARED && ENABLE_DEBUGGER_SUPPORT
1954 RunShell(isolate);
1955 }
1956 }
sgjesse@chromium.org6db88712011-07-11 11:41:22 +00001957 V8::Dispose();
svenpanne@chromium.org6d786c92011-06-15 10:58:27 +00001958
ricow@chromium.orgddd545c2011-08-24 12:02:41 +00001959 OnExit();
ricow@chromium.orgddd545c2011-08-24 12:02:41 +00001960
svenpanne@chromium.org6d786c92011-06-15 10:58:27 +00001961 return result;
1962}
1963
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00001964} // namespace v8
1965
1966
danno@chromium.org40cb8782011-05-25 07:58:50 +00001967#ifndef GOOGLE3
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00001968int main(int argc, char* argv[]) {
1969 return v8::Shell::Main(argc, argv);
1970}
danno@chromium.org40cb8782011-05-25 07:58:50 +00001971#endif