abort in delete operators that shouldn't be called

include/v8.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 /** \mainpage V8 API Reference Guide
  *
  * V8 is Google's open source JavaScript engine.
  *
  * This set of documents provides reference material generated from the
  * V8 header file, include/v8.h.
@@ skipping 849 matching lines @@
    * Counts the number of allocated handles.
    */
   static int NumberOfHandles(Isolate* isolate);
 
   V8_INLINE Isolate* GetIsolate() const {
     return reinterpret_cast<Isolate*>(isolate_);
   }
 
   HandleScope(const HandleScope&) = delete;
   void operator=(const HandleScope&) = delete;
-  void* operator new(size_t size) = delete;
-  void operator delete(void*, size_t) = delete;
+  void* operator new(size_t size);
+  void operator delete(void*, size_t);
 
  protected:
   V8_INLINE HandleScope() {}
 
   void Initialize(Isolate* isolate);
 
   static internal::Object** CreateHandle(internal::Isolate* isolate,
                                          internal::Object* value);
 
  private:
@@ skipping 30 matching lines @@
    */
   template <class T>
   V8_INLINE Local<T> Escape(Local<T> value) {
     internal::Object** slot =
         Escape(reinterpret_cast<internal::Object**>(*value));
     return Local<T>(reinterpret_cast<T*>(slot));
   }
 
   EscapableHandleScope(const EscapableHandleScope&) = delete;
   void operator=(const EscapableHandleScope&) = delete;
-  void* operator new(size_t size) = delete;
-  void operator delete(void*, size_t) = delete;
+  void* operator new(size_t size);
+  void operator delete(void*, size_t);
 
  private:
   internal::Object** Escape(internal::Object** escape_value);
   internal::Object** escape_slot_;
 };
 
 class V8_EXPORT SealHandleScope {
  public:
   SealHandleScope(Isolate* isolate);
   ~SealHandleScope();
 
   SealHandleScope(const SealHandleScope&) = delete;
   void operator=(const SealHandleScope&) = delete;
-  void* operator new(size_t size) = delete;
-  void operator delete(void*, size_t) = delete;
+  void* operator new(size_t size);
+  void operator delete(void*, size_t);
 
  private:
   internal::Isolate* const isolate_;
   internal::Object** prev_limit_;
   int prev_sealed_level_;
 };
 
 
 // --- Special objects ---
 
@@ skipping 6906 matching lines @@
    * UseAfterReturn is enabled, then the address returned will be the address
    * of the C++ try catch handler itself.
    */
   static void* JSStackComparableAddress(v8::TryCatch* handler) {
     if (handler == NULL) return NULL;
     return handler->js_stack_comparable_address_;
   }
 
   TryCatch(const TryCatch&) = delete;
   void operator=(const TryCatch&) = delete;
-  void* operator new(size_t size) = delete;
-  void operator delete(void*, size_t) = delete;
+  void* operator new(size_t size);
+  void operator delete(void*, size_t);
 
  private:
   void ResetInternal();
 
   v8::internal::Isolate* isolate_;
   v8::TryCatch* next_;
   void* exception_;
   void* message_obj_;
   void* js_stack_comparable_address_;
   bool is_verbose_ : 1;
@@ skipping 1854 matching lines @@
  */
 
 
 }  // namespace v8
 
 
 #undef TYPE_CHECK
 
 
 #endif  // INCLUDE_V8_H_