src/3rdparty/v8/src/handles-inl.h

   1 // Copyright 2006-2008 the V8 project authors. All rights reserved.
   2 // 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
  29 #ifndef V8_HANDLES_INL_H_
  30 #define V8_HANDLES_INL_H_
  31
  32 #include "api.h"
  33 #include "apiutils.h"
  34 #include "handles.h"
  35 #include "isolate.h"
  36
  37 namespace v8 {
  38 namespace internal {
  39
  40 inline Isolate* GetIsolateForHandle(Object* obj) {
  41   return Isolate::Current();
  42 }
  43
  44 inline Isolate* GetIsolateForHandle(HeapObject* obj) {
  45   return obj->GetIsolate();
  46 }
  47
  48 template<typename T>
  49 Handle<T>::Handle(T* obj) {
  50   ASSERT(!obj->IsFailure());
  51   location_ = HandleScope::CreateHandle(obj, GetIsolateForHandle(obj));
  52 }
  53
  54
  55 template<typename T>
  56 Handle<T>::Handle(T* obj, Isolate* isolate) {
  57   ASSERT(!obj->IsFailure());
  58   location_ = HandleScope::CreateHandle(obj, isolate);
  59 }
  60
  61
  62 template <typename T>
  63 inline T* Handle<T>::operator*() const {
  64   ASSERT(location_ != NULL);
  65   ASSERT(reinterpret_cast<Address>(*location_) != kHandleZapValue);
  66   return *BitCast<T**>(location_);
  67 }
  68
  69
  70 HandleScope::HandleScope() {
  71   Isolate* isolate = Isolate::Current();
  72   v8::ImplementationUtilities::HandleScopeData* current =
  73       isolate->handle_scope_data();
  74   isolate_ = isolate;
  75   prev_next_ = current->next;
  76   prev_limit_ = current->limit;
  77   current->level++;
  78 }
  79
  80
  81 HandleScope::HandleScope(Isolate* isolate) {
  82   ASSERT(isolate == Isolate::Current());
  83   v8::ImplementationUtilities::HandleScopeData* current =
  84       isolate->handle_scope_data();
  85   isolate_ = isolate;
  86   prev_next_ = current->next;
  87   prev_limit_ = current->limit;
  88   current->level++;
  89 }
  90
  91
  92 HandleScope::~HandleScope() {
  93   CloseScope();
  94 }
  95
  96 void HandleScope::CloseScope() {
  97   ASSERT(isolate_ == Isolate::Current());
  98   v8::ImplementationUtilities::HandleScopeData* current =
  99       isolate_->handle_scope_data();
 100   current->next = prev_next_;
 101   current->level--;
 102   if (current->limit != prev_limit_) {
 103     current->limit = prev_limit_;
 104     DeleteExtensions(isolate_);
 105   }
 106 #ifdef DEBUG
 107   ZapRange(prev_next_, prev_limit_);
 108 #endif
 109 }
 110
 111
 112 template <typename T>
 113 Handle<T> HandleScope::CloseAndEscape(Handle<T> handle_value) {
 114   T* value = *handle_value;
 115   // Throw away all handles in the current scope.
 116   CloseScope();
 117   v8::ImplementationUtilities::HandleScopeData* current =
 118       isolate_->handle_scope_data();
 119   // Allocate one handle in the parent scope.
 120   ASSERT(current->level > 0);
 121   Handle<T> result(CreateHandle<T>(value, isolate_));
 122   // Reinitialize the current scope (so that it's ready
 123   // to be used or closed again).
 124   prev_next_ = current->next;
 125   prev_limit_ = current->limit;
 126   current->level++;
 127   return result;
 128 }
 129
 130
 131 template <typename T>
 132 T** HandleScope::CreateHandle(T* value, Isolate* isolate) {
 133   ASSERT(isolate == Isolate::Current());
 134   v8::ImplementationUtilities::HandleScopeData* current =
 135       isolate->handle_scope_data();
 136
 137   internal::Object** cur = current->next;
 138   if (cur == current->limit) cur = Extend();
 139   // Update the current next field, set the value in the created
 140   // handle, and return the result.
 141   ASSERT(cur < current->limit);
 142   current->next = cur + 1;
 143
 144   T** result = reinterpret_cast<T**>(cur);
 145   *result = value;
 146   return result;
 147 }
 148
 149
 150 #ifdef DEBUG
 151 inline NoHandleAllocation::NoHandleAllocation() {
 152   v8::ImplementationUtilities::HandleScopeData* current =
 153       Isolate::Current()->handle_scope_data();
 154
 155   // Shrink the current handle scope to make it impossible to do
 156   // handle allocations without an explicit handle scope.
 157   current->limit = current->next;
 158
 159   level_ = current->level;
 160   current->level = 0;
 161 }
 162
 163
 164 inline NoHandleAllocation::~NoHandleAllocation() {
 165   // Restore state in current handle scope to re-enable handle
 166   // allocations.
 167   v8::ImplementationUtilities::HandleScopeData* data =
 168       Isolate::Current()->handle_scope_data();
 169   ASSERT_EQ(0, data->level);
 170   data->level = level_;
 171 }
 172 #endif
 173
 174
 175 } }  // namespace v8::internal
 176
 177 #endif  // V8_HANDLES_INL_H_