OLD | NEW |
1 // Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file | 1 // Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file |
2 // for details. All rights reserved. Use of this source code is governed by a | 2 // for details. All rights reserved. Use of this source code is governed by a |
3 // BSD-style license that can be found in the LICENSE file. | 3 // BSD-style license that can be found in the LICENSE file. |
4 | 4 |
5 #include "vm/object.h" | 5 #include "vm/object.h" |
6 | 6 |
7 #include "include/dart_api.h" | 7 #include "include/dart_api.h" |
8 #include "platform/assert.h" | 8 #include "platform/assert.h" |
9 #include "vm/assembler.h" | 9 #include "vm/assembler.h" |
10 #include "vm/bigint_operations.h" | 10 #include "vm/bigint_operations.h" |
(...skipping 412 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
423 const String& name = String::Handle(Symbols::New(cname)); | 423 const String& name = String::Handle(Symbols::New(cname)); |
424 const Class& cls = Class::Handle( | 424 const Class& cls = Class::Handle( |
425 Class::NewInterface(name, script, Scanner::kDummyTokenIndex)); | 425 Class::NewInterface(name, script, Scanner::kDummyTokenIndex)); |
426 lib.AddClass(cls); | 426 lib.AddClass(cls); |
427 return cls.raw(); | 427 return cls.raw(); |
428 } | 428 } |
429 | 429 |
430 | 430 |
431 void Object::RegisterClass(const Class& cls, | 431 void Object::RegisterClass(const Class& cls, |
432 const char* cname, | 432 const char* cname, |
433 const Script& script, | |
434 const Library& lib) { | 433 const Library& lib) { |
435 const String& name = String::Handle(Symbols::New(cname)); | 434 const String& name = String::Handle(Symbols::New(cname)); |
436 cls.set_name(name); | 435 cls.set_name(name); |
437 cls.set_script(script); | |
438 lib.AddClass(cls); | 436 lib.AddClass(cls); |
439 } | 437 } |
440 | 438 |
441 | 439 |
442 void Object::RegisterPrivateClass(const Class& cls, | 440 void Object::RegisterPrivateClass(const Class& cls, |
443 const char* public_class_name, | 441 const char* public_class_name, |
444 const Script& script, | |
445 const Library& lib) { | 442 const Library& lib) { |
446 String& str = String::Handle(); | 443 String& str = String::Handle(); |
447 str = Symbols::New(public_class_name); | 444 str = Symbols::New(public_class_name); |
448 str = lib.PrivateName(str); | 445 str = lib.PrivateName(str); |
449 cls.set_name(str); | 446 cls.set_name(str); |
450 cls.set_script(script); | |
451 lib.AddClass(cls); | 447 lib.AddClass(cls); |
452 } | 448 } |
453 | 449 |
454 | 450 |
455 RawError* Object::Init(Isolate* isolate) { | 451 RawError* Object::Init(Isolate* isolate) { |
456 TIMERSCOPE(time_bootstrap); | 452 TIMERSCOPE(time_bootstrap); |
457 ObjectStore* object_store = isolate->object_store(); | 453 ObjectStore* object_store = isolate->object_store(); |
458 | 454 |
459 Class& cls = Class::Handle(); | 455 Class& cls = Class::Handle(); |
460 Type& type = Type::Handle(); | 456 Type& type = Type::Handle(); |
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
504 const GrowableObjectArray& pending_classes = | 500 const GrowableObjectArray& pending_classes = |
505 GrowableObjectArray::Handle(GrowableObjectArray::New(Heap::kOld)); | 501 GrowableObjectArray::Handle(GrowableObjectArray::New(Heap::kOld)); |
506 object_store->set_pending_classes(pending_classes); | 502 object_store->set_pending_classes(pending_classes); |
507 | 503 |
508 Context& context = Context::Handle(Context::New(0, Heap::kOld)); | 504 Context& context = Context::Handle(Context::New(0, Heap::kOld)); |
509 object_store->set_empty_context(context); | 505 object_store->set_empty_context(context); |
510 | 506 |
511 // Now that the symbol table is initialized and that the core dictionary as | 507 // Now that the symbol table is initialized and that the core dictionary as |
512 // well as the core implementation dictionary have been setup, preallocate | 508 // well as the core implementation dictionary have been setup, preallocate |
513 // remaining classes and register them by name in the dictionaries. | 509 // remaining classes and register them by name in the dictionaries. |
514 const Script& impl_script = Script::Handle(Bootstrap::LoadImplScript()); | 510 const Script& impl_script = Script::Handle( |
| 511 Bootstrap::LoadCoreImplScript(false)); |
515 | 512 |
516 cls = Class::New<Integer>(); | 513 cls = Class::New<Integer>(); |
517 object_store->set_integer_implementation_class(cls); | 514 object_store->set_integer_implementation_class(cls); |
518 RegisterClass(cls, "IntegerImplementation", impl_script, core_impl_lib); | 515 RegisterClass(cls, "IntegerImplementation", core_impl_lib); |
519 pending_classes.Add(cls, Heap::kOld); | 516 pending_classes.Add(cls, Heap::kOld); |
520 | 517 |
521 cls = Class::New<Smi>(); | 518 cls = Class::New<Smi>(); |
522 object_store->set_smi_class(cls); | 519 object_store->set_smi_class(cls); |
523 RegisterClass(cls, "Smi", impl_script, core_impl_lib); | 520 RegisterClass(cls, "Smi", core_impl_lib); |
524 pending_classes.Add(cls, Heap::kOld); | 521 pending_classes.Add(cls, Heap::kOld); |
525 | 522 |
526 cls = Class::New<Mint>(); | 523 cls = Class::New<Mint>(); |
527 object_store->set_mint_class(cls); | 524 object_store->set_mint_class(cls); |
528 RegisterClass(cls, "Mint", impl_script, core_impl_lib); | 525 RegisterClass(cls, "Mint", core_impl_lib); |
529 pending_classes.Add(cls, Heap::kOld); | 526 pending_classes.Add(cls, Heap::kOld); |
530 | 527 |
531 cls = Class::New<Bigint>(); | 528 cls = Class::New<Bigint>(); |
532 object_store->set_bigint_class(cls); | 529 object_store->set_bigint_class(cls); |
533 RegisterClass(cls, "Bigint", impl_script, core_impl_lib); | 530 RegisterClass(cls, "Bigint", core_impl_lib); |
534 pending_classes.Add(cls, Heap::kOld); | 531 pending_classes.Add(cls, Heap::kOld); |
535 | 532 |
536 cls = Class::New<Double>(); | 533 cls = Class::New<Double>(); |
537 object_store->set_double_class(cls); | 534 object_store->set_double_class(cls); |
538 RegisterClass(cls, "Double", impl_script, core_impl_lib); | 535 RegisterClass(cls, "Double", core_impl_lib); |
539 pending_classes.Add(cls, Heap::kOld); | 536 pending_classes.Add(cls, Heap::kOld); |
540 | 537 |
541 cls = Class::New<Bool>(); | 538 cls = Class::New<Bool>(); |
542 object_store->set_bool_class(cls); | 539 object_store->set_bool_class(cls); |
543 RegisterClass(cls, "Bool", impl_script, core_impl_lib); | 540 RegisterClass(cls, "Bool", core_impl_lib); |
544 pending_classes.Add(cls, Heap::kOld); | 541 pending_classes.Add(cls, Heap::kOld); |
545 | 542 |
546 cls = object_store->array_class(); // Was allocated above. | 543 cls = object_store->array_class(); // Was allocated above. |
547 RegisterClass(cls, "ObjectArray", impl_script, core_impl_lib); | 544 RegisterClass(cls, "ObjectArray", core_impl_lib); |
548 pending_classes.Add(cls, Heap::kOld); | 545 pending_classes.Add(cls, Heap::kOld); |
549 | 546 |
550 cls = object_store->growable_object_array_class(); // Was allocated above. | 547 cls = object_store->growable_object_array_class(); // Was allocated above. |
551 RegisterClass(cls, "GrowableObjectArray", impl_script, core_impl_lib); | 548 RegisterClass(cls, "GrowableObjectArray", core_impl_lib); |
552 pending_classes.Add(cls, Heap::kOld); | 549 pending_classes.Add(cls, Heap::kOld); |
553 | 550 |
554 cls = Class::New<ImmutableArray>(); | 551 cls = Class::New<ImmutableArray>(); |
555 object_store->set_immutable_array_class(cls); | 552 object_store->set_immutable_array_class(cls); |
556 cls.set_type_arguments_instance_field_offset(Array::type_arguments_offset()); | 553 cls.set_type_arguments_instance_field_offset(Array::type_arguments_offset()); |
557 ASSERT(object_store->immutable_array_class() != object_store->array_class()); | 554 ASSERT(object_store->immutable_array_class() != object_store->array_class()); |
558 RegisterClass(cls, "ImmutableArray", impl_script, core_impl_lib); | 555 RegisterClass(cls, "ImmutableArray", core_impl_lib); |
559 pending_classes.Add(cls, Heap::kOld); | 556 pending_classes.Add(cls, Heap::kOld); |
560 | 557 |
561 cls = object_store->one_byte_string_class(); // Was allocated above. | 558 cls = object_store->one_byte_string_class(); // Was allocated above. |
562 RegisterClass(cls, "OneByteString", impl_script, core_impl_lib); | 559 RegisterClass(cls, "OneByteString", core_impl_lib); |
563 pending_classes.Add(cls, Heap::kOld); | 560 pending_classes.Add(cls, Heap::kOld); |
564 | 561 |
565 cls = Class::New<TwoByteString>(); | 562 cls = Class::New<TwoByteString>(); |
566 object_store->set_two_byte_string_class(cls); | 563 object_store->set_two_byte_string_class(cls); |
567 RegisterClass(cls, "TwoByteString", impl_script, core_impl_lib); | 564 RegisterClass(cls, "TwoByteString", core_impl_lib); |
568 pending_classes.Add(cls, Heap::kOld); | 565 pending_classes.Add(cls, Heap::kOld); |
569 | 566 |
570 cls = Class::New<FourByteString>(); | 567 cls = Class::New<FourByteString>(); |
571 object_store->set_four_byte_string_class(cls); | 568 object_store->set_four_byte_string_class(cls); |
572 RegisterClass(cls, "FourByteString", impl_script, core_impl_lib); | 569 RegisterClass(cls, "FourByteString", core_impl_lib); |
573 pending_classes.Add(cls, Heap::kOld); | 570 pending_classes.Add(cls, Heap::kOld); |
574 | 571 |
575 cls = Class::New<ExternalOneByteString>(); | 572 cls = Class::New<ExternalOneByteString>(); |
576 object_store->set_external_one_byte_string_class(cls); | 573 object_store->set_external_one_byte_string_class(cls); |
577 RegisterClass(cls, "ExternalOneByteString", impl_script, core_impl_lib); | 574 RegisterClass(cls, "ExternalOneByteString", core_impl_lib); |
578 pending_classes.Add(cls, Heap::kOld); | 575 pending_classes.Add(cls, Heap::kOld); |
579 | 576 |
580 cls = Class::New<ExternalTwoByteString>(); | 577 cls = Class::New<ExternalTwoByteString>(); |
581 object_store->set_external_two_byte_string_class(cls); | 578 object_store->set_external_two_byte_string_class(cls); |
582 RegisterClass(cls, "ExternalTwoByteString", impl_script, core_impl_lib); | 579 RegisterClass(cls, "ExternalTwoByteString", core_impl_lib); |
583 pending_classes.Add(cls, Heap::kOld); | 580 pending_classes.Add(cls, Heap::kOld); |
584 | 581 |
585 cls = Class::New<ExternalFourByteString>(); | 582 cls = Class::New<ExternalFourByteString>(); |
586 object_store->set_external_four_byte_string_class(cls); | 583 object_store->set_external_four_byte_string_class(cls); |
587 RegisterClass(cls, "ExternalFourByteString", impl_script, core_impl_lib); | 584 RegisterClass(cls, "ExternalFourByteString", core_impl_lib); |
588 pending_classes.Add(cls, Heap::kOld); | 585 pending_classes.Add(cls, Heap::kOld); |
589 | 586 |
590 cls = Class::New<Stacktrace>(); | 587 cls = Class::New<Stacktrace>(); |
591 object_store->set_stacktrace_class(cls); | 588 object_store->set_stacktrace_class(cls); |
592 RegisterClass(cls, "Stacktrace", impl_script, core_impl_lib); | 589 RegisterClass(cls, "Stacktrace", core_impl_lib); |
593 pending_classes.Add(cls, Heap::kOld); | 590 pending_classes.Add(cls, Heap::kOld); |
594 // Super type set below, after Object is allocated. | 591 // Super type set below, after Object is allocated. |
595 | 592 |
596 cls = Class::New<JSRegExp>(); | 593 cls = Class::New<JSRegExp>(); |
597 object_store->set_jsregexp_class(cls); | 594 object_store->set_jsregexp_class(cls); |
598 RegisterClass(cls, "JSSyntaxRegExp", impl_script, core_impl_lib); | 595 RegisterClass(cls, "JSSyntaxRegExp", core_impl_lib); |
599 pending_classes.Add(cls, Heap::kOld); | 596 pending_classes.Add(cls, Heap::kOld); |
600 | 597 |
601 // Initialize the base interfaces used by the core VM classes. | 598 // Initialize the base interfaces used by the core VM classes. |
602 const Script& script = Script::Handle(Bootstrap::LoadScript()); | 599 const Script& script = Script::Handle(Bootstrap::LoadCoreScript(false)); |
603 | 600 |
604 // Allocate and initialize the Object class and type. The Object | 601 // Allocate and initialize the Object class and type. The Object |
605 // class and ByteArray subclasses are the only pre-allocated, | 602 // class and ByteArray subclasses are the only pre-allocated, |
606 // non-interface classes in the core library. | 603 // non-interface classes in the core library. |
607 cls = Class::New<Instance>(); | 604 cls = Class::New<Instance>(); |
608 object_store->set_object_class(cls); | 605 object_store->set_object_class(cls); |
609 cls.set_name(String::Handle(Symbols::New("Object"))); | 606 cls.set_name(String::Handle(Symbols::New("Object"))); |
610 cls.set_script(script); | 607 cls.set_script(script); |
611 cls.set_is_prefinalized(); | 608 cls.set_is_prefinalized(); |
612 core_lib.AddClass(cls); | 609 core_lib.AddClass(cls); |
613 pending_classes.Add(cls, Heap::kOld); | 610 pending_classes.Add(cls, Heap::kOld); |
614 type = Type::NewNonParameterizedType(cls); | 611 type = Type::NewNonParameterizedType(cls); |
615 object_store->set_object_type(type); | 612 object_store->set_object_type(type); |
616 | 613 |
617 cls = Class::New<Int8Array>(); | 614 cls = Class::New<Int8Array>(); |
618 object_store->set_int8_array_class(cls); | 615 object_store->set_int8_array_class(cls); |
619 RegisterPrivateClass(cls, "_Int8Array", script, core_lib); | 616 RegisterPrivateClass(cls, "_Int8Array", core_lib); |
620 | 617 |
621 cls = Class::New<Uint8Array>(); | 618 cls = Class::New<Uint8Array>(); |
622 object_store->set_uint8_array_class(cls); | 619 object_store->set_uint8_array_class(cls); |
623 RegisterPrivateClass(cls, "_Uint8Array", script, core_lib); | 620 RegisterPrivateClass(cls, "_Uint8Array", core_lib); |
624 | 621 |
625 cls = Class::New<Int16Array>(); | 622 cls = Class::New<Int16Array>(); |
626 object_store->set_int16_array_class(cls); | 623 object_store->set_int16_array_class(cls); |
627 RegisterPrivateClass(cls, "_Int16Array", script, core_lib); | 624 RegisterPrivateClass(cls, "_Int16Array", core_lib); |
628 | 625 |
629 cls = Class::New<Uint16Array>(); | 626 cls = Class::New<Uint16Array>(); |
630 object_store->set_uint16_array_class(cls); | 627 object_store->set_uint16_array_class(cls); |
631 RegisterPrivateClass(cls, "_Uint16Array", script, core_lib); | 628 RegisterPrivateClass(cls, "_Uint16Array", core_lib); |
632 | 629 |
633 cls = Class::New<Int32Array>(); | 630 cls = Class::New<Int32Array>(); |
634 object_store->set_int32_array_class(cls); | 631 object_store->set_int32_array_class(cls); |
635 RegisterPrivateClass(cls, "_Int32Array", script, core_lib); | 632 RegisterPrivateClass(cls, "_Int32Array", core_lib); |
636 | 633 |
637 cls = Class::New<Uint32Array>(); | 634 cls = Class::New<Uint32Array>(); |
638 object_store->set_uint32_array_class(cls); | 635 object_store->set_uint32_array_class(cls); |
639 RegisterPrivateClass(cls, "_Uint32Array", script, core_lib); | 636 RegisterPrivateClass(cls, "_Uint32Array", core_lib); |
640 | 637 |
641 cls = Class::New<Int64Array>(); | 638 cls = Class::New<Int64Array>(); |
642 object_store->set_int64_array_class(cls); | 639 object_store->set_int64_array_class(cls); |
643 RegisterPrivateClass(cls, "_Int64Array", script, core_lib); | 640 RegisterPrivateClass(cls, "_Int64Array", core_lib); |
644 | 641 |
645 cls = Class::New<Uint64Array>(); | 642 cls = Class::New<Uint64Array>(); |
646 object_store->set_uint64_array_class(cls); | 643 object_store->set_uint64_array_class(cls); |
647 RegisterPrivateClass(cls, "_Uint64Array", script, core_lib); | 644 RegisterPrivateClass(cls, "_Uint64Array", core_lib); |
648 | 645 |
649 cls = Class::New<Float32Array>(); | 646 cls = Class::New<Float32Array>(); |
650 object_store->set_float32_array_class(cls); | 647 object_store->set_float32_array_class(cls); |
651 RegisterPrivateClass(cls, "_Float32Array", script, core_lib); | 648 RegisterPrivateClass(cls, "_Float32Array", core_lib); |
652 | 649 |
653 cls = Class::New<Float64Array>(); | 650 cls = Class::New<Float64Array>(); |
654 object_store->set_float64_array_class(cls); | 651 object_store->set_float64_array_class(cls); |
655 RegisterPrivateClass(cls, "_Float64Array", script, core_lib); | 652 RegisterPrivateClass(cls, "_Float64Array", core_lib); |
656 | 653 |
657 cls = Class::New<ExternalInt8Array>(); | 654 cls = Class::New<ExternalInt8Array>(); |
658 object_store->set_external_int8_array_class(cls); | 655 object_store->set_external_int8_array_class(cls); |
659 RegisterPrivateClass(cls, "_ExternalInt8Array", script, core_lib); | 656 RegisterPrivateClass(cls, "_ExternalInt8Array", core_lib); |
660 | 657 |
661 cls = Class::New<ExternalUint8Array>(); | 658 cls = Class::New<ExternalUint8Array>(); |
662 object_store->set_external_uint8_array_class(cls); | 659 object_store->set_external_uint8_array_class(cls); |
663 RegisterPrivateClass(cls, "_ExternalUint8Array", script, core_lib); | 660 RegisterPrivateClass(cls, "_ExternalUint8Array", core_lib); |
664 | 661 |
665 cls = Class::New<ExternalInt16Array>(); | 662 cls = Class::New<ExternalInt16Array>(); |
666 object_store->set_external_int16_array_class(cls); | 663 object_store->set_external_int16_array_class(cls); |
667 RegisterPrivateClass(cls, "_ExternalInt16Array", script, core_lib); | 664 RegisterPrivateClass(cls, "_ExternalInt16Array", core_lib); |
668 | 665 |
669 cls = Class::New<ExternalUint16Array>(); | 666 cls = Class::New<ExternalUint16Array>(); |
670 object_store->set_external_uint16_array_class(cls); | 667 object_store->set_external_uint16_array_class(cls); |
671 RegisterPrivateClass(cls, "_ExternalUint16Array", script, core_lib); | 668 RegisterPrivateClass(cls, "_ExternalUint16Array", core_lib); |
672 | 669 |
673 cls = Class::New<ExternalInt32Array>(); | 670 cls = Class::New<ExternalInt32Array>(); |
674 object_store->set_external_int32_array_class(cls); | 671 object_store->set_external_int32_array_class(cls); |
675 RegisterPrivateClass(cls, "_ExternalInt32Array", script, core_lib); | 672 RegisterPrivateClass(cls, "_ExternalInt32Array", core_lib); |
676 | 673 |
677 cls = Class::New<ExternalUint32Array>(); | 674 cls = Class::New<ExternalUint32Array>(); |
678 object_store->set_external_uint32_array_class(cls); | 675 object_store->set_external_uint32_array_class(cls); |
679 RegisterPrivateClass(cls, "_ExternalUint32Array", script, core_lib); | 676 RegisterPrivateClass(cls, "_ExternalUint32Array", core_lib); |
680 | 677 |
681 cls = Class::New<ExternalInt64Array>(); | 678 cls = Class::New<ExternalInt64Array>(); |
682 object_store->set_external_int64_array_class(cls); | 679 object_store->set_external_int64_array_class(cls); |
683 RegisterPrivateClass(cls, "_ExternalInt64Array", script, core_lib); | 680 RegisterPrivateClass(cls, "_ExternalInt64Array", core_lib); |
684 | 681 |
685 cls = Class::New<ExternalUint64Array>(); | 682 cls = Class::New<ExternalUint64Array>(); |
686 object_store->set_external_uint64_array_class(cls); | 683 object_store->set_external_uint64_array_class(cls); |
687 RegisterPrivateClass(cls, "_ExternalUint64Array", script, core_lib); | 684 RegisterPrivateClass(cls, "_ExternalUint64Array", core_lib); |
688 | 685 |
689 cls = Class::New<ExternalFloat32Array>(); | 686 cls = Class::New<ExternalFloat32Array>(); |
690 object_store->set_external_float32_array_class(cls); | 687 object_store->set_external_float32_array_class(cls); |
691 RegisterPrivateClass(cls, "_ExternalFloat32Array", script, core_lib); | 688 RegisterPrivateClass(cls, "_ExternalFloat32Array", core_lib); |
692 | 689 |
693 cls = Class::New<ExternalFloat64Array>(); | 690 cls = Class::New<ExternalFloat64Array>(); |
694 object_store->set_external_float64_array_class(cls); | 691 object_store->set_external_float64_array_class(cls); |
695 RegisterPrivateClass(cls, "_ExternalFloat64Array", script, core_lib); | 692 RegisterPrivateClass(cls, "_ExternalFloat64Array", core_lib); |
696 | 693 |
697 // Set the super type of class Stacktrace to Object type so that the | 694 // Set the super type of class Stacktrace to Object type so that the |
698 // 'toString' method is implemented. | 695 // 'toString' method is implemented. |
699 cls = object_store->stacktrace_class(); | 696 cls = object_store->stacktrace_class(); |
700 cls.set_super_type(type); | 697 cls.set_super_type(type); |
701 | 698 |
702 cls = CreateAndRegisterInterface("Function", script, core_lib); | 699 cls = CreateAndRegisterInterface("Function", script, core_lib); |
703 pending_classes.Add(cls, Heap::kOld); | 700 pending_classes.Add(cls, Heap::kOld); |
704 type = Type::NewNonParameterizedType(cls); | 701 type = Type::NewNonParameterizedType(cls); |
705 object_store->set_function_interface(type); | 702 object_store->set_function_interface(type); |
(...skipping 65 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
771 Library::InitNativeWrappersLibrary(isolate); | 768 Library::InitNativeWrappersLibrary(isolate); |
772 ASSERT(isolate->object_store()->native_wrappers_library() != Library::null()); | 769 ASSERT(isolate->object_store()->native_wrappers_library() != Library::null()); |
773 | 770 |
774 // Finish the initialization by compiling the bootstrap scripts containing the | 771 // Finish the initialization by compiling the bootstrap scripts containing the |
775 // base interfaces and the implementation of the internal classes. | 772 // base interfaces and the implementation of the internal classes. |
776 Error& error = Error::Handle(); | 773 Error& error = Error::Handle(); |
777 error = Bootstrap::Compile(core_lib, script); | 774 error = Bootstrap::Compile(core_lib, script); |
778 if (!error.IsNull()) { | 775 if (!error.IsNull()) { |
779 return error.raw(); | 776 return error.raw(); |
780 } | 777 } |
| 778 Script& patch_script = Script::Handle(Bootstrap::LoadCoreScript(true)); |
| 779 error = core_lib.Patch(patch_script); |
| 780 if (!error.IsNull()) { |
| 781 return error.raw(); |
| 782 } |
781 error = Bootstrap::Compile(core_impl_lib, impl_script); | 783 error = Bootstrap::Compile(core_impl_lib, impl_script); |
782 if (!error.IsNull()) { | 784 if (!error.IsNull()) { |
783 return error.raw(); | 785 return error.raw(); |
784 } | 786 } |
785 const Script& math_script = Script::Handle(Bootstrap::LoadMathScript()); | 787 patch_script = Bootstrap::LoadCoreImplScript(true); |
| 788 error = core_impl_lib.Patch(patch_script); |
| 789 if (!error.IsNull()) { |
| 790 return error.raw(); |
| 791 } |
| 792 const Script& math_script = Script::Handle(Bootstrap::LoadMathScript(false)); |
786 Library::InitMathLibrary(isolate); | 793 Library::InitMathLibrary(isolate); |
787 const Library& math_lib = Library::Handle(Library::MathLibrary()); | 794 const Library& math_lib = Library::Handle(Library::MathLibrary()); |
788 ASSERT(!math_lib.IsNull()); | 795 ASSERT(!math_lib.IsNull()); |
789 error = Bootstrap::Compile(math_lib, math_script); | 796 error = Bootstrap::Compile(math_lib, math_script); |
790 if (!error.IsNull()) { | 797 if (!error.IsNull()) { |
791 return error.raw(); | 798 return error.raw(); |
792 } | 799 } |
793 const Script& isolate_script = Script::Handle(Bootstrap::LoadIsolateScript()); | 800 patch_script = Bootstrap::LoadMathScript(true); |
| 801 error = math_lib.Patch(patch_script); |
| 802 if (!error.IsNull()) { |
| 803 return error.raw(); |
| 804 } |
| 805 const Script& isolate_script = Script::Handle( |
| 806 Bootstrap::LoadIsolateScript(false)); |
794 Library::InitIsolateLibrary(isolate); | 807 Library::InitIsolateLibrary(isolate); |
795 const Library& isolate_lib = Library::Handle(Library::IsolateLibrary()); | 808 const Library& isolate_lib = Library::Handle(Library::IsolateLibrary()); |
796 ASSERT(!isolate_lib.IsNull()); | 809 ASSERT(!isolate_lib.IsNull()); |
797 error = Bootstrap::Compile(isolate_lib, isolate_script); | 810 error = Bootstrap::Compile(isolate_lib, isolate_script); |
798 if (!error.IsNull()) { | 811 if (!error.IsNull()) { |
799 return error.raw(); | 812 return error.raw(); |
800 } | 813 } |
801 const Script& mirrors_script = Script::Handle(Bootstrap::LoadMirrorsScript()); | 814 patch_script = Bootstrap::LoadIsolateScript(true); |
| 815 error = isolate_lib.Patch(patch_script); |
| 816 if (!error.IsNull()) { |
| 817 return error.raw(); |
| 818 } |
| 819 const Script& mirrors_script = Script::Handle( |
| 820 Bootstrap::LoadMirrorsScript(false)); |
802 Library::InitMirrorsLibrary(isolate); | 821 Library::InitMirrorsLibrary(isolate); |
803 const Library& mirrors_lib = Library::Handle(Library::MirrorsLibrary()); | 822 const Library& mirrors_lib = Library::Handle(Library::MirrorsLibrary()); |
804 ASSERT(!mirrors_lib.IsNull()); | 823 ASSERT(!mirrors_lib.IsNull()); |
805 error = Bootstrap::Compile(mirrors_lib, mirrors_script); | 824 error = Bootstrap::Compile(mirrors_lib, mirrors_script); |
806 if (!error.IsNull()) { | 825 if (!error.IsNull()) { |
807 return error.raw(); | 826 return error.raw(); |
808 } | 827 } |
| 828 patch_script = Bootstrap::LoadMirrorsScript(true); |
| 829 error = mirrors_lib.Patch(patch_script); |
| 830 if (!error.IsNull()) { |
| 831 return error.raw(); |
| 832 } |
809 Bootstrap::SetupNativeResolver(); | 833 Bootstrap::SetupNativeResolver(); |
810 | 834 |
811 // Remove the Object superclass cycle by setting the super type to null (not | 835 // Remove the Object superclass cycle by setting the super type to null (not |
812 // to the type of null). | 836 // to the type of null). |
813 cls = object_store->object_class(); | 837 cls = object_store->object_class(); |
814 cls.set_super_type(Type::Handle()); | 838 cls.set_super_type(Type::Handle()); |
815 | 839 |
816 ClassFinalizer::VerifyBootstrapClasses(); | 840 ClassFinalizer::VerifyBootstrapClasses(); |
817 return Error::null(); | 841 return Error::null(); |
818 } | 842 } |
(...skipping 5343 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
6162 lib ^= libs.At(i); | 6186 lib ^= libs.At(i); |
6163 error_message = lib.FindDuplicateDefinition(); | 6187 error_message = lib.FindDuplicateDefinition(); |
6164 if (!error_message.IsNull()) { | 6188 if (!error_message.IsNull()) { |
6165 return error_message.raw(); | 6189 return error_message.raw(); |
6166 } | 6190 } |
6167 } | 6191 } |
6168 return String::null(); | 6192 return String::null(); |
6169 } | 6193 } |
6170 | 6194 |
6171 | 6195 |
6172 RawError* Library::Patch(const String& url, const String& source) const { | 6196 RawError* Library::Patch(const Script& script) const { |
6173 const Script& script = Script::Handle( | 6197 ASSERT(script.kind() == RawScript::kPatchTag); |
6174 Script::New(url, source, RawScript::kPatchTag)); | |
6175 return Compiler::Compile(*this, script); | 6198 return Compiler::Compile(*this, script); |
6176 } | 6199 } |
6177 | 6200 |
6178 | 6201 |
6179 bool Library::IsKeyUsed(intptr_t key) { | 6202 bool Library::IsKeyUsed(intptr_t key) { |
6180 intptr_t lib_key; | 6203 intptr_t lib_key; |
6181 const GrowableObjectArray& libs = GrowableObjectArray::Handle( | 6204 const GrowableObjectArray& libs = GrowableObjectArray::Handle( |
6182 Isolate::Current()->object_store()->libraries()); | 6205 Isolate::Current()->object_store()->libraries()); |
6183 Library& lib = Library::Handle(); | 6206 Library& lib = Library::Handle(); |
6184 String& lib_url = String::Handle(); | 6207 String& lib_url = String::Handle(); |
(...skipping 4843 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
11028 const char* JSRegExp::ToCString() const { | 11051 const char* JSRegExp::ToCString() const { |
11029 const String& str = String::Handle(pattern()); | 11052 const String& str = String::Handle(pattern()); |
11030 const char* format = "JSRegExp: pattern=%s flags=%s"; | 11053 const char* format = "JSRegExp: pattern=%s flags=%s"; |
11031 intptr_t len = OS::SNPrint(NULL, 0, format, str.ToCString(), Flags()); | 11054 intptr_t len = OS::SNPrint(NULL, 0, format, str.ToCString(), Flags()); |
11032 char* chars = Isolate::Current()->current_zone()->Alloc<char>(len + 1); | 11055 char* chars = Isolate::Current()->current_zone()->Alloc<char>(len + 1); |
11033 OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags()); | 11056 OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags()); |
11034 return chars; | 11057 return chars; |
11035 } | 11058 } |
11036 | 11059 |
11037 } // namespace dart | 11060 } // namespace dart |
OLD | NEW |