- Split Dart core libraries into shared sources and patch sources.

vm/object.h

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef VM_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 267 matching lines @@
   static RawClass* context_scope_class() { return context_scope_class_; }
   static RawClass* api_error_class() { return api_error_class_; }
   static RawClass* language_error_class() { return language_error_class_; }
   static RawClass* unhandled_exception_class() {
     return unhandled_exception_class_;
   }
   static RawClass* unwind_error_class() { return unwind_error_class_; }
   static RawClass* icdata_class() { return icdata_class_; }
   static RawClass* subtypetestcache_class() { return subtypetestcache_class_; }
 
-  static RawClass* CreateAndRegisterInterface(const char* cname,
-                                              const Script& script,
-                                              const Library& lib);
-  static void RegisterClass(const Class& cls,
-                            const char* cname,
-                            const Script& script,
-                            const Library& lib);
-
-  static void RegisterPrivateClass(const Class& cls,
-                                   const char* cname,
-                                   const Script& script,
-                                   const Library& lib);
-
   static RawError* Init(Isolate* isolate);
   static void InitFromSnapshot(Isolate* isolate);
   static void InitOnce();
   static void RegisterSingletonClassNames();
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawObject));
   }
 
   static const ClassId kClassId = kObjectCid;
@@ skipping 47 matching lines @@
       uword ptr = reinterpret_cast<uword>(addr);
       Isolate::Current()->store_buffer()->AddPointer(ptr);
     }
   }
 
   RawObject* raw_;  // The raw object reference.
 
  private:
   static void InitializeObject(uword address, intptr_t id, intptr_t size);
 
+  static RawClass* CreateAndRegisterInterface(const char* cname,
+                                              const Script& script,
+                                              const Library& lib);
+  static void RegisterClass(const Class& cls,
+                            const char* cname,
+                            const Library& lib);
+  static void RegisterPrivateClass(const Class& cls,
+                                   const char* cname,
+                                   const Library& lib);
+
   cpp_vtable* vtable_address() const {
     uword vtable_addr = reinterpret_cast<uword>(this);
     return reinterpret_cast<cpp_vtable*>(vtable_addr);
   }
 
   static cpp_vtable handle_vtable_;
   static cpp_vtable builtin_vtables_[kNumPredefinedCids];
 
   // The static values below are singletons shared between the different
   // isolates. They are all allocated in the non-GC'd Dart::vm_isolate_.
@@ skipping 79 matching lines @@
   intptr_t id() const { return raw_ptr()->id_; }
   void set_id(intptr_t value) const {
     raw_ptr()->id_ = value;
   }
 
   RawString* Name() const;
 
   RawString* UserVisibleName() const;
 
   RawScript* script() const { return raw_ptr()->script_; }
+  void set_script(const Script& value) const;
 
   intptr_t token_pos() const { return raw_ptr()->token_pos_; }
 
   // This class represents the signature class of a closure function if
   // signature_function() is not null.
   // The associated function may be a closure function (with code) or a
   // signature function (without code) solely describing the result type and
   // parameter types of the signature.
   RawFunction* signature_function() const {
     return raw_ptr()->signature_function_;
@@ skipping 228 matching lines @@
                                      const Function& signature_function,
                                      const Script& script);
 
   // Return a class object corresponding to the specified kind. If
   // a canonicalized version of it exists then that object is returned
   // otherwise a new object is allocated and returned.
   static RawClass* GetClass(intptr_t class_id, bool is_signature_class);
 
  private:
   void set_name(const String& value) const;
-  void set_script(const Script& value) const;
   void set_token_pos(intptr_t value) const;
   void set_signature_function(const Function& value) const;
   void set_signature_type(const AbstractType& value) const;
   void set_class_state(int8_t state) const;
 
   void set_constants(const Array& value) const;
 
   void set_canonical_types(const Array& value) const;
   RawArray* canonical_types() const;
 
@@ skipping 1262 matching lines @@
                                       intptr_t token_pos) const;
 
   // Resolving native methods for script loaded in the library.
   Dart_NativeEntryResolver native_entry_resolver() const {
     return raw_ptr()->native_entry_resolver_;
   }
   void set_native_entry_resolver(Dart_NativeEntryResolver value) const {
     raw_ptr()->native_entry_resolver_ = value;
   }
 
-  RawError* Patch(const String& url, const String& source) const;
+  RawError* Patch(const Script& script) const;
 
   RawString* PrivateName(const String& name) const;
 
   intptr_t index() const { return raw_ptr()->index_; }
   void set_index(intptr_t value) const {
     raw_ptr()->index_ = value;
   }
 
   void Register() const;
 
@@ skipping 3443 matching lines @@
     if (this->CharAt(i) != str.CharAt(begin_index + i)) {
       return false;
     }
   }
   return true;
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_