Home | History | Annotate | Download | only in src 
      1 // Copyright 2012 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 #ifndef V8_API_H_
     29 #define V8_API_H_
     30 
     31 #include "v8.h"
     32 
     33 #include "../include/v8-testing.h"
     34 #include "apiutils.h"
     35 #include "contexts.h"
     36 #include "factory.h"
     37 #include "isolate.h"
     38 #include "list-inl.h"
     39 
     40 namespace v8 {
     41 
     42 // Constants used in the implementation of the API.  The most natural thing
     43 // would usually be to place these with the classes that use them, but
     44 // we want to keep them out of v8.h because it is an externally
     45 // visible file.
     46 class Consts {
     47  public:
     48   enum TemplateType {
     49     FUNCTION_TEMPLATE = 0,
     50     OBJECT_TEMPLATE = 1
     51   };
     52 };
     53 
     54 
     55 // Utilities for working with neander-objects, primitive
     56 // env-independent JSObjects used by the api.
     57 class NeanderObject {
     58  public:
     59   explicit NeanderObject(int size);
     60   explicit inline NeanderObject(v8::internal::Handle<v8::internal::Object> obj);
     61   explicit inline NeanderObject(v8::internal::Object* obj);
     62   inline v8::internal::Object* get(int index);
     63   inline void set(int index, v8::internal::Object* value);
     64   inline v8::internal::Handle<v8::internal::JSObject> value() { return value_; }
     65   int size();
     66  private:
     67   v8::internal::Handle<v8::internal::JSObject> value_;
     68 };
     69 
     70 
     71 // Utilities for working with neander-arrays, a simple extensible
     72 // array abstraction built on neander-objects.
     73 class NeanderArray {
     74  public:
     75   NeanderArray();
     76   explicit inline NeanderArray(v8::internal::Handle<v8::internal::Object> obj);
     77   inline v8::internal::Handle<v8::internal::JSObject> value() {
     78     return obj_.value();
     79   }
     80 
     81   void add(v8::internal::Handle<v8::internal::Object> value);
     82 
     83   int length();
     84 
     85   v8::internal::Object* get(int index);
     86   // Change the value at an index to undefined value. If the index is
     87   // out of bounds, the request is ignored. Returns the old value.
     88   void set(int index, v8::internal::Object* value);
     89  private:
     90   NeanderObject obj_;
     91 };
     92 
     93 
     94 NeanderObject::NeanderObject(v8::internal::Handle<v8::internal::Object> obj)
     95     : value_(v8::internal::Handle<v8::internal::JSObject>::cast(obj)) { }
     96 
     97 
     98 NeanderObject::NeanderObject(v8::internal::Object* obj)
     99     : value_(v8::internal::Handle<v8::internal::JSObject>(
    100         v8::internal::JSObject::cast(obj))) { }
    101 
    102 
    103 NeanderArray::NeanderArray(v8::internal::Handle<v8::internal::Object> obj)
    104     : obj_(obj) { }
    105 
    106 
    107 v8::internal::Object* NeanderObject::get(int offset) {
    108   ASSERT(value()->HasFastObjectElements());
    109   return v8::internal::FixedArray::cast(value()->elements())->get(offset);
    110 }
    111 
    112 
    113 void NeanderObject::set(int offset, v8::internal::Object* value) {
    114   ASSERT(value_->HasFastObjectElements());
    115   v8::internal::FixedArray::cast(value_->elements())->set(offset, value);
    116 }
    117 
    118 
    119 template <typename T> inline T ToCData(v8::internal::Object* obj) {
    120   STATIC_ASSERT(sizeof(T) == sizeof(v8::internal::Address));
    121   return reinterpret_cast<T>(
    122       reinterpret_cast<intptr_t>(
    123           v8::internal::Foreign::cast(obj)->foreign_address()));
    124 }
    125 
    126 
    127 template <typename T>
    128 inline v8::internal::Handle<v8::internal::Object> FromCData(T obj) {
    129   v8::internal::Isolate* isolate = v8::internal::Isolate::Current();
    130   STATIC_ASSERT(sizeof(T) == sizeof(v8::internal::Address));
    131   return isolate->factory()->NewForeign(
    132       reinterpret_cast<v8::internal::Address>(reinterpret_cast<intptr_t>(obj)));
    133 }
    134 
    135 
    136 class ApiFunction {
    137  public:
    138   explicit ApiFunction(v8::internal::Address addr) : addr_(addr) { }
    139   v8::internal::Address address() { return addr_; }
    140  private:
    141   v8::internal::Address addr_;
    142 };
    143 
    144 
    145 
    146 class RegisteredExtension {
    147  public:
    148   explicit RegisteredExtension(Extension* extension);
    149   static void Register(RegisteredExtension* that);
    150   static void UnregisterAll();
    151   Extension* extension() { return extension_; }
    152   RegisteredExtension* next() { return next_; }
    153   static RegisteredExtension* first_extension() { return first_extension_; }
    154  private:
    155   Extension* extension_;
    156   RegisteredExtension* next_;
    157   static RegisteredExtension* first_extension_;
    158 };
    159 
    160 
    161 #define OPEN_HANDLE_LIST(V)                    \
    162   V(Template, TemplateInfo)                    \
    163   V(FunctionTemplate, FunctionTemplateInfo)    \
    164   V(ObjectTemplate, ObjectTemplateInfo)        \
    165   V(Signature, SignatureInfo)                  \
    166   V(AccessorSignature, FunctionTemplateInfo)   \
    167   V(TypeSwitch, TypeSwitchInfo)                \
    168   V(Data, Object)                              \
    169   V(RegExp, JSRegExp)                          \
    170   V(Object, JSObject)                          \
    171   V(Array, JSArray)                            \
    172   V(ArrayBuffer, JSArrayBuffer)                \
    173   V(ArrayBufferView, JSArrayBufferView)        \
    174   V(TypedArray, JSTypedArray)                  \
    175   V(Uint8Array, JSTypedArray)                  \
    176   V(Uint8ClampedArray, JSTypedArray)           \
    177   V(Int8Array, JSTypedArray)                   \
    178   V(Uint16Array, JSTypedArray)                 \
    179   V(Int16Array, JSTypedArray)                  \
    180   V(Uint32Array, JSTypedArray)                 \
    181   V(Int32Array, JSTypedArray)                  \
    182   V(Float32Array, JSTypedArray)                \
    183   V(Float64Array, JSTypedArray)                \
    184   V(DataView, JSDataView)                      \
    185   V(String, String)                            \
    186   V(Symbol, Symbol)                            \
    187   V(Script, Object)                            \
    188   V(Function, JSFunction)                      \
    189   V(Message, JSObject)                         \
    190   V(Context, Context)                          \
    191   V(External, Foreign)                         \
    192   V(StackTrace, JSArray)                       \
    193   V(StackFrame, JSObject)                      \
    194   V(DeclaredAccessorDescriptor, DeclaredAccessorDescriptor)
    195 
    196 
    197 class Utils {
    198  public:
    199   static bool ReportApiFailure(const char* location, const char* message);
    200 
    201   static Local<FunctionTemplate> ToFunctionTemplate(NeanderObject obj);
    202   static Local<ObjectTemplate> ToObjectTemplate(NeanderObject obj);
    203 
    204   static inline Local<Context> ToLocal(
    205       v8::internal::Handle<v8::internal::Context> obj);
    206   static inline Local<Value> ToLocal(
    207       v8::internal::Handle<v8::internal::Object> obj);
    208   static inline Local<Function> ToLocal(
    209       v8::internal::Handle<v8::internal::JSFunction> obj);
    210   static inline Local<String> ToLocal(
    211       v8::internal::Handle<v8::internal::String> obj);
    212   static inline Local<Symbol> ToLocal(
    213       v8::internal::Handle<v8::internal::Symbol> obj);
    214   static inline Local<RegExp> ToLocal(
    215       v8::internal::Handle<v8::internal::JSRegExp> obj);
    216   static inline Local<Object> ToLocal(
    217       v8::internal::Handle<v8::internal::JSObject> obj);
    218   static inline Local<Array> ToLocal(
    219       v8::internal::Handle<v8::internal::JSArray> obj);
    220   static inline Local<ArrayBuffer> ToLocal(
    221       v8::internal::Handle<v8::internal::JSArrayBuffer> obj);
    222   static inline Local<ArrayBufferView> ToLocal(
    223       v8::internal::Handle<v8::internal::JSArrayBufferView> obj);
    224   static inline Local<DataView> ToLocal(
    225       v8::internal::Handle<v8::internal::JSDataView> obj);
    226 
    227   static inline Local<TypedArray> ToLocal(
    228       v8::internal::Handle<v8::internal::JSTypedArray> obj);
    229   static inline Local<Uint8Array> ToLocalUint8Array(
    230       v8::internal::Handle<v8::internal::JSTypedArray> obj);
    231   static inline Local<Uint8ClampedArray> ToLocalUint8ClampedArray(
    232       v8::internal::Handle<v8::internal::JSTypedArray> obj);
    233   static inline Local<Int8Array> ToLocalInt8Array(
    234       v8::internal::Handle<v8::internal::JSTypedArray> obj);
    235   static inline Local<Uint16Array> ToLocalUint16Array(
    236       v8::internal::Handle<v8::internal::JSTypedArray> obj);
    237   static inline Local<Int16Array> ToLocalInt16Array(
    238       v8::internal::Handle<v8::internal::JSTypedArray> obj);
    239   static inline Local<Uint32Array> ToLocalUint32Array(
    240       v8::internal::Handle<v8::internal::JSTypedArray> obj);
    241   static inline Local<Int32Array> ToLocalInt32Array(
    242       v8::internal::Handle<v8::internal::JSTypedArray> obj);
    243   static inline Local<Float32Array> ToLocalFloat32Array(
    244       v8::internal::Handle<v8::internal::JSTypedArray> obj);
    245   static inline Local<Float64Array> ToLocalFloat64Array(
    246       v8::internal::Handle<v8::internal::JSTypedArray> obj);
    247 
    248   static inline Local<Message> MessageToLocal(
    249       v8::internal::Handle<v8::internal::Object> obj);
    250   static inline Local<StackTrace> StackTraceToLocal(
    251       v8::internal::Handle<v8::internal::JSArray> obj);
    252   static inline Local<StackFrame> StackFrameToLocal(
    253       v8::internal::Handle<v8::internal::JSObject> obj);
    254   static inline Local<Number> NumberToLocal(
    255       v8::internal::Handle<v8::internal::Object> obj);
    256   static inline Local<Integer> IntegerToLocal(
    257       v8::internal::Handle<v8::internal::Object> obj);
    258   static inline Local<Uint32> Uint32ToLocal(
    259       v8::internal::Handle<v8::internal::Object> obj);
    260   static inline Local<FunctionTemplate> ToLocal(
    261       v8::internal::Handle<v8::internal::FunctionTemplateInfo> obj);
    262   static inline Local<ObjectTemplate> ToLocal(
    263       v8::internal::Handle<v8::internal::ObjectTemplateInfo> obj);
    264   static inline Local<Signature> ToLocal(
    265       v8::internal::Handle<v8::internal::SignatureInfo> obj);
    266   static inline Local<AccessorSignature> AccessorSignatureToLocal(
    267       v8::internal::Handle<v8::internal::FunctionTemplateInfo> obj);
    268   static inline Local<TypeSwitch> ToLocal(
    269       v8::internal::Handle<v8::internal::TypeSwitchInfo> obj);
    270   static inline Local<External> ExternalToLocal(
    271       v8::internal::Handle<v8::internal::JSObject> obj);
    272   static inline Local<DeclaredAccessorDescriptor> ToLocal(
    273       v8::internal::Handle<v8::internal::DeclaredAccessorDescriptor> obj);
    274 
    275 #define DECLARE_OPEN_HANDLE(From, To) \
    276   static inline v8::internal::Handle<v8::internal::To> \
    277       OpenHandle(const From* that, bool allow_empty_handle = false);
    278 
    279 OPEN_HANDLE_LIST(DECLARE_OPEN_HANDLE)
    280 
    281 #undef DECLARE_OPEN_HANDLE
    282 
    283   template<class From, class To>
    284   static inline Local<To> Convert(v8::internal::Handle<From> obj) {
    285     ASSERT(obj.is_null() || !obj->IsTheHole());
    286     return Local<To>(reinterpret_cast<To*>(obj.location()));
    287   }
    288 
    289   template <class T>
    290   static inline v8::internal::Handle<v8::internal::Object> OpenPersistent(
    291       const v8::Persistent<T>& persistent) {
    292     return v8::internal::Handle<v8::internal::Object>(
    293         reinterpret_cast<v8::internal::Object**>(persistent.val_));
    294   }
    295 
    296   template <class T>
    297   static inline v8::internal::Handle<v8::internal::Object> OpenPersistent(
    298       v8::Persistent<T>* persistent) {
    299     return OpenPersistent(*persistent);
    300   }
    301 
    302   template <class From, class To>
    303   static inline v8::internal::Handle<To> OpenHandle(v8::Local<From> handle) {
    304     return OpenHandle(*handle);
    305   }
    306 };
    307 
    308 
    309 template <class T>
    310 v8::internal::Handle<T> v8::internal::Handle<T>::EscapeFrom(
    311     v8::HandleScope* scope) {
    312   v8::internal::Handle<T> handle;
    313   if (!is_null()) {
    314     handle = *this;
    315   }
    316   return Utils::OpenHandle(*scope->Close(Utils::ToLocal(handle)), true);
    317 }
    318 
    319 
    320 template <class T>
    321 inline T* ToApi(v8::internal::Handle<v8::internal::Object> obj) {
    322   return reinterpret_cast<T*>(obj.location());
    323 }
    324 
    325 template <class T>
    326 inline v8::Local<T> ToApiHandle(
    327     v8::internal::Handle<v8::internal::Object> obj) {
    328   return Utils::Convert<v8::internal::Object, T>(obj);
    329 }
    330 
    331 
    332 // Implementations of ToLocal
    333 
    334 #define MAKE_TO_LOCAL(Name, From, To)                                       \
    335   Local<v8::To> Utils::Name(v8::internal::Handle<v8::internal::From> obj) { \
    336     return Convert<v8::internal::From, v8::To>(obj);  \
    337   }
    338 
    339 
    340 #define MAKE_TO_LOCAL_TYPED_ARRAY(TypedArray, typeConst)                    \
    341   Local<v8::TypedArray> Utils::ToLocal##TypedArray(                         \
    342       v8::internal::Handle<v8::internal::JSTypedArray> obj) {               \
    343     ASSERT(obj->type() == typeConst);                                       \
    344     return Convert<v8::internal::JSTypedArray, v8::TypedArray>(obj);        \
    345   }
    346 
    347 
    348 MAKE_TO_LOCAL(ToLocal, Context, Context)
    349 MAKE_TO_LOCAL(ToLocal, Object, Value)
    350 MAKE_TO_LOCAL(ToLocal, JSFunction, Function)
    351 MAKE_TO_LOCAL(ToLocal, String, String)
    352 MAKE_TO_LOCAL(ToLocal, Symbol, Symbol)
    353 MAKE_TO_LOCAL(ToLocal, JSRegExp, RegExp)
    354 MAKE_TO_LOCAL(ToLocal, JSObject, Object)
    355 MAKE_TO_LOCAL(ToLocal, JSArray, Array)
    356 MAKE_TO_LOCAL(ToLocal, JSArrayBuffer, ArrayBuffer)
    357 MAKE_TO_LOCAL(ToLocal, JSArrayBufferView, ArrayBufferView)
    358 MAKE_TO_LOCAL(ToLocal, JSDataView, DataView)
    359 MAKE_TO_LOCAL(ToLocal, JSTypedArray, TypedArray)
    360 
    361 MAKE_TO_LOCAL_TYPED_ARRAY(Uint8Array, kExternalUnsignedByteArray)
    362 MAKE_TO_LOCAL_TYPED_ARRAY(Uint8ClampedArray, kExternalPixelArray)
    363 MAKE_TO_LOCAL_TYPED_ARRAY(Int8Array, kExternalByteArray)
    364 MAKE_TO_LOCAL_TYPED_ARRAY(Uint16Array, kExternalUnsignedShortArray)
    365 MAKE_TO_LOCAL_TYPED_ARRAY(Int16Array, kExternalShortArray)
    366 MAKE_TO_LOCAL_TYPED_ARRAY(Uint32Array, kExternalUnsignedIntArray)
    367 MAKE_TO_LOCAL_TYPED_ARRAY(Int32Array, kExternalIntArray)
    368 MAKE_TO_LOCAL_TYPED_ARRAY(Float32Array, kExternalFloatArray)
    369 MAKE_TO_LOCAL_TYPED_ARRAY(Float64Array, kExternalDoubleArray)
    370 
    371 MAKE_TO_LOCAL(ToLocal, FunctionTemplateInfo, FunctionTemplate)
    372 MAKE_TO_LOCAL(ToLocal, ObjectTemplateInfo, ObjectTemplate)
    373 MAKE_TO_LOCAL(ToLocal, SignatureInfo, Signature)
    374 MAKE_TO_LOCAL(AccessorSignatureToLocal, FunctionTemplateInfo, AccessorSignature)
    375 MAKE_TO_LOCAL(ToLocal, TypeSwitchInfo, TypeSwitch)
    376 MAKE_TO_LOCAL(MessageToLocal, Object, Message)
    377 MAKE_TO_LOCAL(StackTraceToLocal, JSArray, StackTrace)
    378 MAKE_TO_LOCAL(StackFrameToLocal, JSObject, StackFrame)
    379 MAKE_TO_LOCAL(NumberToLocal, Object, Number)
    380 MAKE_TO_LOCAL(IntegerToLocal, Object, Integer)
    381 MAKE_TO_LOCAL(Uint32ToLocal, Object, Uint32)
    382 MAKE_TO_LOCAL(ExternalToLocal, JSObject, External)
    383 MAKE_TO_LOCAL(ToLocal, DeclaredAccessorDescriptor, DeclaredAccessorDescriptor)
    384 
    385 #undef MAKE_TO_LOCAL_TYPED_ARRAY
    386 #undef MAKE_TO_LOCAL
    387 
    388 
    389 // Implementations of OpenHandle
    390 
    391 #define MAKE_OPEN_HANDLE(From, To)                                          \
    392   v8::internal::Handle<v8::internal::To> Utils::OpenHandle(                 \
    393     const v8::From* that, bool allow_empty_handle) {                        \
    394     EXTRA_CHECK(allow_empty_handle || that != NULL);                        \
    395     EXTRA_CHECK(that == NULL ||                                             \
    396         !(*reinterpret_cast<v8::internal::To**>(                            \
    397             const_cast<v8::From*>(that)))->IsFailure());                    \
    398     return v8::internal::Handle<v8::internal::To>(                          \
    399         reinterpret_cast<v8::internal::To**>(const_cast<v8::From*>(that))); \
    400   }
    401 
    402 OPEN_HANDLE_LIST(MAKE_OPEN_HANDLE)
    403 
    404 #undef MAKE_OPEN_HANDLE
    405 #undef OPEN_HANDLE_LIST
    406 
    407 
    408 namespace internal {
    409 
    410 // Tracks string usage to help make better decisions when
    411 // externalizing strings.
    412 //
    413 // Implementation note: internally this class only tracks fresh
    414 // strings and keeps a single use counter for them.
    415 class StringTracker {
    416  public:
    417   // Records that the given string's characters were copied to some
    418   // external buffer. If this happens often we should honor
    419   // externalization requests for the string.
    420   void RecordWrite(Handle<String> string) {
    421     Address address = reinterpret_cast<Address>(*string);
    422     Address top = isolate_->heap()->NewSpaceTop();
    423     if (IsFreshString(address, top)) {
    424       IncrementUseCount(top);
    425     }
    426   }
    427 
    428   // Estimates freshness and use frequency of the given string based
    429   // on how close it is to the new space top and the recorded usage
    430   // history.
    431   inline bool IsFreshUnusedString(Handle<String> string) {
    432     Address address = reinterpret_cast<Address>(*string);
    433     Address top = isolate_->heap()->NewSpaceTop();
    434     return IsFreshString(address, top) && IsUseCountLow(top);
    435   }
    436 
    437  private:
    438   StringTracker() : use_count_(0), last_top_(NULL), isolate_(NULL) { }
    439 
    440   static inline bool IsFreshString(Address string, Address top) {
    441     return top - kFreshnessLimit <= string && string <= top;
    442   }
    443 
    444   inline bool IsUseCountLow(Address top) {
    445     if (last_top_ != top) return true;
    446     return use_count_ < kUseLimit;
    447   }
    448 
    449   inline void IncrementUseCount(Address top) {
    450     if (last_top_ != top) {
    451       use_count_ = 0;
    452       last_top_ = top;
    453     }
    454     ++use_count_;
    455   }
    456 
    457   // Single use counter shared by all fresh strings.
    458   int use_count_;
    459 
    460   // Last new space top when the use count above was valid.
    461   Address last_top_;
    462 
    463   Isolate* isolate_;
    464 
    465   // How close to the new space top a fresh string has to be.
    466   static const int kFreshnessLimit = 1024;
    467 
    468   // The number of uses required to consider a string useful.
    469   static const int kUseLimit = 32;
    470 
    471   friend class Isolate;
    472 
    473   DISALLOW_COPY_AND_ASSIGN(StringTracker);
    474 };
    475 
    476 
    477 class DeferredHandles {
    478  public:
    479   ~DeferredHandles();
    480 
    481  private:
    482   DeferredHandles(Object** first_block_limit, Isolate* isolate)
    483       : next_(NULL),
    484         previous_(NULL),
    485         first_block_limit_(first_block_limit),
    486         isolate_(isolate) {
    487     isolate->LinkDeferredHandles(this);
    488   }
    489 
    490   void Iterate(ObjectVisitor* v);
    491 
    492   List<Object**> blocks_;
    493   DeferredHandles* next_;
    494   DeferredHandles* previous_;
    495   Object** first_block_limit_;
    496   Isolate* isolate_;
    497 
    498   friend class HandleScopeImplementer;
    499   friend class Isolate;
    500 };
    501 
    502 
    503 // This class is here in order to be able to declare it a friend of
    504 // HandleScope.  Moving these methods to be members of HandleScope would be
    505 // neat in some ways, but it would expose internal implementation details in
    506 // our public header file, which is undesirable.
    507 //
    508 // An isolate has a single instance of this class to hold the current thread's
    509 // data. In multithreaded V8 programs this data is copied in and out of storage
    510 // so that the currently executing thread always has its own copy of this
    511 // data.
    512 class HandleScopeImplementer {
    513  public:
    514   explicit HandleScopeImplementer(Isolate* isolate)
    515       : isolate_(isolate),
    516         blocks_(0),
    517         entered_contexts_(0),
    518         saved_contexts_(0),
    519         spare_(NULL),
    520         call_depth_(0),
    521         last_handle_before_deferred_block_(NULL) { }
    522 
    523   ~HandleScopeImplementer() {
    524     DeleteArray(spare_);
    525   }
    526 
    527   // Threading support for handle data.
    528   static int ArchiveSpacePerThread();
    529   char* RestoreThread(char* from);
    530   char* ArchiveThread(char* to);
    531   void FreeThreadResources();
    532 
    533   // Garbage collection support.
    534   void Iterate(v8::internal::ObjectVisitor* v);
    535   static char* Iterate(v8::internal::ObjectVisitor* v, char* data);
    536 
    537 
    538   inline internal::Object** GetSpareOrNewBlock();
    539   inline void DeleteExtensions(internal::Object** prev_limit);
    540 
    541   inline void IncrementCallDepth() {call_depth_++;}
    542   inline void DecrementCallDepth() {call_depth_--;}
    543   inline bool CallDepthIsZero() { return call_depth_ == 0; }
    544 
    545   inline void EnterContext(Handle<Object> context);
    546   inline bool LeaveLastContext();
    547 
    548   // Returns the last entered context or an empty handle if no
    549   // contexts have been entered.
    550   inline Handle<Object> LastEnteredContext();
    551 
    552   inline void SaveContext(Context* context);
    553   inline Context* RestoreContext();
    554   inline bool HasSavedContexts();
    555 
    556   inline List<internal::Object**>* blocks() { return &blocks_; }
    557   Isolate* isolate() const { return isolate_; }
    558 
    559   void ReturnBlock(Object** block) {
    560     ASSERT(block != NULL);
    561     if (spare_ != NULL) DeleteArray(spare_);
    562     spare_ = block;
    563   }
    564 
    565  private:
    566   void ResetAfterArchive() {
    567     blocks_.Initialize(0);
    568     entered_contexts_.Initialize(0);
    569     saved_contexts_.Initialize(0);
    570     spare_ = NULL;
    571     last_handle_before_deferred_block_ = NULL;
    572     call_depth_ = 0;
    573   }
    574 
    575   void Free() {
    576     ASSERT(blocks_.length() == 0);
    577     ASSERT(entered_contexts_.length() == 0);
    578     ASSERT(saved_contexts_.length() == 0);
    579     blocks_.Free();
    580     entered_contexts_.Free();
    581     saved_contexts_.Free();
    582     if (spare_ != NULL) {
    583       DeleteArray(spare_);
    584       spare_ = NULL;
    585     }
    586     ASSERT(call_depth_ == 0);
    587   }
    588 
    589   void BeginDeferredScope();
    590   DeferredHandles* Detach(Object** prev_limit);
    591 
    592   Isolate* isolate_;
    593   List<internal::Object**> blocks_;
    594   // Used as a stack to keep track of entered contexts.
    595   List<Handle<Object> > entered_contexts_;
    596   // Used as a stack to keep track of saved contexts.
    597   List<Context*> saved_contexts_;
    598   Object** spare_;
    599   int call_depth_;
    600   Object** last_handle_before_deferred_block_;
    601   // This is only used for threading support.
    602   v8::ImplementationUtilities::HandleScopeData handle_scope_data_;
    603 
    604   void IterateThis(ObjectVisitor* v);
    605   char* RestoreThreadHelper(char* from);
    606   char* ArchiveThreadHelper(char* to);
    607 
    608   friend class DeferredHandles;
    609   friend class DeferredHandleScope;
    610 
    611   DISALLOW_COPY_AND_ASSIGN(HandleScopeImplementer);
    612 };
    613 
    614 
    615 const int kHandleBlockSize = v8::internal::KB - 2;  // fit in one page
    616 
    617 
    618 void HandleScopeImplementer::SaveContext(Context* context) {
    619   saved_contexts_.Add(context);
    620 }
    621 
    622 
    623 Context* HandleScopeImplementer::RestoreContext() {
    624   return saved_contexts_.RemoveLast();
    625 }
    626 
    627 
    628 bool HandleScopeImplementer::HasSavedContexts() {
    629   return !saved_contexts_.is_empty();
    630 }
    631 
    632 
    633 void HandleScopeImplementer::EnterContext(Handle<Object> context) {
    634   entered_contexts_.Add(context);
    635 }
    636 
    637 
    638 bool HandleScopeImplementer::LeaveLastContext() {
    639   if (entered_contexts_.is_empty()) return false;
    640   entered_contexts_.RemoveLast();
    641   return true;
    642 }
    643 
    644 
    645 Handle<Object> HandleScopeImplementer::LastEnteredContext() {
    646   if (entered_contexts_.is_empty()) return Handle<Object>::null();
    647   return entered_contexts_.last();
    648 }
    649 
    650 
    651 // If there's a spare block, use it for growing the current scope.
    652 internal::Object** HandleScopeImplementer::GetSpareOrNewBlock() {
    653   internal::Object** block = (spare_ != NULL) ?
    654       spare_ :
    655       NewArray<internal::Object*>(kHandleBlockSize);
    656   spare_ = NULL;
    657   return block;
    658 }
    659 
    660 
    661 void HandleScopeImplementer::DeleteExtensions(internal::Object** prev_limit) {
    662   while (!blocks_.is_empty()) {
    663     internal::Object** block_start = blocks_.last();
    664     internal::Object** block_limit = block_start + kHandleBlockSize;
    665 #ifdef DEBUG
    666     // SealHandleScope may make the prev_limit to point inside the block.
    667     if (block_start <= prev_limit && prev_limit <= block_limit) {
    668 #ifdef ENABLE_EXTRA_CHECKS
    669       internal::HandleScope::ZapRange(prev_limit, block_limit);
    670 #endif
    671       break;
    672     }
    673 #else
    674     if (prev_limit == block_limit) break;
    675 #endif
    676 
    677     blocks_.RemoveLast();
    678 #ifdef ENABLE_EXTRA_CHECKS
    679     internal::HandleScope::ZapRange(block_start, block_limit);
    680 #endif
    681     if (spare_ != NULL) {
    682       DeleteArray(spare_);
    683     }
    684     spare_ = block_start;
    685   }
    686   ASSERT((blocks_.is_empty() && prev_limit == NULL) ||
    687          (!blocks_.is_empty() && prev_limit != NULL));
    688 }
    689 
    690 
    691 // Interceptor functions called from generated inline caches to notify
    692 // CPU profiler that external callbacks are invoked.
    693 v8::Handle<v8::Value> InvokeAccessorGetter(
    694     v8::Local<v8::String> property,
    695     const v8::AccessorInfo& info,
    696     v8::AccessorGetter getter);
    697 
    698 
    699 void InvokeAccessorGetterCallback(
    700     v8::Local<v8::String> property,
    701     const v8::PropertyCallbackInfo<v8::Value>& info,
    702     v8::AccessorGetterCallback getter);
    703 
    704 v8::Handle<v8::Value> InvokeInvocationCallback(const v8::Arguments& args,
    705                                               v8::InvocationCallback callback);
    706 void InvokeFunctionCallback(const v8::FunctionCallbackInfo<v8::Value>& info,
    707                             v8::FunctionCallback callback);
    708 
    709 class Testing {
    710  public:
    711   static v8::Testing::StressType stress_type() { return stress_type_; }
    712   static void set_stress_type(v8::Testing::StressType stress_type) {
    713     stress_type_ = stress_type;
    714   }
    715 
    716  private:
    717   static v8::Testing::StressType stress_type_;
    718 };
    719 
    720 } }  // namespace v8::internal
    721 
    722 #endif  // V8_API_H_
    723