Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(25)

Side by Side Diff: src/d8.cc

Issue 11419067: Revert "Drastically reduce the number of created strings in d8." (Closed) Base URL: https://v8.googlecode.com/svn/branches/bleeding_edge
Patch Set: Created 8 years, 1 month ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
« no previous file with comments | « no previous file | no next file » | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 // Copyright 2012 the V8 project authors. All rights reserved. 1 // Copyright 2012 the V8 project authors. All rights reserved.
2 // Redistribution and use in source and binary forms, with or without 2 // Redistribution and use in source and binary forms, with or without
3 // modification, are permitted provided that the following conditions are 3 // modification, are permitted provided that the following conditions are
4 // met: 4 // met:
5 // 5 //
6 // * Redistributions of source code must retain the above copyright 6 // * Redistributions of source code must retain the above copyright
7 // notice, this list of conditions and the following disclaimer. 7 // notice, this list of conditions and the following disclaimer.
8 // * Redistributions in binary form must reproduce the above 8 // * Redistributions in binary form must reproduce the above
9 // copyright notice, this list of conditions and the following 9 // copyright notice, this list of conditions and the following
10 // disclaimer in the documentation and/or other materials provided 10 // disclaimer in the documentation and/or other materials provided
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after
60 #if !defined(_WIN32) && !defined(_WIN64) 60 #if !defined(_WIN32) && !defined(_WIN64)
61 #include <unistd.h> // NOLINT 61 #include <unistd.h> // NOLINT
62 #endif 62 #endif
63 63
64 #ifndef ASSERT 64 #ifndef ASSERT
65 #define ASSERT(condition) assert(condition) 65 #define ASSERT(condition) assert(condition)
66 #endif 66 #endif
67 67
68 namespace v8 { 68 namespace v8 {
69 69
70
71 static 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.
78 const char kArrayBufferMarkerPropName[] = "d8::_is_array_buffer_";
79 const char kArrayMarkerPropName[] = "d8::_is_typed_array_";
80
81
82 namespace Symbols {
83 #define FOR_EACH_SYMBOL(V) \
84 V(ArrayBuffer, "ArrayBuffer") \
85 V(ArrayBufferMarkerPropName, kArrayBufferMarkerPropName) \
86 V(ArrayMarkerPropName, kArrayMarkerPropName) \
87 V(buffer, "buffer") \
88 V(byteLength, "byteLength") \
89 V(byteOffset, "byteOffset") \
90 V(BYTES_PER_ELEMENT, "BYTES_PER_ELEMENT") \
91 V(length, "length")
92
93 #define DEFINE_SYMBOL(name, value) Persistent<String> name;
94 FOR_EACH_SYMBOL(DEFINE_SYMBOL)
95 #undef DEFINE_SYMBOL
96
97 void Initialize() {
98 HandleScope scope;
99 #define INIT_SYMBOL(name, value) \
100 name = Persistent<String>::New(String::NewSymbol(value));
101 FOR_EACH_SYMBOL(INIT_SYMBOL)
102 #undef INIT_SYMBOL
103 }
104
105 void TearDown() {
106 #define DISPOSE_SYMBOL(name, value) name.Dispose();
107 FOR_EACH_SYMBOL(DISPOSE_SYMBOL)
108 #undef DISPOSE_SYMBOL
109 }
110 }
111
112
113 LineEditor *LineEditor::first_ = NULL; 70 LineEditor *LineEditor::first_ = NULL;
114 71
115 72
116 LineEditor::LineEditor(Type type, const char* name) 73 LineEditor::LineEditor(Type type, const char* name)
117 : type_(type), 74 : type_(type),
118 name_(name), 75 name_(name),
119 next_(first_) { 76 next_(first_) {
120 first_ = this; 77 first_ = this;
121 } 78 }
122 79
(...skipping 145 matching lines...) Expand 10 before | Expand all | Expand 10 after
268 225
269 Handle<Value> Shell::DisableProfiler(const Arguments& args) { 226 Handle<Value> Shell::DisableProfiler(const Arguments& args) {
270 V8::PauseProfiler(); 227 V8::PauseProfiler();
271 return Undefined(); 228 return Undefined();
272 } 229 }
273 230
274 231
275 Handle<Value> Shell::Read(const Arguments& args) { 232 Handle<Value> Shell::Read(const Arguments& args) {
276 String::Utf8Value file(args[0]); 233 String::Utf8Value file(args[0]);
277 if (*file == NULL) { 234 if (*file == NULL) {
278 return Throw("Error loading file"); 235 return ThrowException(String::New("Error loading file"));
279 } 236 }
280 Handle<String> source = ReadFile(*file); 237 Handle<String> source = ReadFile(*file);
281 if (source.IsEmpty()) { 238 if (source.IsEmpty()) {
282 return Throw("Error loading file"); 239 return ThrowException(String::New("Error loading file"));
283 } 240 }
284 return source; 241 return source;
285 } 242 }
286 243
287 244
288 Handle<String> Shell::ReadFromStdin() { 245 Handle<String> Shell::ReadFromStdin() {
289 static const int kBufferSize = 256; 246 static const int kBufferSize = 256;
290 char buffer[kBufferSize]; 247 char buffer[kBufferSize];
291 Handle<String> accumulator = String::New(""); 248 Handle<String> accumulator = String::New("");
292 int length; 249 int length;
(...skipping 20 matching lines...) Expand all
313 } 270 }
314 } 271 }
315 } 272 }
316 273
317 274
318 Handle<Value> Shell::Load(const Arguments& args) { 275 Handle<Value> Shell::Load(const Arguments& args) {
319 for (int i = 0; i < args.Length(); i++) { 276 for (int i = 0; i < args.Length(); i++) {
320 HandleScope handle_scope; 277 HandleScope handle_scope;
321 String::Utf8Value file(args[i]); 278 String::Utf8Value file(args[i]);
322 if (*file == NULL) { 279 if (*file == NULL) {
323 return Throw("Error loading file"); 280 return ThrowException(String::New("Error loading file"));
324 } 281 }
325 Handle<String> source = ReadFile(*file); 282 Handle<String> source = ReadFile(*file);
326 if (source.IsEmpty()) { 283 if (source.IsEmpty()) {
327 return Throw("Error loading file"); 284 return ThrowException(String::New("Error loading file"));
328 } 285 }
329 if (!ExecuteString(source, String::New(*file), false, true)) { 286 if (!ExecuteString(source, String::New(*file), false, true)) {
330 return Throw("Error executing file"); 287 return ThrowException(String::New("Error executing file"));
331 } 288 }
332 } 289 }
333 return Undefined(); 290 return Undefined();
334 } 291 }
335 292
336 static int32_t convertToInt(Local<Value> value_in, TryCatch* try_catch) { 293 static int32_t convertToInt(Local<Value> value_in, TryCatch* try_catch) {
337 if (value_in->IsInt32()) { 294 if (value_in->IsInt32()) {
338 return value_in->Int32Value(); 295 return value_in->Int32Value();
339 } 296 }
340 297
341 Local<Value> number = value_in->ToNumber(); 298 Local<Value> number = value_in->ToNumber();
342 if (try_catch->HasCaught()) return 0; 299 if (try_catch->HasCaught()) return 0;
343 300
344 ASSERT(number->IsNumber()); 301 ASSERT(number->IsNumber());
345 Local<Int32> int32 = number->ToInt32(); 302 Local<Int32> int32 = number->ToInt32();
346 if (try_catch->HasCaught() || int32.IsEmpty()) return 0; 303 if (try_catch->HasCaught() || int32.IsEmpty()) return 0;
347 304
348 int32_t value = int32->Int32Value(); 305 int32_t value = int32->Int32Value();
349 if (try_catch->HasCaught()) return 0; 306 if (try_catch->HasCaught()) return 0;
350 307
351 return value; 308 return value;
352 } 309 }
353 310
354 311
355 static int32_t convertToUint(Local<Value> value_in, TryCatch* try_catch) { 312 static int32_t convertToUint(Local<Value> value_in, TryCatch* try_catch) {
356 int32_t raw_value = convertToInt(value_in, try_catch); 313 int32_t raw_value = convertToInt(value_in, try_catch);
357 if (try_catch->HasCaught()) return 0; 314 if (try_catch->HasCaught()) return 0;
358 315
359 if (raw_value < 0) { 316 if (raw_value < 0) {
360 Throw("Array length must not be negative."); 317 ThrowException(String::New("Array length must not be negative."));
361 return 0; 318 return 0;
362 } 319 }
363 320
364 static const int kMaxLength = 0x3fffffff; 321 static const int kMaxLength = 0x3fffffff;
365 #ifndef V8_SHARED 322 #ifndef V8_SHARED
366 ASSERT(kMaxLength == i::ExternalArray::kMaxLength); 323 ASSERT(kMaxLength == i::ExternalArray::kMaxLength);
367 #endif // V8_SHARED 324 #endif // V8_SHARED
368 if (raw_value > static_cast<int32_t>(kMaxLength)) { 325 if (raw_value > static_cast<int32_t>(kMaxLength)) {
369 Throw("Array length exceeds maximum length."); 326 ThrowException(
327 String::New("Array length exceeds maximum length."));
370 } 328 }
371 return raw_value; 329 return raw_value;
372 } 330 }
373 331
374 332
333 // TODO(rossberg): should replace these by proper uses of HasInstance,
334 // once we figure out a good way to make the templates global.
335 const char kArrayBufferMarkerPropName[] = "d8::_is_array_buffer_";
336 const char kArrayMarkerPropName[] = "d8::_is_typed_array_";
337
338
375 Handle<Value> Shell::CreateExternalArrayBuffer(Handle<Object> buffer, 339 Handle<Value> Shell::CreateExternalArrayBuffer(Handle<Object> buffer,
376 int32_t length) { 340 int32_t length) {
377 static const int32_t kMaxSize = 0x7fffffff; 341 static const int32_t kMaxSize = 0x7fffffff;
378 // Make sure the total size fits into a (signed) int. 342 // Make sure the total size fits into a (signed) int.
379 if (length < 0 || length > kMaxSize) { 343 if (length < 0 || length > kMaxSize) {
380 return Throw("ArrayBuffer exceeds maximum size (2G)"); 344 return ThrowException(String::New("ArrayBuffer exceeds maximum size (2G)"));
381 } 345 }
382 uint8_t* data = new uint8_t[length]; 346 uint8_t* data = new uint8_t[length];
383 if (data == NULL) { 347 if (data == NULL) {
384 return Throw("Memory allocation failed"); 348 return ThrowException(String::New("Memory allocation failed"));
385 } 349 }
386 memset(data, 0, length); 350 memset(data, 0, length);
387 351
388 buffer->SetHiddenValue(Symbols::ArrayBufferMarkerPropName, True()); 352 buffer->SetHiddenValue(String::New(kArrayBufferMarkerPropName), True());
389 Persistent<Object> persistent_array = Persistent<Object>::New(buffer); 353 Persistent<Object> persistent_array = Persistent<Object>::New(buffer);
390 persistent_array.MakeWeak(data, ExternalArrayWeakCallback); 354 persistent_array.MakeWeak(data, ExternalArrayWeakCallback);
391 persistent_array.MarkIndependent(); 355 persistent_array.MarkIndependent();
392 V8::AdjustAmountOfExternalAllocatedMemory(length); 356 V8::AdjustAmountOfExternalAllocatedMemory(length);
393 357
394 buffer->SetIndexedPropertiesToExternalArrayData( 358 buffer->SetIndexedPropertiesToExternalArrayData(
395 data, v8::kExternalByteArray, length); 359 data, v8::kExternalByteArray, length);
396 buffer->Set(Symbols::byteLength, Int32::New(length), ReadOnly); 360 buffer->Set(String::New("byteLength"), Int32::New(length), ReadOnly);
397 361
398 return buffer; 362 return buffer;
399 } 363 }
400 364
401 365
402 Handle<Value> Shell::ArrayBuffer(const Arguments& args) { 366 Handle<Value> Shell::ArrayBuffer(const Arguments& args) {
403 if (!args.IsConstructCall()) { 367 if (!args.IsConstructCall()) {
404 Handle<Value>* rec_args = new Handle<Value>[args.Length()]; 368 Handle<Value>* rec_args = new Handle<Value>[args.Length()];
405 for (int i = 0; i < args.Length(); ++i) rec_args[i] = args[i]; 369 for (int i = 0; i < args.Length(); ++i) rec_args[i] = args[i];
406 Handle<Value> result = args.Callee()->NewInstance(args.Length(), rec_args); 370 Handle<Value> result = args.Callee()->NewInstance(args.Length(), rec_args);
407 delete[] rec_args; 371 delete[] rec_args;
408 return result; 372 return result;
409 } 373 }
410 374
411 if (args.Length() == 0) { 375 if (args.Length() == 0) {
412 return Throw("ArrayBuffer constructor must have one argument"); 376 return ThrowException(
377 String::New("ArrayBuffer constructor must have one argument"));
413 } 378 }
414 TryCatch try_catch; 379 TryCatch try_catch;
415 int32_t length = convertToUint(args[0], &try_catch); 380 int32_t length = convertToUint(args[0], &try_catch);
416 if (try_catch.HasCaught()) return try_catch.ReThrow(); 381 if (try_catch.HasCaught()) return try_catch.ReThrow();
417 382
418 return CreateExternalArrayBuffer(args.This(), length); 383 return CreateExternalArrayBuffer(args.This(), length);
419 } 384 }
420 385
421 386
422 Handle<Object> Shell::CreateExternalArray(Handle<Object> array, 387 Handle<Object> Shell::CreateExternalArray(Handle<Object> array,
423 Handle<Object> buffer, 388 Handle<Object> buffer,
424 ExternalArrayType type, 389 ExternalArrayType type,
425 int32_t length, 390 int32_t length,
426 int32_t byteLength, 391 int32_t byteLength,
427 int32_t byteOffset, 392 int32_t byteOffset,
428 int32_t element_size) { 393 int32_t element_size) {
429 ASSERT(element_size == 1 || element_size == 2 || 394 ASSERT(element_size == 1 || element_size == 2 ||
430 element_size == 4 || element_size == 8); 395 element_size == 4 || element_size == 8);
431 ASSERT(byteLength == length * element_size); 396 ASSERT(byteLength == length * element_size);
432 397
433 void* data = buffer->GetIndexedPropertiesExternalArrayData(); 398 void* data = buffer->GetIndexedPropertiesExternalArrayData();
434 ASSERT(data != NULL); 399 ASSERT(data != NULL);
435 400
436 array->SetIndexedPropertiesToExternalArrayData( 401 array->SetIndexedPropertiesToExternalArrayData(
437 static_cast<uint8_t*>(data) + byteOffset, type, length); 402 static_cast<uint8_t*>(data) + byteOffset, type, length);
438 array->SetHiddenValue(Symbols::ArrayMarkerPropName, Int32::New(type)); 403 array->SetHiddenValue(String::New(kArrayMarkerPropName), Int32::New(type));
439 array->Set(Symbols::byteLength, Int32::New(byteLength), ReadOnly); 404 array->Set(String::New("byteLength"), Int32::New(byteLength), ReadOnly);
440 array->Set(Symbols::byteOffset, Int32::New(byteOffset), ReadOnly); 405 array->Set(String::New("byteOffset"), Int32::New(byteOffset), ReadOnly);
441 array->Set(Symbols::length, Int32::New(length), ReadOnly); 406 array->Set(String::New("length"), Int32::New(length), ReadOnly);
442 array->Set(Symbols::BYTES_PER_ELEMENT, Int32::New(element_size)); 407 array->Set(String::New("BYTES_PER_ELEMENT"), Int32::New(element_size));
443 array->Set(Symbols::buffer, buffer, ReadOnly); 408 array->Set(String::New("buffer"), buffer, ReadOnly);
444 409
445 return array; 410 return array;
446 } 411 }
447 412
448 413
449 Handle<Value> Shell::CreateExternalArray(const Arguments& args, 414 Handle<Value> Shell::CreateExternalArray(const Arguments& args,
450 ExternalArrayType type, 415 ExternalArrayType type,
451 int32_t element_size) { 416 int32_t element_size) {
452 if (!args.IsConstructCall()) { 417 if (!args.IsConstructCall()) {
453 Handle<Value>* rec_args = new Handle<Value>[args.Length()]; 418 Handle<Value>* rec_args = new Handle<Value>[args.Length()];
(...skipping 13 matching lines...) Expand all
467 // TypedArray(TypedArray array) 432 // TypedArray(TypedArray array)
468 // TypedArray(ArrayBuffer buffer, 433 // TypedArray(ArrayBuffer buffer,
469 // optional unsigned long byteOffset, 434 // optional unsigned long byteOffset,
470 // optional unsigned long length) 435 // optional unsigned long length)
471 Handle<Object> buffer; 436 Handle<Object> buffer;
472 int32_t length; 437 int32_t length;
473 int32_t byteLength; 438 int32_t byteLength;
474 int32_t byteOffset; 439 int32_t byteOffset;
475 bool init_from_array = false; 440 bool init_from_array = false;
476 if (args.Length() == 0) { 441 if (args.Length() == 0) {
477 return Throw("Array constructor must have at least one argument"); 442 return ThrowException(
443 String::New("Array constructor must have at least one argument"));
478 } 444 }
479 if (args[0]->IsObject() && 445 if (args[0]->IsObject() &&
480 !args[0]->ToObject()->GetHiddenValue( 446 !args[0]->ToObject()->GetHiddenValue(
481 Symbols::ArrayBufferMarkerPropName).IsEmpty()) { 447 String::New(kArrayBufferMarkerPropName)).IsEmpty()) {
482 // Construct from ArrayBuffer. 448 // Construct from ArrayBuffer.
483 buffer = args[0]->ToObject(); 449 buffer = args[0]->ToObject();
484 int32_t bufferLength = 450 int32_t bufferLength =
485 convertToUint(buffer->Get(Symbols::byteLength), &try_catch); 451 convertToUint(buffer->Get(String::New("byteLength")), &try_catch);
486 if (try_catch.HasCaught()) return try_catch.ReThrow(); 452 if (try_catch.HasCaught()) return try_catch.ReThrow();
487 453
488 if (args.Length() < 2 || args[1]->IsUndefined()) { 454 if (args.Length() < 2 || args[1]->IsUndefined()) {
489 byteOffset = 0; 455 byteOffset = 0;
490 } else { 456 } else {
491 byteOffset = convertToUint(args[1], &try_catch); 457 byteOffset = convertToUint(args[1], &try_catch);
492 if (try_catch.HasCaught()) return try_catch.ReThrow(); 458 if (try_catch.HasCaught()) return try_catch.ReThrow();
493 if (byteOffset > bufferLength) { 459 if (byteOffset > bufferLength) {
494 return Throw("byteOffset out of bounds"); 460 return ThrowException(String::New("byteOffset out of bounds"));
495 } 461 }
496 if (byteOffset % element_size != 0) { 462 if (byteOffset % element_size != 0) {
497 return Throw("byteOffset must be multiple of element size"); 463 return ThrowException(
464 String::New("byteOffset must be multiple of element size"));
498 } 465 }
499 } 466 }
500 467
501 if (args.Length() < 3 || args[2]->IsUndefined()) { 468 if (args.Length() < 3 || args[2]->IsUndefined()) {
502 byteLength = bufferLength - byteOffset; 469 byteLength = bufferLength - byteOffset;
503 length = byteLength / element_size; 470 length = byteLength / element_size;
504 if (byteLength % element_size != 0) { 471 if (byteLength % element_size != 0) {
505 return Throw("buffer size must be multiple of element size"); 472 return ThrowException(
473 String::New("buffer size must be multiple of element size"));
506 } 474 }
507 } else { 475 } else {
508 length = convertToUint(args[2], &try_catch); 476 length = convertToUint(args[2], &try_catch);
509 if (try_catch.HasCaught()) return try_catch.ReThrow(); 477 if (try_catch.HasCaught()) return try_catch.ReThrow();
510 byteLength = length * element_size; 478 byteLength = length * element_size;
511 if (byteOffset + byteLength > bufferLength) { 479 if (byteOffset + byteLength > bufferLength) {
512 return Throw("length out of bounds"); 480 return ThrowException(String::New("length out of bounds"));
513 } 481 }
514 } 482 }
515 } else { 483 } else {
516 if (args[0]->IsObject() && 484 if (args[0]->IsObject() &&
517 args[0]->ToObject()->Has(Symbols::length)) { 485 args[0]->ToObject()->Has(String::New("length"))) {
518 // Construct from array. 486 // Construct from array.
519 length = convertToUint( 487 length = convertToUint(
520 args[0]->ToObject()->Get(Symbols::length), &try_catch); 488 args[0]->ToObject()->Get(String::New("length")), &try_catch);
521 if (try_catch.HasCaught()) return try_catch.ReThrow(); 489 if (try_catch.HasCaught()) return try_catch.ReThrow();
522 init_from_array = true; 490 init_from_array = true;
523 } else { 491 } else {
524 // Construct from size. 492 // Construct from size.
525 length = convertToUint(args[0], &try_catch); 493 length = convertToUint(args[0], &try_catch);
526 if (try_catch.HasCaught()) return try_catch.ReThrow(); 494 if (try_catch.HasCaught()) return try_catch.ReThrow();
527 } 495 }
528 byteLength = length * element_size; 496 byteLength = length * element_size;
529 byteOffset = 0; 497 byteOffset = 0;
530 498
531 Handle<Object> global = Context::GetCurrent()->Global(); 499 Handle<Object> global = Context::GetCurrent()->Global();
532 Handle<Value> array_buffer = global->Get(Symbols::ArrayBuffer); 500 Handle<Value> array_buffer = global->Get(String::New("ArrayBuffer"));
533 ASSERT(!try_catch.HasCaught() && array_buffer->IsFunction()); 501 ASSERT(!try_catch.HasCaught() && array_buffer->IsFunction());
534 Handle<Value> buffer_args[] = { Uint32::New(byteLength) }; 502 Handle<Value> buffer_args[] = { Uint32::New(byteLength) };
535 Handle<Value> result = Handle<Function>::Cast(array_buffer)->NewInstance( 503 Handle<Value> result = Handle<Function>::Cast(array_buffer)->NewInstance(
536 1, buffer_args); 504 1, buffer_args);
537 if (try_catch.HasCaught()) return result; 505 if (try_catch.HasCaught()) return result;
538 buffer = result->ToObject(); 506 buffer = result->ToObject();
539 } 507 }
540 508
541 Handle<Object> array = CreateExternalArray( 509 Handle<Object> array = CreateExternalArray(
542 args.This(), buffer, type, length, byteLength, byteOffset, element_size); 510 args.This(), buffer, type, length, byteLength, byteOffset, element_size);
543 511
544 if (init_from_array) { 512 if (init_from_array) {
545 Handle<Object> init = args[0]->ToObject(); 513 Handle<Object> init = args[0]->ToObject();
546 for (int i = 0; i < length; ++i) array->Set(i, init->Get(i)); 514 for (int i = 0; i < length; ++i) array->Set(i, init->Get(i));
547 } 515 }
548 516
549 return array; 517 return array;
550 } 518 }
551 519
552 520
553 Handle<Value> Shell::ArrayBufferSlice(const Arguments& args) { 521 Handle<Value> Shell::ArrayBufferSlice(const Arguments& args) {
554 TryCatch try_catch; 522 TryCatch try_catch;
555 523
556 if (!args.This()->IsObject()) { 524 if (!args.This()->IsObject()) {
557 return Throw("'slice' invoked on non-object receiver"); 525 return ThrowException(
526 String::New("'slice' invoked on non-object receiver"));
558 } 527 }
559 528
560 Local<Object> self = args.This(); 529 Local<Object> self = args.This();
561 Local<Value> marker = 530 Local<Value> marker =
562 self->GetHiddenValue(Symbols::ArrayBufferMarkerPropName); 531 self->GetHiddenValue(String::New(kArrayBufferMarkerPropName));
563 if (marker.IsEmpty()) { 532 if (marker.IsEmpty()) {
564 return Throw("'slice' invoked on wrong receiver type"); 533 return ThrowException(
534 String::New("'slice' invoked on wrong receiver type"));
565 } 535 }
566 536
567 int32_t length = 537 int32_t length =
568 convertToUint(self->Get(Symbols::byteLength), &try_catch); 538 convertToUint(self->Get(String::New("byteLength")), &try_catch);
569 if (try_catch.HasCaught()) return try_catch.ReThrow(); 539 if (try_catch.HasCaught()) return try_catch.ReThrow();
570 540
571 if (args.Length() == 0) { 541 if (args.Length() == 0) {
572 return Throw("'slice' must have at least one argument"); 542 return ThrowException(
543 String::New("'slice' must have at least one argument"));
573 } 544 }
574 int32_t begin = convertToInt(args[0], &try_catch); 545 int32_t begin = convertToInt(args[0], &try_catch);
575 if (try_catch.HasCaught()) return try_catch.ReThrow(); 546 if (try_catch.HasCaught()) return try_catch.ReThrow();
576 if (begin < 0) begin += length; 547 if (begin < 0) begin += length;
577 if (begin < 0) begin = 0; 548 if (begin < 0) begin = 0;
578 if (begin > length) begin = length; 549 if (begin > length) begin = length;
579 550
580 int32_t end; 551 int32_t end;
581 if (args.Length() < 2 || args[1]->IsUndefined()) { 552 if (args.Length() < 2 || args[1]->IsUndefined()) {
582 end = length; 553 end = length;
(...skipping 18 matching lines...) Expand all
601 memcpy(dest, src, end - begin); 572 memcpy(dest, src, end - begin);
602 573
603 return buffer; 574 return buffer;
604 } 575 }
605 576
606 577
607 Handle<Value> Shell::ArraySubArray(const Arguments& args) { 578 Handle<Value> Shell::ArraySubArray(const Arguments& args) {
608 TryCatch try_catch; 579 TryCatch try_catch;
609 580
610 if (!args.This()->IsObject()) { 581 if (!args.This()->IsObject()) {
611 return Throw("'subarray' invoked on non-object receiver"); 582 return ThrowException(
583 String::New("'subarray' invoked on non-object receiver"));
612 } 584 }
613 585
614 Local<Object> self = args.This(); 586 Local<Object> self = args.This();
615 Local<Value> marker = self->GetHiddenValue(Symbols::ArrayMarkerPropName); 587 Local<Value> marker = self->GetHiddenValue(String::New(kArrayMarkerPropName));
616 if (marker.IsEmpty()) { 588 if (marker.IsEmpty()) {
617 return Throw("'subarray' invoked on wrong receiver type"); 589 return ThrowException(
590 String::New("'subarray' invoked on wrong receiver type"));
618 } 591 }
619 592
620 Handle<Object> buffer = self->Get(Symbols::buffer)->ToObject(); 593 Handle<Object> buffer = self->Get(String::New("buffer"))->ToObject();
621 if (try_catch.HasCaught()) return try_catch.ReThrow(); 594 if (try_catch.HasCaught()) return try_catch.ReThrow();
622 int32_t length = 595 int32_t length =
623 convertToUint(self->Get(Symbols::length), &try_catch); 596 convertToUint(self->Get(String::New("length")), &try_catch);
624 if (try_catch.HasCaught()) return try_catch.ReThrow(); 597 if (try_catch.HasCaught()) return try_catch.ReThrow();
625 int32_t byteOffset = 598 int32_t byteOffset =
626 convertToUint(self->Get(Symbols::byteOffset), &try_catch); 599 convertToUint(self->Get(String::New("byteOffset")), &try_catch);
627 if (try_catch.HasCaught()) return try_catch.ReThrow(); 600 if (try_catch.HasCaught()) return try_catch.ReThrow();
628 int32_t element_size = 601 int32_t element_size =
629 convertToUint(self->Get(Symbols::BYTES_PER_ELEMENT), &try_catch); 602 convertToUint(self->Get(String::New("BYTES_PER_ELEMENT")), &try_catch);
630 if (try_catch.HasCaught()) return try_catch.ReThrow(); 603 if (try_catch.HasCaught()) return try_catch.ReThrow();
631 604
632 if (args.Length() == 0) { 605 if (args.Length() == 0) {
633 return Throw("'subarray' must have at least one argument"); 606 return ThrowException(
607 String::New("'subarray' must have at least one argument"));
634 } 608 }
635 int32_t begin = convertToInt(args[0], &try_catch); 609 int32_t begin = convertToInt(args[0], &try_catch);
636 if (try_catch.HasCaught()) return try_catch.ReThrow(); 610 if (try_catch.HasCaught()) return try_catch.ReThrow();
637 if (begin < 0) begin += length; 611 if (begin < 0) begin += length;
638 if (begin < 0) begin = 0; 612 if (begin < 0) begin = 0;
639 if (begin > length) begin = length; 613 if (begin > length) begin = length;
640 614
641 int32_t end; 615 int32_t end;
642 if (args.Length() < 2 || args[1]->IsUndefined()) { 616 if (args.Length() < 2 || args[1]->IsUndefined()) {
643 end = length; 617 end = length;
(...skipping 14 matching lines...) Expand all
658 buffer, Uint32::New(byteOffset), Uint32::New(length) 632 buffer, Uint32::New(byteOffset), Uint32::New(length)
659 }; 633 };
660 return constructor->NewInstance(3, construct_args); 634 return constructor->NewInstance(3, construct_args);
661 } 635 }
662 636
663 637
664 Handle<Value> Shell::ArraySet(const Arguments& args) { 638 Handle<Value> Shell::ArraySet(const Arguments& args) {
665 TryCatch try_catch; 639 TryCatch try_catch;
666 640
667 if (!args.This()->IsObject()) { 641 if (!args.This()->IsObject()) {
668 return Throw("'set' invoked on non-object receiver"); 642 return ThrowException(
643 String::New("'set' invoked on non-object receiver"));
669 } 644 }
670 645
671 Local<Object> self = args.This(); 646 Local<Object> self = args.This();
672 Local<Value> marker = self->GetHiddenValue(Symbols::ArrayMarkerPropName); 647 Local<Value> marker = self->GetHiddenValue(String::New(kArrayMarkerPropName));
673 if (marker.IsEmpty()) { 648 if (marker.IsEmpty()) {
674 return Throw("'set' invoked on wrong receiver type"); 649 return ThrowException(
650 String::New("'set' invoked on wrong receiver type"));
675 } 651 }
676 int32_t length = 652 int32_t length =
677 convertToUint(self->Get(Symbols::length), &try_catch); 653 convertToUint(self->Get(String::New("length")), &try_catch);
678 if (try_catch.HasCaught()) return try_catch.ReThrow(); 654 if (try_catch.HasCaught()) return try_catch.ReThrow();
679 int32_t element_size = 655 int32_t element_size =
680 convertToUint(self->Get(Symbols::BYTES_PER_ELEMENT), &try_catch); 656 convertToUint(self->Get(String::New("BYTES_PER_ELEMENT")), &try_catch);
681 if (try_catch.HasCaught()) return try_catch.ReThrow(); 657 if (try_catch.HasCaught()) return try_catch.ReThrow();
682 658
683 if (args.Length() == 0) { 659 if (args.Length() == 0) {
684 return Throw("'set' must have at least one argument"); 660 return ThrowException(
661 String::New("'set' must have at least one argument"));
685 } 662 }
686 if (!args[0]->IsObject() || 663 if (!args[0]->IsObject() ||
687 !args[0]->ToObject()->Has(Symbols::length)) { 664 !args[0]->ToObject()->Has(String::New("length"))) {
688 return Throw("'set' invoked with non-array argument"); 665 return ThrowException(
666 String::New("'set' invoked with non-array argument"));
689 } 667 }
690 Handle<Object> source = args[0]->ToObject(); 668 Handle<Object> source = args[0]->ToObject();
691 int32_t source_length = 669 int32_t source_length =
692 convertToUint(source->Get(Symbols::length), &try_catch); 670 convertToUint(source->Get(String::New("length")), &try_catch);
693 if (try_catch.HasCaught()) return try_catch.ReThrow(); 671 if (try_catch.HasCaught()) return try_catch.ReThrow();
694 672
695 int32_t offset; 673 int32_t offset;
696 if (args.Length() < 2 || args[1]->IsUndefined()) { 674 if (args.Length() < 2 || args[1]->IsUndefined()) {
697 offset = 0; 675 offset = 0;
698 } else { 676 } else {
699 offset = convertToUint(args[1], &try_catch); 677 offset = convertToUint(args[1], &try_catch);
700 if (try_catch.HasCaught()) return try_catch.ReThrow(); 678 if (try_catch.HasCaught()) return try_catch.ReThrow();
701 } 679 }
702 if (offset + source_length > length) { 680 if (offset + source_length > length) {
703 return Throw("offset or source length out of bounds"); 681 return ThrowException(String::New("offset or source length out of bounds"));
704 } 682 }
705 683
706 int32_t source_element_size; 684 int32_t source_element_size;
707 if (source->GetHiddenValue(Symbols::ArrayMarkerPropName).IsEmpty()) { 685 if (source->GetHiddenValue(String::New(kArrayMarkerPropName)).IsEmpty()) {
708 source_element_size = 0; 686 source_element_size = 0;
709 } else { 687 } else {
710 source_element_size = 688 source_element_size =
711 convertToUint(source->Get(Symbols::BYTES_PER_ELEMENT), &try_catch); 689 convertToUint(source->Get(String::New("BYTES_PER_ELEMENT")), &try_catch);
712 if (try_catch.HasCaught()) return try_catch.ReThrow(); 690 if (try_catch.HasCaught()) return try_catch.ReThrow();
713 } 691 }
714 692
715 if (element_size == source_element_size && 693 if (element_size == source_element_size &&
716 self->GetConstructor()->StrictEquals(source->GetConstructor())) { 694 self->GetConstructor()->StrictEquals(source->GetConstructor())) {
717 // Use memmove on the array buffers. 695 // Use memmove on the array buffers.
718 Handle<Object> buffer = self->Get(Symbols::buffer)->ToObject(); 696 Handle<Object> buffer = self->Get(String::New("buffer"))->ToObject();
719 if (try_catch.HasCaught()) return try_catch.ReThrow(); 697 if (try_catch.HasCaught()) return try_catch.ReThrow();
720 Handle<Object> source_buffer = 698 Handle<Object> source_buffer =
721 source->Get(Symbols::buffer)->ToObject(); 699 source->Get(String::New("buffer"))->ToObject();
722 if (try_catch.HasCaught()) return try_catch.ReThrow(); 700 if (try_catch.HasCaught()) return try_catch.ReThrow();
723 int32_t byteOffset = 701 int32_t byteOffset =
724 convertToUint(self->Get(Symbols::byteOffset), &try_catch); 702 convertToUint(self->Get(String::New("byteOffset")), &try_catch);
725 if (try_catch.HasCaught()) return try_catch.ReThrow(); 703 if (try_catch.HasCaught()) return try_catch.ReThrow();
726 int32_t source_byteOffset = 704 int32_t source_byteOffset =
727 convertToUint(source->Get(Symbols::byteOffset), &try_catch); 705 convertToUint(source->Get(String::New("byteOffset")), &try_catch);
728 if (try_catch.HasCaught()) return try_catch.ReThrow(); 706 if (try_catch.HasCaught()) return try_catch.ReThrow();
729 707
730 uint8_t* dest = byteOffset + offset * element_size + static_cast<uint8_t*>( 708 uint8_t* dest = byteOffset + offset * element_size + static_cast<uint8_t*>(
731 buffer->GetIndexedPropertiesExternalArrayData()); 709 buffer->GetIndexedPropertiesExternalArrayData());
732 uint8_t* src = source_byteOffset + static_cast<uint8_t*>( 710 uint8_t* src = source_byteOffset + static_cast<uint8_t*>(
733 source_buffer->GetIndexedPropertiesExternalArrayData()); 711 source_buffer->GetIndexedPropertiesExternalArrayData());
734 memmove(dest, src, source_length * element_size); 712 memmove(dest, src, source_length * element_size);
735 } else if (source_element_size == 0) { 713 } else if (source_element_size == 0) {
736 // Source is not a typed array, copy element-wise sequentially. 714 // Source is not a typed array, copy element-wise sequentially.
737 for (int i = 0; i < source_length; ++i) { 715 for (int i = 0; i < source_length; ++i) {
738 self->Set(offset + i, source->Get(i)); 716 self->Set(offset + i, source->Get(i));
739 if (try_catch.HasCaught()) return try_catch.ReThrow(); 717 if (try_catch.HasCaught()) return try_catch.ReThrow();
740 } 718 }
741 } else { 719 } else {
742 // Need to copy element-wise to make the right conversions. 720 // Need to copy element-wise to make the right conversions.
743 Handle<Object> buffer = self->Get(Symbols::buffer)->ToObject(); 721 Handle<Object> buffer = self->Get(String::New("buffer"))->ToObject();
744 if (try_catch.HasCaught()) return try_catch.ReThrow(); 722 if (try_catch.HasCaught()) return try_catch.ReThrow();
745 Handle<Object> source_buffer = 723 Handle<Object> source_buffer =
746 source->Get(Symbols::buffer)->ToObject(); 724 source->Get(String::New("buffer"))->ToObject();
747 if (try_catch.HasCaught()) return try_catch.ReThrow(); 725 if (try_catch.HasCaught()) return try_catch.ReThrow();
748 726
749 if (buffer->StrictEquals(source_buffer)) { 727 if (buffer->StrictEquals(source_buffer)) {
750 // Same backing store, need to handle overlap correctly. 728 // Same backing store, need to handle overlap correctly.
751 // This gets a bit tricky in the case of different element sizes 729 // This gets a bit tricky in the case of different element sizes
752 // (which, of course, is extremely unlikely to ever occur in practice). 730 // (which, of course, is extremely unlikely to ever occur in practice).
753 int32_t byteOffset = 731 int32_t byteOffset =
754 convertToUint(self->Get(Symbols::byteOffset), &try_catch); 732 convertToUint(self->Get(String::New("byteOffset")), &try_catch);
755 if (try_catch.HasCaught()) return try_catch.ReThrow(); 733 if (try_catch.HasCaught()) return try_catch.ReThrow();
756 int32_t source_byteOffset = 734 int32_t source_byteOffset =
757 convertToUint(source->Get(Symbols::byteOffset), &try_catch); 735 convertToUint(source->Get(String::New("byteOffset")), &try_catch);
758 if (try_catch.HasCaught()) return try_catch.ReThrow(); 736 if (try_catch.HasCaught()) return try_catch.ReThrow();
759 737
760 // Copy as much as we can from left to right. 738 // Copy as much as we can from left to right.
761 int i = 0; 739 int i = 0;
762 int32_t next_dest_offset = byteOffset + (offset + 1) * element_size; 740 int32_t next_dest_offset = byteOffset + (offset + 1) * element_size;
763 int32_t next_src_offset = source_byteOffset + source_element_size; 741 int32_t next_src_offset = source_byteOffset + source_element_size;
764 while (i < length && next_dest_offset <= next_src_offset) { 742 while (i < length && next_dest_offset <= next_src_offset) {
765 self->Set(offset + i, source->Get(i)); 743 self->Set(offset + i, source->Get(i));
766 ++i; 744 ++i;
767 next_dest_offset += element_size; 745 next_dest_offset += element_size;
(...skipping 26 matching lines...) Expand all
794 } 772 }
795 } 773 }
796 774
797 return Undefined(); 775 return Undefined();
798 } 776 }
799 777
800 778
801 void Shell::ExternalArrayWeakCallback(Persistent<Value> object, void* data) { 779 void Shell::ExternalArrayWeakCallback(Persistent<Value> object, void* data) {
802 HandleScope scope; 780 HandleScope scope;
803 int32_t length = 781 int32_t length =
804 object->ToObject()->Get(Symbols::byteLength)->Uint32Value(); 782 object->ToObject()->Get(String::New("byteLength"))->Uint32Value();
805 V8::AdjustAmountOfExternalAllocatedMemory(-length); 783 V8::AdjustAmountOfExternalAllocatedMemory(-length);
806 delete[] static_cast<uint8_t*>(data); 784 delete[] static_cast<uint8_t*>(data);
807 object.Dispose(); 785 object.Dispose();
808 } 786 }
809 787
810 788
811 Handle<Value> Shell::Int8Array(const Arguments& args) { 789 Handle<Value> Shell::Int8Array(const Arguments& args) {
812 return CreateExternalArray(args, v8::kExternalByteArray, sizeof(int8_t)); 790 return CreateExternalArray(args, v8::kExternalByteArray, sizeof(int8_t));
813 } 791 }
814 792
(...skipping 365 matching lines...) Expand 10 before | Expand all | Expand 10 after
1180 global_template->Set(String::New("quit"), FunctionTemplate::New(Quit)); 1158 global_template->Set(String::New("quit"), FunctionTemplate::New(Quit));
1181 global_template->Set(String::New("version"), FunctionTemplate::New(Version)); 1159 global_template->Set(String::New("version"), FunctionTemplate::New(Version));
1182 global_template->Set(String::New("enableProfiler"), 1160 global_template->Set(String::New("enableProfiler"),
1183 FunctionTemplate::New(EnableProfiler)); 1161 FunctionTemplate::New(EnableProfiler));
1184 global_template->Set(String::New("disableProfiler"), 1162 global_template->Set(String::New("disableProfiler"),
1185 FunctionTemplate::New(DisableProfiler)); 1163 FunctionTemplate::New(DisableProfiler));
1186 1164
1187 // Bind the handlers for external arrays. 1165 // Bind the handlers for external arrays.
1188 PropertyAttribute attr = 1166 PropertyAttribute attr =
1189 static_cast<PropertyAttribute>(ReadOnly | DontDelete); 1167 static_cast<PropertyAttribute>(ReadOnly | DontDelete);
1190 global_template->Set(Symbols::ArrayBuffer, 1168 global_template->Set(String::New("ArrayBuffer"),
1191 CreateArrayBufferTemplate(ArrayBuffer), attr); 1169 CreateArrayBufferTemplate(ArrayBuffer), attr);
1192 global_template->Set(String::New("Int8Array"), 1170 global_template->Set(String::New("Int8Array"),
1193 CreateArrayTemplate(Int8Array), attr); 1171 CreateArrayTemplate(Int8Array), attr);
1194 global_template->Set(String::New("Uint8Array"), 1172 global_template->Set(String::New("Uint8Array"),
1195 CreateArrayTemplate(Uint8Array), attr); 1173 CreateArrayTemplate(Uint8Array), attr);
1196 global_template->Set(String::New("Int16Array"), 1174 global_template->Set(String::New("Int16Array"),
1197 CreateArrayTemplate(Int16Array), attr); 1175 CreateArrayTemplate(Int16Array), attr);
1198 global_template->Set(String::New("Uint16Array"), 1176 global_template->Set(String::New("Uint16Array"),
1199 CreateArrayTemplate(Uint16Array), attr); 1177 CreateArrayTemplate(Uint16Array), attr);
1200 global_template->Set(String::New("Int32Array"), 1178 global_template->Set(String::New("Int32Array"),
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after
1238 Shell::counter_map_ = new CounterMap(); 1216 Shell::counter_map_ = new CounterMap();
1239 // Set up counters 1217 // Set up counters
1240 if (i::StrLength(i::FLAG_map_counters) != 0) 1218 if (i::StrLength(i::FLAG_map_counters) != 0)
1241 MapCounters(i::FLAG_map_counters); 1219 MapCounters(i::FLAG_map_counters);
1242 if (i::FLAG_dump_counters || i::FLAG_track_gc_object_stats) { 1220 if (i::FLAG_dump_counters || i::FLAG_track_gc_object_stats) {
1243 V8::SetCounterFunction(LookupCounter); 1221 V8::SetCounterFunction(LookupCounter);
1244 V8::SetCreateHistogramFunction(CreateHistogram); 1222 V8::SetCreateHistogramFunction(CreateHistogram);
1245 V8::SetAddHistogramSampleFunction(AddHistogramSample); 1223 V8::SetAddHistogramSampleFunction(AddHistogramSample);
1246 } 1224 }
1247 #endif // V8_SHARED 1225 #endif // V8_SHARED
1248
1249 Symbols::Initialize();
1250 if (options.test_shell) return; 1226 if (options.test_shell) return;
1251 1227
1252 #ifndef V8_SHARED 1228 #ifndef V8_SHARED
1253 Locker lock; 1229 Locker lock;
1254 HandleScope scope; 1230 HandleScope scope;
1255 Handle<ObjectTemplate> global_template = CreateGlobalTemplate(); 1231 Handle<ObjectTemplate> global_template = CreateGlobalTemplate();
1256 utility_context_ = Context::New(NULL, global_template); 1232 utility_context_ = Context::New(NULL, global_template);
1257 1233
1258 #ifdef ENABLE_DEBUGGER_SUPPORT 1234 #ifdef ENABLE_DEBUGGER_SUPPORT
1259 // Start the debugger agent if requested. 1235 // Start the debugger agent if requested.
(...skipping 138 matching lines...) Expand 10 before | Expand all | Expand 10 after
1398 *size_out = size; 1374 *size_out = size;
1399 return chars; 1375 return chars;
1400 } 1376 }
1401 1377
1402 1378
1403 Handle<Value> Shell::ReadBuffer(const Arguments& args) { 1379 Handle<Value> Shell::ReadBuffer(const Arguments& args) {
1404 ASSERT(sizeof(char) == sizeof(uint8_t)); // NOLINT 1380 ASSERT(sizeof(char) == sizeof(uint8_t)); // NOLINT
1405 String::Utf8Value filename(args[0]); 1381 String::Utf8Value filename(args[0]);
1406 int length; 1382 int length;
1407 if (*filename == NULL) { 1383 if (*filename == NULL) {
1408 return Throw("Error loading file"); 1384 return ThrowException(String::New("Error loading file"));
1409 } 1385 }
1410 1386
1411 uint8_t* data = reinterpret_cast<uint8_t*>(ReadChars(*filename, &length)); 1387 uint8_t* data = reinterpret_cast<uint8_t*>(ReadChars(*filename, &length));
1412 if (data == NULL) { 1388 if (data == NULL) {
1413 return Throw("Error reading file"); 1389 return ThrowException(String::New("Error reading file"));
1414 } 1390 }
1415 Handle<Object> buffer = Object::New(); 1391 Handle<Object> buffer = Object::New();
1416 buffer->SetHiddenValue(Symbols::ArrayBufferMarkerPropName, True()); 1392 buffer->SetHiddenValue(String::New(kArrayBufferMarkerPropName), True());
1417 Persistent<Object> persistent_buffer = Persistent<Object>::New(buffer); 1393 Persistent<Object> persistent_buffer = Persistent<Object>::New(buffer);
1418 persistent_buffer.MakeWeak(data, ExternalArrayWeakCallback); 1394 persistent_buffer.MakeWeak(data, ExternalArrayWeakCallback);
1419 persistent_buffer.MarkIndependent(); 1395 persistent_buffer.MarkIndependent();
1420 V8::AdjustAmountOfExternalAllocatedMemory(length); 1396 V8::AdjustAmountOfExternalAllocatedMemory(length);
1421 1397
1422 buffer->SetIndexedPropertiesToExternalArrayData( 1398 buffer->SetIndexedPropertiesToExternalArrayData(
1423 data, kExternalUnsignedByteArray, length); 1399 data, kExternalUnsignedByteArray, length);
1424 buffer->Set(Symbols::byteLength, 1400 buffer->Set(String::New("byteLength"),
1425 Int32::New(static_cast<int32_t>(length)), ReadOnly); 1401 Int32::New(static_cast<int32_t>(length)), ReadOnly);
1426 return buffer; 1402 return buffer;
1427 } 1403 }
1428 1404
1429 1405
1430 #ifndef V8_SHARED 1406 #ifndef V8_SHARED
1431 static char* ReadToken(char* data, char token) { 1407 static char* ReadToken(char* data, char token) {
1432 char* next = i::OS::StrChr(data, token); 1408 char* next = i::OS::StrChr(data, token);
1433 if (next != NULL) { 1409 if (next != NULL) {
1434 *next = '\0'; 1410 *next = '\0';
(...skipping 477 matching lines...) Expand 10 before | Expand all | Expand 10 after
1912 || !options.script_executed ) 1888 || !options.script_executed )
1913 && !options.test_shell ) { 1889 && !options.test_shell ) {
1914 #if !defined(V8_SHARED) && defined(ENABLE_DEBUGGER_SUPPORT) 1890 #if !defined(V8_SHARED) && defined(ENABLE_DEBUGGER_SUPPORT)
1915 if (!i::FLAG_debugger) { 1891 if (!i::FLAG_debugger) {
1916 InstallUtilityScript(); 1892 InstallUtilityScript();
1917 } 1893 }
1918 #endif // !V8_SHARED && ENABLE_DEBUGGER_SUPPORT 1894 #endif // !V8_SHARED && ENABLE_DEBUGGER_SUPPORT
1919 RunShell(); 1895 RunShell();
1920 } 1896 }
1921 1897
1922 Symbols::TearDown();
1923 V8::Dispose(); 1898 V8::Dispose();
1924 1899
1925 #ifndef V8_SHARED 1900 #ifndef V8_SHARED
1926 OnExit(); 1901 OnExit();
1927 #endif // V8_SHARED 1902 #endif // V8_SHARED
1928 1903
1929 return result; 1904 return result;
1930 } 1905 }
1931 1906
1932 } // namespace v8 1907 } // namespace v8
1933 1908
1934 1909
1935 #ifndef GOOGLE3 1910 #ifndef GOOGLE3
1936 int main(int argc, char* argv[]) { 1911 int main(int argc, char* argv[]) {
1937 return v8::Shell::Main(argc, argv); 1912 return v8::Shell::Main(argc, argv);
1938 } 1913 }
1939 #endif 1914 #endif
OLDNEW
« no previous file with comments | « no previous file | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698