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