libv8-st 3.11.8.2-x86-mingw32

Sign up to get free protection for your applications and to get access to all the features.
@@ -0,0 +1,104 @@
1
+ // Copyright 2010 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_V8_TEST_H_
29
+ #define V8_V8_TEST_H_
30
+
31
+ #include "v8.h"
32
+
33
+ #ifdef _WIN32
34
+ // Setup for Windows DLL export/import. See v8.h in this directory for
35
+ // information on how to build/use V8 as a DLL.
36
+ #if defined(BUILDING_V8_SHARED) && defined(USING_V8_SHARED)
37
+ #error both BUILDING_V8_SHARED and USING_V8_SHARED are set - please check the\
38
+ build configuration to ensure that at most one of these is set
39
+ #endif
40
+
41
+ #ifdef BUILDING_V8_SHARED
42
+ #define V8EXPORT __declspec(dllexport)
43
+ #elif USING_V8_SHARED
44
+ #define V8EXPORT __declspec(dllimport)
45
+ #else
46
+ #define V8EXPORT
47
+ #endif
48
+
49
+ #else // _WIN32
50
+
51
+ // Setup for Linux shared library export. See v8.h in this directory for
52
+ // information on how to build/use V8 as shared library.
53
+ #if defined(__GNUC__) && (__GNUC__ >= 4) && defined(V8_SHARED)
54
+ #define V8EXPORT __attribute__ ((visibility("default")))
55
+ #else // defined(__GNUC__) && (__GNUC__ >= 4)
56
+ #define V8EXPORT
57
+ #endif // defined(__GNUC__) && (__GNUC__ >= 4)
58
+
59
+ #endif // _WIN32
60
+
61
+
62
+ /**
63
+ * Testing support for the V8 JavaScript engine.
64
+ */
65
+ namespace v8 {
66
+
67
+ class V8EXPORT Testing {
68
+ public:
69
+ enum StressType {
70
+ kStressTypeOpt,
71
+ kStressTypeDeopt
72
+ };
73
+
74
+ /**
75
+ * Set the type of stressing to do. The default if not set is kStressTypeOpt.
76
+ */
77
+ static void SetStressRunType(StressType type);
78
+
79
+ /**
80
+ * Get the number of runs of a given test that is required to get the full
81
+ * stress coverage.
82
+ */
83
+ static int GetStressRuns();
84
+
85
+ /**
86
+ * Indicate the number of the run which is about to start. The value of run
87
+ * should be between 0 and one less than the result from GetStressRuns()
88
+ */
89
+ static void PrepareStressRun(int run);
90
+
91
+ /**
92
+ * Force deoptimization of all functions.
93
+ */
94
+ static void DeoptimizeAll();
95
+ };
96
+
97
+
98
+ } // namespace v8
99
+
100
+
101
+ #undef V8EXPORT
102
+
103
+
104
+ #endif // V8_V8_TEST_H_
@@ -0,0 +1,4483 @@
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
+ /** \mainpage V8 API Reference Guide
29
+ *
30
+ * V8 is Google's open source JavaScript engine.
31
+ *
32
+ * This set of documents provides reference material generated from the
33
+ * V8 header file, include/v8.h.
34
+ *
35
+ * For other documentation see http://code.google.com/apis/v8/
36
+ */
37
+
38
+ #ifndef V8_H_
39
+ #define V8_H_
40
+
41
+ #include "v8stdint.h"
42
+
43
+ #ifdef _WIN32
44
+
45
+ // Setup for Windows DLL export/import. When building the V8 DLL the
46
+ // BUILDING_V8_SHARED needs to be defined. When building a program which uses
47
+ // the V8 DLL USING_V8_SHARED needs to be defined. When either building the V8
48
+ // static library or building a program which uses the V8 static library neither
49
+ // BUILDING_V8_SHARED nor USING_V8_SHARED should be defined.
50
+ #if defined(BUILDING_V8_SHARED) && defined(USING_V8_SHARED)
51
+ #error both BUILDING_V8_SHARED and USING_V8_SHARED are set - please check the\
52
+ build configuration to ensure that at most one of these is set
53
+ #endif
54
+
55
+ #ifdef BUILDING_V8_SHARED
56
+ #define V8EXPORT __declspec(dllexport)
57
+ #elif USING_V8_SHARED
58
+ #define V8EXPORT __declspec(dllimport)
59
+ #else
60
+ #define V8EXPORT
61
+ #endif // BUILDING_V8_SHARED
62
+
63
+ #else // _WIN32
64
+
65
+ // Setup for Linux shared library export.
66
+ #if defined(__GNUC__) && (__GNUC__ >= 4) && defined(V8_SHARED)
67
+ #ifdef BUILDING_V8_SHARED
68
+ #define V8EXPORT __attribute__ ((visibility("default")))
69
+ #else
70
+ #define V8EXPORT
71
+ #endif
72
+ #else // defined(__GNUC__) && (__GNUC__ >= 4)
73
+ #define V8EXPORT
74
+ #endif // defined(__GNUC__) && (__GNUC__ >= 4)
75
+
76
+ #endif // _WIN32
77
+
78
+ /**
79
+ * The v8 JavaScript engine.
80
+ */
81
+ namespace v8 {
82
+
83
+ class Context;
84
+ class String;
85
+ class StringObject;
86
+ class Value;
87
+ class Utils;
88
+ class Number;
89
+ class NumberObject;
90
+ class Object;
91
+ class Array;
92
+ class Int32;
93
+ class Uint32;
94
+ class External;
95
+ class Primitive;
96
+ class Boolean;
97
+ class BooleanObject;
98
+ class Integer;
99
+ class Function;
100
+ class Date;
101
+ class ImplementationUtilities;
102
+ class Signature;
103
+ template <class T> class Handle;
104
+ template <class T> class Local;
105
+ template <class T> class Persistent;
106
+ class FunctionTemplate;
107
+ class ObjectTemplate;
108
+ class Data;
109
+ class AccessorInfo;
110
+ class StackTrace;
111
+ class StackFrame;
112
+ class Isolate;
113
+
114
+ namespace internal {
115
+
116
+ class Arguments;
117
+ class Object;
118
+ class Heap;
119
+ class HeapObject;
120
+ class Isolate;
121
+ }
122
+
123
+
124
+ // --- Weak Handles ---
125
+
126
+
127
+ /**
128
+ * A weak reference callback function.
129
+ *
130
+ * This callback should either explicitly invoke Dispose on |object| if
131
+ * V8 wrapper is not needed anymore, or 'revive' it by invocation of MakeWeak.
132
+ *
133
+ * \param object the weak global object to be reclaimed by the garbage collector
134
+ * \param parameter the value passed in when making the weak global object
135
+ */
136
+ typedef void (*WeakReferenceCallback)(Persistent<Value> object,
137
+ void* parameter);
138
+
139
+
140
+ // --- Handles ---
141
+
142
+ #define TYPE_CHECK(T, S) \
143
+ while (false) { \
144
+ *(static_cast<T* volatile*>(0)) = static_cast<S*>(0); \
145
+ }
146
+
147
+ /**
148
+ * An object reference managed by the v8 garbage collector.
149
+ *
150
+ * All objects returned from v8 have to be tracked by the garbage
151
+ * collector so that it knows that the objects are still alive. Also,
152
+ * because the garbage collector may move objects, it is unsafe to
153
+ * point directly to an object. Instead, all objects are stored in
154
+ * handles which are known by the garbage collector and updated
155
+ * whenever an object moves. Handles should always be passed by value
156
+ * (except in cases like out-parameters) and they should never be
157
+ * allocated on the heap.
158
+ *
159
+ * There are two types of handles: local and persistent handles.
160
+ * Local handles are light-weight and transient and typically used in
161
+ * local operations. They are managed by HandleScopes. Persistent
162
+ * handles can be used when storing objects across several independent
163
+ * operations and have to be explicitly deallocated when they're no
164
+ * longer used.
165
+ *
166
+ * It is safe to extract the object stored in the handle by
167
+ * dereferencing the handle (for instance, to extract the Object* from
168
+ * a Handle<Object>); the value will still be governed by a handle
169
+ * behind the scenes and the same rules apply to these values as to
170
+ * their handles.
171
+ */
172
+ template <class T> class Handle {
173
+ public:
174
+ /**
175
+ * Creates an empty handle.
176
+ */
177
+ inline Handle() : val_(0) {}
178
+
179
+ /**
180
+ * Creates a new handle for the specified value.
181
+ */
182
+ inline explicit Handle(T* val) : val_(val) {}
183
+
184
+ /**
185
+ * Creates a handle for the contents of the specified handle. This
186
+ * constructor allows you to pass handles as arguments by value and
187
+ * to assign between handles. However, if you try to assign between
188
+ * incompatible handles, for instance from a Handle<String> to a
189
+ * Handle<Number> it will cause a compile-time error. Assigning
190
+ * between compatible handles, for instance assigning a
191
+ * Handle<String> to a variable declared as Handle<Value>, is legal
192
+ * because String is a subclass of Value.
193
+ */
194
+ template <class S> inline Handle(Handle<S> that)
195
+ : val_(reinterpret_cast<T*>(*that)) {
196
+ /**
197
+ * This check fails when trying to convert between incompatible
198
+ * handles. For example, converting from a Handle<String> to a
199
+ * Handle<Number>.
200
+ */
201
+ TYPE_CHECK(T, S);
202
+ }
203
+
204
+ /**
205
+ * Returns true if the handle is empty.
206
+ */
207
+ inline bool IsEmpty() const { return val_ == 0; }
208
+
209
+ /**
210
+ * Sets the handle to be empty. IsEmpty() will then return true.
211
+ */
212
+ inline void Clear() { val_ = 0; }
213
+
214
+ inline T* operator->() const { return val_; }
215
+
216
+ inline T* operator*() const { return val_; }
217
+
218
+ /**
219
+ * Checks whether two handles are the same.
220
+ * Returns true if both are empty, or if the objects
221
+ * to which they refer are identical.
222
+ * The handles' references are not checked.
223
+ */
224
+ template <class S> inline bool operator==(Handle<S> that) const {
225
+ internal::Object** a = reinterpret_cast<internal::Object**>(**this);
226
+ internal::Object** b = reinterpret_cast<internal::Object**>(*that);
227
+ if (a == 0) return b == 0;
228
+ if (b == 0) return false;
229
+ return *a == *b;
230
+ }
231
+
232
+ /**
233
+ * Checks whether two handles are different.
234
+ * Returns true if only one of the handles is empty, or if
235
+ * the objects to which they refer are different.
236
+ * The handles' references are not checked.
237
+ */
238
+ template <class S> inline bool operator!=(Handle<S> that) const {
239
+ return !operator==(that);
240
+ }
241
+
242
+ template <class S> static inline Handle<T> Cast(Handle<S> that) {
243
+ #ifdef V8_ENABLE_CHECKS
244
+ // If we're going to perform the type check then we have to check
245
+ // that the handle isn't empty before doing the checked cast.
246
+ if (that.IsEmpty()) return Handle<T>();
247
+ #endif
248
+ return Handle<T>(T::Cast(*that));
249
+ }
250
+
251
+ template <class S> inline Handle<S> As() {
252
+ return Handle<S>::Cast(*this);
253
+ }
254
+
255
+ private:
256
+ T* val_;
257
+ };
258
+
259
+
260
+ /**
261
+ * A light-weight stack-allocated object handle. All operations
262
+ * that return objects from within v8 return them in local handles. They
263
+ * are created within HandleScopes, and all local handles allocated within a
264
+ * handle scope are destroyed when the handle scope is destroyed. Hence it
265
+ * is not necessary to explicitly deallocate local handles.
266
+ */
267
+ template <class T> class Local : public Handle<T> {
268
+ public:
269
+ inline Local();
270
+ template <class S> inline Local(Local<S> that)
271
+ : Handle<T>(reinterpret_cast<T*>(*that)) {
272
+ /**
273
+ * This check fails when trying to convert between incompatible
274
+ * handles. For example, converting from a Handle<String> to a
275
+ * Handle<Number>.
276
+ */
277
+ TYPE_CHECK(T, S);
278
+ }
279
+ template <class S> inline Local(S* that) : Handle<T>(that) { }
280
+ template <class S> static inline Local<T> Cast(Local<S> that) {
281
+ #ifdef V8_ENABLE_CHECKS
282
+ // If we're going to perform the type check then we have to check
283
+ // that the handle isn't empty before doing the checked cast.
284
+ if (that.IsEmpty()) return Local<T>();
285
+ #endif
286
+ return Local<T>(T::Cast(*that));
287
+ }
288
+
289
+ template <class S> inline Local<S> As() {
290
+ return Local<S>::Cast(*this);
291
+ }
292
+
293
+ /** Create a local handle for the content of another handle.
294
+ * The referee is kept alive by the local handle even when
295
+ * the original handle is destroyed/disposed.
296
+ */
297
+ inline static Local<T> New(Handle<T> that);
298
+ };
299
+
300
+
301
+ /**
302
+ * An object reference that is independent of any handle scope. Where
303
+ * a Local handle only lives as long as the HandleScope in which it was
304
+ * allocated, a Persistent handle remains valid until it is explicitly
305
+ * disposed.
306
+ *
307
+ * A persistent handle contains a reference to a storage cell within
308
+ * the v8 engine which holds an object value and which is updated by
309
+ * the garbage collector whenever the object is moved. A new storage
310
+ * cell can be created using Persistent::New and existing handles can
311
+ * be disposed using Persistent::Dispose. Since persistent handles
312
+ * are passed by value you may have many persistent handle objects
313
+ * that point to the same storage cell. For instance, if you pass a
314
+ * persistent handle as an argument to a function you will not get two
315
+ * different storage cells but rather two references to the same
316
+ * storage cell.
317
+ */
318
+ template <class T> class Persistent : public Handle<T> {
319
+ public:
320
+ /**
321
+ * Creates an empty persistent handle that doesn't point to any
322
+ * storage cell.
323
+ */
324
+ inline Persistent();
325
+
326
+ /**
327
+ * Creates a persistent handle for the same storage cell as the
328
+ * specified handle. This constructor allows you to pass persistent
329
+ * handles as arguments by value and to assign between persistent
330
+ * handles. However, attempting to assign between incompatible
331
+ * persistent handles, for instance from a Persistent<String> to a
332
+ * Persistent<Number> will cause a compile-time error. Assigning
333
+ * between compatible persistent handles, for instance assigning a
334
+ * Persistent<String> to a variable declared as Persistent<Value>,
335
+ * is allowed as String is a subclass of Value.
336
+ */
337
+ template <class S> inline Persistent(Persistent<S> that)
338
+ : Handle<T>(reinterpret_cast<T*>(*that)) {
339
+ /**
340
+ * This check fails when trying to convert between incompatible
341
+ * handles. For example, converting from a Handle<String> to a
342
+ * Handle<Number>.
343
+ */
344
+ TYPE_CHECK(T, S);
345
+ }
346
+
347
+ template <class S> inline Persistent(S* that) : Handle<T>(that) { }
348
+
349
+ /**
350
+ * "Casts" a plain handle which is known to be a persistent handle
351
+ * to a persistent handle.
352
+ */
353
+ template <class S> explicit inline Persistent(Handle<S> that)
354
+ : Handle<T>(*that) { }
355
+
356
+ template <class S> static inline Persistent<T> Cast(Persistent<S> that) {
357
+ #ifdef V8_ENABLE_CHECKS
358
+ // If we're going to perform the type check then we have to check
359
+ // that the handle isn't empty before doing the checked cast.
360
+ if (that.IsEmpty()) return Persistent<T>();
361
+ #endif
362
+ return Persistent<T>(T::Cast(*that));
363
+ }
364
+
365
+ template <class S> inline Persistent<S> As() {
366
+ return Persistent<S>::Cast(*this);
367
+ }
368
+
369
+ /**
370
+ * Creates a new persistent handle for an existing local or
371
+ * persistent handle.
372
+ */
373
+ inline static Persistent<T> New(Handle<T> that);
374
+
375
+ /**
376
+ * Releases the storage cell referenced by this persistent handle.
377
+ * Does not remove the reference to the cell from any handles.
378
+ * This handle's reference, and any other references to the storage
379
+ * cell remain and IsEmpty will still return false.
380
+ */
381
+ inline void Dispose();
382
+
383
+ /**
384
+ * Make the reference to this object weak. When only weak handles
385
+ * refer to the object, the garbage collector will perform a
386
+ * callback to the given V8::WeakReferenceCallback function, passing
387
+ * it the object reference and the given parameters.
388
+ */
389
+ inline void MakeWeak(void* parameters, WeakReferenceCallback callback);
390
+
391
+ /** Clears the weak reference to this object.*/
392
+ inline void ClearWeak();
393
+
394
+ /**
395
+ * Marks the reference to this object independent. Garbage collector
396
+ * is free to ignore any object groups containing this object.
397
+ * Weak callback for an independent handle should not
398
+ * assume that it will be preceded by a global GC prologue callback
399
+ * or followed by a global GC epilogue callback.
400
+ */
401
+ inline void MarkIndependent();
402
+
403
+ /**
404
+ *Checks if the handle holds the only reference to an object.
405
+ */
406
+ inline bool IsNearDeath() const;
407
+
408
+ /**
409
+ * Returns true if the handle's reference is weak.
410
+ */
411
+ inline bool IsWeak() const;
412
+
413
+ /**
414
+ * Assigns a wrapper class ID to the handle. See RetainedObjectInfo
415
+ * interface description in v8-profiler.h for details.
416
+ */
417
+ inline void SetWrapperClassId(uint16_t class_id);
418
+
419
+ private:
420
+ friend class ImplementationUtilities;
421
+ friend class ObjectTemplate;
422
+ };
423
+
424
+
425
+ /**
426
+ * A stack-allocated class that governs a number of local handles.
427
+ * After a handle scope has been created, all local handles will be
428
+ * allocated within that handle scope until either the handle scope is
429
+ * deleted or another handle scope is created. If there is already a
430
+ * handle scope and a new one is created, all allocations will take
431
+ * place in the new handle scope until it is deleted. After that,
432
+ * new handles will again be allocated in the original handle scope.
433
+ *
434
+ * After the handle scope of a local handle has been deleted the
435
+ * garbage collector will no longer track the object stored in the
436
+ * handle and may deallocate it. The behavior of accessing a handle
437
+ * for which the handle scope has been deleted is undefined.
438
+ */
439
+ class V8EXPORT HandleScope {
440
+ public:
441
+ HandleScope();
442
+
443
+ ~HandleScope();
444
+
445
+ /**
446
+ * Closes the handle scope and returns the value as a handle in the
447
+ * previous scope, which is the new current scope after the call.
448
+ */
449
+ template <class T> Local<T> Close(Handle<T> value);
450
+
451
+ /**
452
+ * Counts the number of allocated handles.
453
+ */
454
+ static int NumberOfHandles();
455
+
456
+ /**
457
+ * Creates a new handle with the given value.
458
+ */
459
+ static internal::Object** CreateHandle(internal::Object* value);
460
+ // Faster version, uses HeapObject to obtain the current Isolate.
461
+ static internal::Object** CreateHandle(internal::HeapObject* value);
462
+
463
+ private:
464
+ // Make it impossible to create heap-allocated or illegal handle
465
+ // scopes by disallowing certain operations.
466
+ HandleScope(const HandleScope&);
467
+ void operator=(const HandleScope&);
468
+ void* operator new(size_t size);
469
+ void operator delete(void*, size_t);
470
+
471
+ // This Data class is accessible internally as HandleScopeData through a
472
+ // typedef in the ImplementationUtilities class.
473
+ class V8EXPORT Data {
474
+ public:
475
+ internal::Object** next;
476
+ internal::Object** limit;
477
+ int level;
478
+ inline void Initialize() {
479
+ next = limit = NULL;
480
+ level = 0;
481
+ }
482
+ };
483
+
484
+ void Leave();
485
+
486
+ internal::Isolate* isolate_;
487
+ internal::Object** prev_next_;
488
+ internal::Object** prev_limit_;
489
+
490
+ // Allow for the active closing of HandleScopes which allows to pass a handle
491
+ // from the HandleScope being closed to the next top most HandleScope.
492
+ bool is_closed_;
493
+ internal::Object** RawClose(internal::Object** value);
494
+
495
+ friend class ImplementationUtilities;
496
+ };
497
+
498
+
499
+ // --- Special objects ---
500
+
501
+
502
+ /**
503
+ * The superclass of values and API object templates.
504
+ */
505
+ class V8EXPORT Data {
506
+ private:
507
+ Data();
508
+ };
509
+
510
+
511
+ /**
512
+ * Pre-compilation data that can be associated with a script. This
513
+ * data can be calculated for a script in advance of actually
514
+ * compiling it, and can be stored between compilations. When script
515
+ * data is given to the compile method compilation will be faster.
516
+ */
517
+ class V8EXPORT ScriptData { // NOLINT
518
+ public:
519
+ virtual ~ScriptData() { }
520
+
521
+ /**
522
+ * Pre-compiles the specified script (context-independent).
523
+ *
524
+ * \param input Pointer to UTF-8 script source code.
525
+ * \param length Length of UTF-8 script source code.
526
+ */
527
+ static ScriptData* PreCompile(const char* input, int length);
528
+
529
+ /**
530
+ * Pre-compiles the specified script (context-independent).
531
+ *
532
+ * NOTE: Pre-compilation using this method cannot happen on another thread
533
+ * without using Lockers.
534
+ *
535
+ * \param source Script source code.
536
+ */
537
+ static ScriptData* PreCompile(Handle<String> source);
538
+
539
+ /**
540
+ * Load previous pre-compilation data.
541
+ *
542
+ * \param data Pointer to data returned by a call to Data() of a previous
543
+ * ScriptData. Ownership is not transferred.
544
+ * \param length Length of data.
545
+ */
546
+ static ScriptData* New(const char* data, int length);
547
+
548
+ /**
549
+ * Returns the length of Data().
550
+ */
551
+ virtual int Length() = 0;
552
+
553
+ /**
554
+ * Returns a serialized representation of this ScriptData that can later be
555
+ * passed to New(). NOTE: Serialized data is platform-dependent.
556
+ */
557
+ virtual const char* Data() = 0;
558
+
559
+ /**
560
+ * Returns true if the source code could not be parsed.
561
+ */
562
+ virtual bool HasError() = 0;
563
+ };
564
+
565
+
566
+ /**
567
+ * The origin, within a file, of a script.
568
+ */
569
+ class ScriptOrigin {
570
+ public:
571
+ inline ScriptOrigin(
572
+ Handle<Value> resource_name,
573
+ Handle<Integer> resource_line_offset = Handle<Integer>(),
574
+ Handle<Integer> resource_column_offset = Handle<Integer>())
575
+ : resource_name_(resource_name),
576
+ resource_line_offset_(resource_line_offset),
577
+ resource_column_offset_(resource_column_offset) { }
578
+ inline Handle<Value> ResourceName() const;
579
+ inline Handle<Integer> ResourceLineOffset() const;
580
+ inline Handle<Integer> ResourceColumnOffset() const;
581
+ private:
582
+ Handle<Value> resource_name_;
583
+ Handle<Integer> resource_line_offset_;
584
+ Handle<Integer> resource_column_offset_;
585
+ };
586
+
587
+
588
+ /**
589
+ * A compiled JavaScript script.
590
+ */
591
+ class V8EXPORT Script {
592
+ public:
593
+ /**
594
+ * Compiles the specified script (context-independent).
595
+ *
596
+ * \param source Script source code.
597
+ * \param origin Script origin, owned by caller, no references are kept
598
+ * when New() returns
599
+ * \param pre_data Pre-parsing data, as obtained by ScriptData::PreCompile()
600
+ * using pre_data speeds compilation if it's done multiple times.
601
+ * Owned by caller, no references are kept when New() returns.
602
+ * \param script_data Arbitrary data associated with script. Using
603
+ * this has same effect as calling SetData(), but allows data to be
604
+ * available to compile event handlers.
605
+ * \return Compiled script object (context independent; when run it
606
+ * will use the currently entered context).
607
+ */
608
+ static Local<Script> New(Handle<String> source,
609
+ ScriptOrigin* origin = NULL,
610
+ ScriptData* pre_data = NULL,
611
+ Handle<String> script_data = Handle<String>());
612
+
613
+ /**
614
+ * Compiles the specified script using the specified file name
615
+ * object (typically a string) as the script's origin.
616
+ *
617
+ * \param source Script source code.
618
+ * \param file_name file name object (typically a string) to be used
619
+ * as the script's origin.
620
+ * \return Compiled script object (context independent; when run it
621
+ * will use the currently entered context).
622
+ */
623
+ static Local<Script> New(Handle<String> source,
624
+ Handle<Value> file_name);
625
+
626
+ /**
627
+ * Compiles the specified script (bound to current context).
628
+ *
629
+ * \param source Script source code.
630
+ * \param origin Script origin, owned by caller, no references are kept
631
+ * when Compile() returns
632
+ * \param pre_data Pre-parsing data, as obtained by ScriptData::PreCompile()
633
+ * using pre_data speeds compilation if it's done multiple times.
634
+ * Owned by caller, no references are kept when Compile() returns.
635
+ * \param script_data Arbitrary data associated with script. Using
636
+ * this has same effect as calling SetData(), but makes data available
637
+ * earlier (i.e. to compile event handlers).
638
+ * \return Compiled script object, bound to the context that was active
639
+ * when this function was called. When run it will always use this
640
+ * context.
641
+ */
642
+ static Local<Script> Compile(Handle<String> source,
643
+ ScriptOrigin* origin = NULL,
644
+ ScriptData* pre_data = NULL,
645
+ Handle<String> script_data = Handle<String>());
646
+
647
+ /**
648
+ * Compiles the specified script using the specified file name
649
+ * object (typically a string) as the script's origin.
650
+ *
651
+ * \param source Script source code.
652
+ * \param file_name File name to use as script's origin
653
+ * \param script_data Arbitrary data associated with script. Using
654
+ * this has same effect as calling SetData(), but makes data available
655
+ * earlier (i.e. to compile event handlers).
656
+ * \return Compiled script object, bound to the context that was active
657
+ * when this function was called. When run it will always use this
658
+ * context.
659
+ */
660
+ static Local<Script> Compile(Handle<String> source,
661
+ Handle<Value> file_name,
662
+ Handle<String> script_data = Handle<String>());
663
+
664
+ /**
665
+ * Runs the script returning the resulting value. If the script is
666
+ * context independent (created using ::New) it will be run in the
667
+ * currently entered context. If it is context specific (created
668
+ * using ::Compile) it will be run in the context in which it was
669
+ * compiled.
670
+ */
671
+ Local<Value> Run();
672
+
673
+ /**
674
+ * Returns the script id value.
675
+ */
676
+ Local<Value> Id();
677
+
678
+ /**
679
+ * Associate an additional data object with the script. This is mainly used
680
+ * with the debugger as this data object is only available through the
681
+ * debugger API.
682
+ */
683
+ void SetData(Handle<String> data);
684
+ };
685
+
686
+
687
+ /**
688
+ * An error message.
689
+ */
690
+ class V8EXPORT Message {
691
+ public:
692
+ Local<String> Get() const;
693
+ Local<String> GetSourceLine() const;
694
+
695
+ /**
696
+ * Returns the resource name for the script from where the function causing
697
+ * the error originates.
698
+ */
699
+ Handle<Value> GetScriptResourceName() const;
700
+
701
+ /**
702
+ * Returns the resource data for the script from where the function causing
703
+ * the error originates.
704
+ */
705
+ Handle<Value> GetScriptData() const;
706
+
707
+ /**
708
+ * Exception stack trace. By default stack traces are not captured for
709
+ * uncaught exceptions. SetCaptureStackTraceForUncaughtExceptions allows
710
+ * to change this option.
711
+ */
712
+ Handle<StackTrace> GetStackTrace() const;
713
+
714
+ /**
715
+ * Returns the number, 1-based, of the line where the error occurred.
716
+ */
717
+ int GetLineNumber() const;
718
+
719
+ /**
720
+ * Returns the index within the script of the first character where
721
+ * the error occurred.
722
+ */
723
+ int GetStartPosition() const;
724
+
725
+ /**
726
+ * Returns the index within the script of the last character where
727
+ * the error occurred.
728
+ */
729
+ int GetEndPosition() const;
730
+
731
+ /**
732
+ * Returns the index within the line of the first character where
733
+ * the error occurred.
734
+ */
735
+ int GetStartColumn() const;
736
+
737
+ /**
738
+ * Returns the index within the line of the last character where
739
+ * the error occurred.
740
+ */
741
+ int GetEndColumn() const;
742
+
743
+ // TODO(1245381): Print to a string instead of on a FILE.
744
+ static void PrintCurrentStackTrace(FILE* out);
745
+
746
+ static const int kNoLineNumberInfo = 0;
747
+ static const int kNoColumnInfo = 0;
748
+ };
749
+
750
+
751
+ /**
752
+ * Representation of a JavaScript stack trace. The information collected is a
753
+ * snapshot of the execution stack and the information remains valid after
754
+ * execution continues.
755
+ */
756
+ class V8EXPORT StackTrace {
757
+ public:
758
+ /**
759
+ * Flags that determine what information is placed captured for each
760
+ * StackFrame when grabbing the current stack trace.
761
+ */
762
+ enum StackTraceOptions {
763
+ kLineNumber = 1,
764
+ kColumnOffset = 1 << 1 | kLineNumber,
765
+ kScriptName = 1 << 2,
766
+ kFunctionName = 1 << 3,
767
+ kIsEval = 1 << 4,
768
+ kIsConstructor = 1 << 5,
769
+ kScriptNameOrSourceURL = 1 << 6,
770
+ kOverview = kLineNumber | kColumnOffset | kScriptName | kFunctionName,
771
+ kDetailed = kOverview | kIsEval | kIsConstructor | kScriptNameOrSourceURL
772
+ };
773
+
774
+ /**
775
+ * Returns a StackFrame at a particular index.
776
+ */
777
+ Local<StackFrame> GetFrame(uint32_t index) const;
778
+
779
+ /**
780
+ * Returns the number of StackFrames.
781
+ */
782
+ int GetFrameCount() const;
783
+
784
+ /**
785
+ * Returns StackTrace as a v8::Array that contains StackFrame objects.
786
+ */
787
+ Local<Array> AsArray();
788
+
789
+ /**
790
+ * Grab a snapshot of the current JavaScript execution stack.
791
+ *
792
+ * \param frame_limit The maximum number of stack frames we want to capture.
793
+ * \param options Enumerates the set of things we will capture for each
794
+ * StackFrame.
795
+ */
796
+ static Local<StackTrace> CurrentStackTrace(
797
+ int frame_limit,
798
+ StackTraceOptions options = kOverview);
799
+ };
800
+
801
+
802
+ /**
803
+ * A single JavaScript stack frame.
804
+ */
805
+ class V8EXPORT StackFrame {
806
+ public:
807
+ /**
808
+ * Returns the number, 1-based, of the line for the associate function call.
809
+ * This method will return Message::kNoLineNumberInfo if it is unable to
810
+ * retrieve the line number, or if kLineNumber was not passed as an option
811
+ * when capturing the StackTrace.
812
+ */
813
+ int GetLineNumber() const;
814
+
815
+ /**
816
+ * Returns the 1-based column offset on the line for the associated function
817
+ * call.
818
+ * This method will return Message::kNoColumnInfo if it is unable to retrieve
819
+ * the column number, or if kColumnOffset was not passed as an option when
820
+ * capturing the StackTrace.
821
+ */
822
+ int GetColumn() const;
823
+
824
+ /**
825
+ * Returns the name of the resource that contains the script for the
826
+ * function for this StackFrame.
827
+ */
828
+ Local<String> GetScriptName() const;
829
+
830
+ /**
831
+ * Returns the name of the resource that contains the script for the
832
+ * function for this StackFrame or sourceURL value if the script name
833
+ * is undefined and its source ends with //@ sourceURL=... string.
834
+ */
835
+ Local<String> GetScriptNameOrSourceURL() const;
836
+
837
+ /**
838
+ * Returns the name of the function associated with this stack frame.
839
+ */
840
+ Local<String> GetFunctionName() const;
841
+
842
+ /**
843
+ * Returns whether or not the associated function is compiled via a call to
844
+ * eval().
845
+ */
846
+ bool IsEval() const;
847
+
848
+ /**
849
+ * Returns whether or not the associated function is called as a
850
+ * constructor via "new".
851
+ */
852
+ bool IsConstructor() const;
853
+ };
854
+
855
+
856
+ // --- Value ---
857
+
858
+
859
+ /**
860
+ * The superclass of all JavaScript values and objects.
861
+ */
862
+ class Value : public Data {
863
+ public:
864
+ /**
865
+ * Returns true if this value is the undefined value. See ECMA-262
866
+ * 4.3.10.
867
+ */
868
+ inline bool IsUndefined() const;
869
+
870
+ /**
871
+ * Returns true if this value is the null value. See ECMA-262
872
+ * 4.3.11.
873
+ */
874
+ inline bool IsNull() const;
875
+
876
+ /**
877
+ * Returns true if this value is true.
878
+ */
879
+ V8EXPORT bool IsTrue() const;
880
+
881
+ /**
882
+ * Returns true if this value is false.
883
+ */
884
+ V8EXPORT bool IsFalse() const;
885
+
886
+ /**
887
+ * Returns true if this value is an instance of the String type.
888
+ * See ECMA-262 8.4.
889
+ */
890
+ inline bool IsString() const;
891
+
892
+ /**
893
+ * Returns true if this value is a function.
894
+ */
895
+ V8EXPORT bool IsFunction() const;
896
+
897
+ /**
898
+ * Returns true if this value is an array.
899
+ */
900
+ V8EXPORT bool IsArray() const;
901
+
902
+ /**
903
+ * Returns true if this value is an object.
904
+ */
905
+ V8EXPORT bool IsObject() const;
906
+
907
+ /**
908
+ * Returns true if this value is boolean.
909
+ */
910
+ V8EXPORT bool IsBoolean() const;
911
+
912
+ /**
913
+ * Returns true if this value is a number.
914
+ */
915
+ V8EXPORT bool IsNumber() const;
916
+
917
+ /**
918
+ * Returns true if this value is external.
919
+ */
920
+ V8EXPORT bool IsExternal() const;
921
+
922
+ /**
923
+ * Returns true if this value is a 32-bit signed integer.
924
+ */
925
+ V8EXPORT bool IsInt32() const;
926
+
927
+ /**
928
+ * Returns true if this value is a 32-bit unsigned integer.
929
+ */
930
+ V8EXPORT bool IsUint32() const;
931
+
932
+ /**
933
+ * Returns true if this value is a Date.
934
+ */
935
+ V8EXPORT bool IsDate() const;
936
+
937
+ /**
938
+ * Returns true if this value is a Boolean object.
939
+ */
940
+ V8EXPORT bool IsBooleanObject() const;
941
+
942
+ /**
943
+ * Returns true if this value is a Number object.
944
+ */
945
+ V8EXPORT bool IsNumberObject() const;
946
+
947
+ /**
948
+ * Returns true if this value is a String object.
949
+ */
950
+ V8EXPORT bool IsStringObject() const;
951
+
952
+ /**
953
+ * Returns true if this value is a NativeError.
954
+ */
955
+ V8EXPORT bool IsNativeError() const;
956
+
957
+ /**
958
+ * Returns true if this value is a RegExp.
959
+ */
960
+ V8EXPORT bool IsRegExp() const;
961
+
962
+ V8EXPORT Local<Boolean> ToBoolean() const;
963
+ V8EXPORT Local<Number> ToNumber() const;
964
+ V8EXPORT Local<String> ToString() const;
965
+ V8EXPORT Local<String> ToDetailString() const;
966
+ V8EXPORT Local<Object> ToObject() const;
967
+ V8EXPORT Local<Integer> ToInteger() const;
968
+ V8EXPORT Local<Uint32> ToUint32() const;
969
+ V8EXPORT Local<Int32> ToInt32() const;
970
+
971
+ /**
972
+ * Attempts to convert a string to an array index.
973
+ * Returns an empty handle if the conversion fails.
974
+ */
975
+ V8EXPORT Local<Uint32> ToArrayIndex() const;
976
+
977
+ V8EXPORT bool BooleanValue() const;
978
+ V8EXPORT double NumberValue() const;
979
+ V8EXPORT int64_t IntegerValue() const;
980
+ V8EXPORT uint32_t Uint32Value() const;
981
+ V8EXPORT int32_t Int32Value() const;
982
+
983
+ /** JS == */
984
+ V8EXPORT bool Equals(Handle<Value> that) const;
985
+ V8EXPORT bool StrictEquals(Handle<Value> that) const;
986
+
987
+ private:
988
+ inline bool QuickIsUndefined() const;
989
+ inline bool QuickIsNull() const;
990
+ inline bool QuickIsString() const;
991
+ V8EXPORT bool FullIsUndefined() const;
992
+ V8EXPORT bool FullIsNull() const;
993
+ V8EXPORT bool FullIsString() const;
994
+ };
995
+
996
+
997
+ /**
998
+ * The superclass of primitive values. See ECMA-262 4.3.2.
999
+ */
1000
+ class Primitive : public Value { };
1001
+
1002
+
1003
+ /**
1004
+ * A primitive boolean value (ECMA-262, 4.3.14). Either the true
1005
+ * or false value.
1006
+ */
1007
+ class Boolean : public Primitive {
1008
+ public:
1009
+ V8EXPORT bool Value() const;
1010
+ static inline Handle<Boolean> New(bool value);
1011
+ };
1012
+
1013
+
1014
+ /**
1015
+ * A JavaScript string value (ECMA-262, 4.3.17).
1016
+ */
1017
+ class String : public Primitive {
1018
+ public:
1019
+ /**
1020
+ * Returns the number of characters in this string.
1021
+ */
1022
+ V8EXPORT int Length() const;
1023
+
1024
+ /**
1025
+ * Returns the number of bytes in the UTF-8 encoded
1026
+ * representation of this string.
1027
+ */
1028
+ V8EXPORT int Utf8Length() const;
1029
+
1030
+ /**
1031
+ * A fast conservative check for non-ASCII characters. May
1032
+ * return true even for ASCII strings, but if it returns
1033
+ * false you can be sure that all characters are in the range
1034
+ * 0-127.
1035
+ */
1036
+ V8EXPORT bool MayContainNonAscii() const;
1037
+
1038
+ /**
1039
+ * Write the contents of the string to an external buffer.
1040
+ * If no arguments are given, expects the buffer to be large
1041
+ * enough to hold the entire string and NULL terminator. Copies
1042
+ * the contents of the string and the NULL terminator into the
1043
+ * buffer.
1044
+ *
1045
+ * WriteUtf8 will not write partial UTF-8 sequences, preferring to stop
1046
+ * before the end of the buffer.
1047
+ *
1048
+ * Copies up to length characters into the output buffer.
1049
+ * Only null-terminates if there is enough space in the buffer.
1050
+ *
1051
+ * \param buffer The buffer into which the string will be copied.
1052
+ * \param start The starting position within the string at which
1053
+ * copying begins.
1054
+ * \param length The number of characters to copy from the string. For
1055
+ * WriteUtf8 the number of bytes in the buffer.
1056
+ * \param nchars_ref The number of characters written, can be NULL.
1057
+ * \param options Various options that might affect performance of this or
1058
+ * subsequent operations.
1059
+ * \return The number of characters copied to the buffer excluding the null
1060
+ * terminator. For WriteUtf8: The number of bytes copied to the buffer
1061
+ * including the null terminator (if written).
1062
+ */
1063
+ enum WriteOptions {
1064
+ NO_OPTIONS = 0,
1065
+ HINT_MANY_WRITES_EXPECTED = 1,
1066
+ NO_NULL_TERMINATION = 2
1067
+ };
1068
+
1069
+ // 16-bit character codes.
1070
+ V8EXPORT int Write(uint16_t* buffer,
1071
+ int start = 0,
1072
+ int length = -1,
1073
+ int options = NO_OPTIONS) const;
1074
+ // ASCII characters.
1075
+ V8EXPORT int WriteAscii(char* buffer,
1076
+ int start = 0,
1077
+ int length = -1,
1078
+ int options = NO_OPTIONS) const;
1079
+ // UTF-8 encoded characters.
1080
+ V8EXPORT int WriteUtf8(char* buffer,
1081
+ int length = -1,
1082
+ int* nchars_ref = NULL,
1083
+ int options = NO_OPTIONS) const;
1084
+
1085
+ /**
1086
+ * A zero length string.
1087
+ */
1088
+ V8EXPORT static v8::Local<v8::String> Empty();
1089
+ inline static v8::Local<v8::String> Empty(Isolate* isolate);
1090
+
1091
+ /**
1092
+ * Returns true if the string is external
1093
+ */
1094
+ V8EXPORT bool IsExternal() const;
1095
+
1096
+ /**
1097
+ * Returns true if the string is both external and ASCII
1098
+ */
1099
+ V8EXPORT bool IsExternalAscii() const;
1100
+
1101
+ class V8EXPORT ExternalStringResourceBase { // NOLINT
1102
+ public:
1103
+ virtual ~ExternalStringResourceBase() {}
1104
+
1105
+ protected:
1106
+ ExternalStringResourceBase() {}
1107
+
1108
+ /**
1109
+ * Internally V8 will call this Dispose method when the external string
1110
+ * resource is no longer needed. The default implementation will use the
1111
+ * delete operator. This method can be overridden in subclasses to
1112
+ * control how allocated external string resources are disposed.
1113
+ */
1114
+ virtual void Dispose() { delete this; }
1115
+
1116
+ private:
1117
+ // Disallow copying and assigning.
1118
+ ExternalStringResourceBase(const ExternalStringResourceBase&);
1119
+ void operator=(const ExternalStringResourceBase&);
1120
+
1121
+ friend class v8::internal::Heap;
1122
+ };
1123
+
1124
+ /**
1125
+ * An ExternalStringResource is a wrapper around a two-byte string
1126
+ * buffer that resides outside V8's heap. Implement an
1127
+ * ExternalStringResource to manage the life cycle of the underlying
1128
+ * buffer. Note that the string data must be immutable.
1129
+ */
1130
+ class V8EXPORT ExternalStringResource
1131
+ : public ExternalStringResourceBase {
1132
+ public:
1133
+ /**
1134
+ * Override the destructor to manage the life cycle of the underlying
1135
+ * buffer.
1136
+ */
1137
+ virtual ~ExternalStringResource() {}
1138
+
1139
+ /**
1140
+ * The string data from the underlying buffer.
1141
+ */
1142
+ virtual const uint16_t* data() const = 0;
1143
+
1144
+ /**
1145
+ * The length of the string. That is, the number of two-byte characters.
1146
+ */
1147
+ virtual size_t length() const = 0;
1148
+
1149
+ protected:
1150
+ ExternalStringResource() {}
1151
+ };
1152
+
1153
+ /**
1154
+ * An ExternalAsciiStringResource is a wrapper around an ASCII
1155
+ * string buffer that resides outside V8's heap. Implement an
1156
+ * ExternalAsciiStringResource to manage the life cycle of the
1157
+ * underlying buffer. Note that the string data must be immutable
1158
+ * and that the data must be strict (7-bit) ASCII, not Latin-1 or
1159
+ * UTF-8, which would require special treatment internally in the
1160
+ * engine and, in the case of UTF-8, do not allow efficient indexing.
1161
+ * Use String::New or convert to 16 bit data for non-ASCII.
1162
+ */
1163
+
1164
+ class V8EXPORT ExternalAsciiStringResource
1165
+ : public ExternalStringResourceBase {
1166
+ public:
1167
+ /**
1168
+ * Override the destructor to manage the life cycle of the underlying
1169
+ * buffer.
1170
+ */
1171
+ virtual ~ExternalAsciiStringResource() {}
1172
+ /** The string data from the underlying buffer.*/
1173
+ virtual const char* data() const = 0;
1174
+ /** The number of ASCII characters in the string.*/
1175
+ virtual size_t length() const = 0;
1176
+ protected:
1177
+ ExternalAsciiStringResource() {}
1178
+ };
1179
+
1180
+ /**
1181
+ * Get the ExternalStringResource for an external string. Returns
1182
+ * NULL if IsExternal() doesn't return true.
1183
+ */
1184
+ inline ExternalStringResource* GetExternalStringResource() const;
1185
+
1186
+ /**
1187
+ * Get the ExternalAsciiStringResource for an external ASCII string.
1188
+ * Returns NULL if IsExternalAscii() doesn't return true.
1189
+ */
1190
+ V8EXPORT const ExternalAsciiStringResource* GetExternalAsciiStringResource()
1191
+ const;
1192
+
1193
+ static inline String* Cast(v8::Value* obj);
1194
+
1195
+ /**
1196
+ * Allocates a new string from either UTF-8 encoded or ASCII data.
1197
+ * The second parameter 'length' gives the buffer length.
1198
+ * If the data is UTF-8 encoded, the caller must
1199
+ * be careful to supply the length parameter.
1200
+ * If it is not given, the function calls
1201
+ * 'strlen' to determine the buffer length, it might be
1202
+ * wrong if 'data' contains a null character.
1203
+ */
1204
+ V8EXPORT static Local<String> New(const char* data, int length = -1);
1205
+
1206
+ /** Allocates a new string from 16-bit character codes.*/
1207
+ V8EXPORT static Local<String> New(const uint16_t* data, int length = -1);
1208
+
1209
+ /** Creates a symbol. Returns one if it exists already.*/
1210
+ V8EXPORT static Local<String> NewSymbol(const char* data, int length = -1);
1211
+
1212
+ /**
1213
+ * Creates a new string by concatenating the left and the right strings
1214
+ * passed in as parameters.
1215
+ */
1216
+ V8EXPORT static Local<String> Concat(Handle<String> left,
1217
+ Handle<String> right);
1218
+
1219
+ /**
1220
+ * Creates a new external string using the data defined in the given
1221
+ * resource. When the external string is no longer live on V8's heap the
1222
+ * resource will be disposed by calling its Dispose method. The caller of
1223
+ * this function should not otherwise delete or modify the resource. Neither
1224
+ * should the underlying buffer be deallocated or modified except through the
1225
+ * destructor of the external string resource.
1226
+ */
1227
+ V8EXPORT static Local<String> NewExternal(ExternalStringResource* resource);
1228
+
1229
+ /**
1230
+ * Associate an external string resource with this string by transforming it
1231
+ * in place so that existing references to this string in the JavaScript heap
1232
+ * will use the external string resource. The external string resource's
1233
+ * character contents need to be equivalent to this string.
1234
+ * Returns true if the string has been changed to be an external string.
1235
+ * The string is not modified if the operation fails. See NewExternal for
1236
+ * information on the lifetime of the resource.
1237
+ */
1238
+ V8EXPORT bool MakeExternal(ExternalStringResource* resource);
1239
+
1240
+ /**
1241
+ * Creates a new external string using the ASCII data defined in the given
1242
+ * resource. When the external string is no longer live on V8's heap the
1243
+ * resource will be disposed by calling its Dispose method. The caller of
1244
+ * this function should not otherwise delete or modify the resource. Neither
1245
+ * should the underlying buffer be deallocated or modified except through the
1246
+ * destructor of the external string resource.
1247
+ */ V8EXPORT static Local<String> NewExternal(
1248
+ ExternalAsciiStringResource* resource);
1249
+
1250
+ /**
1251
+ * Associate an external string resource with this string by transforming it
1252
+ * in place so that existing references to this string in the JavaScript heap
1253
+ * will use the external string resource. The external string resource's
1254
+ * character contents need to be equivalent to this string.
1255
+ * Returns true if the string has been changed to be an external string.
1256
+ * The string is not modified if the operation fails. See NewExternal for
1257
+ * information on the lifetime of the resource.
1258
+ */
1259
+ V8EXPORT bool MakeExternal(ExternalAsciiStringResource* resource);
1260
+
1261
+ /**
1262
+ * Returns true if this string can be made external.
1263
+ */
1264
+ V8EXPORT bool CanMakeExternal();
1265
+
1266
+ /** Creates an undetectable string from the supplied ASCII or UTF-8 data.*/
1267
+ V8EXPORT static Local<String> NewUndetectable(const char* data,
1268
+ int length = -1);
1269
+
1270
+ /** Creates an undetectable string from the supplied 16-bit character codes.*/
1271
+ V8EXPORT static Local<String> NewUndetectable(const uint16_t* data,
1272
+ int length = -1);
1273
+
1274
+ /**
1275
+ * Converts an object to a UTF-8-encoded character array. Useful if
1276
+ * you want to print the object. If conversion to a string fails
1277
+ * (e.g. due to an exception in the toString() method of the object)
1278
+ * then the length() method returns 0 and the * operator returns
1279
+ * NULL.
1280
+ */
1281
+ class V8EXPORT Utf8Value {
1282
+ public:
1283
+ explicit Utf8Value(Handle<v8::Value> obj);
1284
+ ~Utf8Value();
1285
+ char* operator*() { return str_; }
1286
+ const char* operator*() const { return str_; }
1287
+ int length() const { return length_; }
1288
+ private:
1289
+ char* str_;
1290
+ int length_;
1291
+
1292
+ // Disallow copying and assigning.
1293
+ Utf8Value(const Utf8Value&);
1294
+ void operator=(const Utf8Value&);
1295
+ };
1296
+
1297
+ /**
1298
+ * Converts an object to an ASCII string.
1299
+ * Useful if you want to print the object.
1300
+ * If conversion to a string fails (eg. due to an exception in the toString()
1301
+ * method of the object) then the length() method returns 0 and the * operator
1302
+ * returns NULL.
1303
+ */
1304
+ class V8EXPORT AsciiValue {
1305
+ public:
1306
+ explicit AsciiValue(Handle<v8::Value> obj);
1307
+ ~AsciiValue();
1308
+ char* operator*() { return str_; }
1309
+ const char* operator*() const { return str_; }
1310
+ int length() const { return length_; }
1311
+ private:
1312
+ char* str_;
1313
+ int length_;
1314
+
1315
+ // Disallow copying and assigning.
1316
+ AsciiValue(const AsciiValue&);
1317
+ void operator=(const AsciiValue&);
1318
+ };
1319
+
1320
+ /**
1321
+ * Converts an object to a two-byte string.
1322
+ * If conversion to a string fails (eg. due to an exception in the toString()
1323
+ * method of the object) then the length() method returns 0 and the * operator
1324
+ * returns NULL.
1325
+ */
1326
+ class V8EXPORT Value {
1327
+ public:
1328
+ explicit Value(Handle<v8::Value> obj);
1329
+ ~Value();
1330
+ uint16_t* operator*() { return str_; }
1331
+ const uint16_t* operator*() const { return str_; }
1332
+ int length() const { return length_; }
1333
+ private:
1334
+ uint16_t* str_;
1335
+ int length_;
1336
+
1337
+ // Disallow copying and assigning.
1338
+ Value(const Value&);
1339
+ void operator=(const Value&);
1340
+ };
1341
+
1342
+ private:
1343
+ V8EXPORT void VerifyExternalStringResource(ExternalStringResource* val) const;
1344
+ V8EXPORT static void CheckCast(v8::Value* obj);
1345
+ };
1346
+
1347
+
1348
+ /**
1349
+ * A JavaScript number value (ECMA-262, 4.3.20)
1350
+ */
1351
+ class Number : public Primitive {
1352
+ public:
1353
+ V8EXPORT double Value() const;
1354
+ V8EXPORT static Local<Number> New(double value);
1355
+ static inline Number* Cast(v8::Value* obj);
1356
+ private:
1357
+ V8EXPORT Number();
1358
+ V8EXPORT static void CheckCast(v8::Value* obj);
1359
+ };
1360
+
1361
+
1362
+ /**
1363
+ * A JavaScript value representing a signed integer.
1364
+ */
1365
+ class Integer : public Number {
1366
+ public:
1367
+ V8EXPORT static Local<Integer> New(int32_t value);
1368
+ V8EXPORT static Local<Integer> NewFromUnsigned(uint32_t value);
1369
+ V8EXPORT int64_t Value() const;
1370
+ static inline Integer* Cast(v8::Value* obj);
1371
+ private:
1372
+ V8EXPORT Integer();
1373
+ V8EXPORT static void CheckCast(v8::Value* obj);
1374
+ };
1375
+
1376
+
1377
+ /**
1378
+ * A JavaScript value representing a 32-bit signed integer.
1379
+ */
1380
+ class Int32 : public Integer {
1381
+ public:
1382
+ V8EXPORT int32_t Value() const;
1383
+ private:
1384
+ V8EXPORT Int32();
1385
+ };
1386
+
1387
+
1388
+ /**
1389
+ * A JavaScript value representing a 32-bit unsigned integer.
1390
+ */
1391
+ class Uint32 : public Integer {
1392
+ public:
1393
+ V8EXPORT uint32_t Value() const;
1394
+ private:
1395
+ V8EXPORT Uint32();
1396
+ };
1397
+
1398
+
1399
+ enum PropertyAttribute {
1400
+ None = 0,
1401
+ ReadOnly = 1 << 0,
1402
+ DontEnum = 1 << 1,
1403
+ DontDelete = 1 << 2
1404
+ };
1405
+
1406
+ enum ExternalArrayType {
1407
+ kExternalByteArray = 1,
1408
+ kExternalUnsignedByteArray,
1409
+ kExternalShortArray,
1410
+ kExternalUnsignedShortArray,
1411
+ kExternalIntArray,
1412
+ kExternalUnsignedIntArray,
1413
+ kExternalFloatArray,
1414
+ kExternalDoubleArray,
1415
+ kExternalPixelArray
1416
+ };
1417
+
1418
+ /**
1419
+ * Accessor[Getter|Setter] are used as callback functions when
1420
+ * setting|getting a particular property. See Object and ObjectTemplate's
1421
+ * method SetAccessor.
1422
+ */
1423
+ typedef Handle<Value> (*AccessorGetter)(Local<String> property,
1424
+ const AccessorInfo& info);
1425
+
1426
+
1427
+ typedef void (*AccessorSetter)(Local<String> property,
1428
+ Local<Value> value,
1429
+ const AccessorInfo& info);
1430
+
1431
+
1432
+ /**
1433
+ * Access control specifications.
1434
+ *
1435
+ * Some accessors should be accessible across contexts. These
1436
+ * accessors have an explicit access control parameter which specifies
1437
+ * the kind of cross-context access that should be allowed.
1438
+ *
1439
+ * Additionally, for security, accessors can prohibit overwriting by
1440
+ * accessors defined in JavaScript. For objects that have such
1441
+ * accessors either locally or in their prototype chain it is not
1442
+ * possible to overwrite the accessor by using __defineGetter__ or
1443
+ * __defineSetter__ from JavaScript code.
1444
+ */
1445
+ enum AccessControl {
1446
+ DEFAULT = 0,
1447
+ ALL_CAN_READ = 1,
1448
+ ALL_CAN_WRITE = 1 << 1,
1449
+ PROHIBITS_OVERWRITING = 1 << 2
1450
+ };
1451
+
1452
+
1453
+ /**
1454
+ * A JavaScript object (ECMA-262, 4.3.3)
1455
+ */
1456
+ class Object : public Value {
1457
+ public:
1458
+ V8EXPORT bool Set(Handle<Value> key,
1459
+ Handle<Value> value,
1460
+ PropertyAttribute attribs = None);
1461
+
1462
+ V8EXPORT bool Set(uint32_t index,
1463
+ Handle<Value> value);
1464
+
1465
+ // Sets a local property on this object bypassing interceptors and
1466
+ // overriding accessors or read-only properties.
1467
+ //
1468
+ // Note that if the object has an interceptor the property will be set
1469
+ // locally, but since the interceptor takes precedence the local property
1470
+ // will only be returned if the interceptor doesn't return a value.
1471
+ //
1472
+ // Note also that this only works for named properties.
1473
+ V8EXPORT bool ForceSet(Handle<Value> key,
1474
+ Handle<Value> value,
1475
+ PropertyAttribute attribs = None);
1476
+
1477
+ V8EXPORT Local<Value> Get(Handle<Value> key);
1478
+
1479
+ V8EXPORT Local<Value> Get(uint32_t index);
1480
+
1481
+ /**
1482
+ * Gets the property attributes of a property which can be None or
1483
+ * any combination of ReadOnly, DontEnum and DontDelete. Returns
1484
+ * None when the property doesn't exist.
1485
+ */
1486
+ V8EXPORT PropertyAttribute GetPropertyAttributes(Handle<Value> key);
1487
+
1488
+ // TODO(1245389): Replace the type-specific versions of these
1489
+ // functions with generic ones that accept a Handle<Value> key.
1490
+ V8EXPORT bool Has(Handle<String> key);
1491
+
1492
+ V8EXPORT bool Delete(Handle<String> key);
1493
+
1494
+ // Delete a property on this object bypassing interceptors and
1495
+ // ignoring dont-delete attributes.
1496
+ V8EXPORT bool ForceDelete(Handle<Value> key);
1497
+
1498
+ V8EXPORT bool Has(uint32_t index);
1499
+
1500
+ V8EXPORT bool Delete(uint32_t index);
1501
+
1502
+ V8EXPORT bool SetAccessor(Handle<String> name,
1503
+ AccessorGetter getter,
1504
+ AccessorSetter setter = 0,
1505
+ Handle<Value> data = Handle<Value>(),
1506
+ AccessControl settings = DEFAULT,
1507
+ PropertyAttribute attribute = None);
1508
+
1509
+ /**
1510
+ * Returns an array containing the names of the enumerable properties
1511
+ * of this object, including properties from prototype objects. The
1512
+ * array returned by this method contains the same values as would
1513
+ * be enumerated by a for-in statement over this object.
1514
+ */
1515
+ V8EXPORT Local<Array> GetPropertyNames();
1516
+
1517
+ /**
1518
+ * This function has the same functionality as GetPropertyNames but
1519
+ * the returned array doesn't contain the names of properties from
1520
+ * prototype objects.
1521
+ */
1522
+ V8EXPORT Local<Array> GetOwnPropertyNames();
1523
+
1524
+ /**
1525
+ * Get the prototype object. This does not skip objects marked to
1526
+ * be skipped by __proto__ and it does not consult the security
1527
+ * handler.
1528
+ */
1529
+ V8EXPORT Local<Value> GetPrototype();
1530
+
1531
+ /**
1532
+ * Set the prototype object. This does not skip objects marked to
1533
+ * be skipped by __proto__ and it does not consult the security
1534
+ * handler.
1535
+ */
1536
+ V8EXPORT bool SetPrototype(Handle<Value> prototype);
1537
+
1538
+ /**
1539
+ * Finds an instance of the given function template in the prototype
1540
+ * chain.
1541
+ */
1542
+ V8EXPORT Local<Object> FindInstanceInPrototypeChain(
1543
+ Handle<FunctionTemplate> tmpl);
1544
+
1545
+ /**
1546
+ * Call builtin Object.prototype.toString on this object.
1547
+ * This is different from Value::ToString() that may call
1548
+ * user-defined toString function. This one does not.
1549
+ */
1550
+ V8EXPORT Local<String> ObjectProtoToString();
1551
+
1552
+ /**
1553
+ * Returns the name of the function invoked as a constructor for this object.
1554
+ */
1555
+ V8EXPORT Local<String> GetConstructorName();
1556
+
1557
+ /** Gets the number of internal fields for this Object. */
1558
+ V8EXPORT int InternalFieldCount();
1559
+ /** Gets the value in an internal field. */
1560
+ inline Local<Value> GetInternalField(int index);
1561
+ /** Sets the value in an internal field. */
1562
+ V8EXPORT void SetInternalField(int index, Handle<Value> value);
1563
+
1564
+ /** Gets a native pointer from an internal field. */
1565
+ inline void* GetPointerFromInternalField(int index);
1566
+
1567
+ /** Sets a native pointer in an internal field. */
1568
+ V8EXPORT void SetPointerInInternalField(int index, void* value);
1569
+
1570
+ // Testers for local properties.
1571
+ V8EXPORT bool HasOwnProperty(Handle<String> key);
1572
+ V8EXPORT bool HasRealNamedProperty(Handle<String> key);
1573
+ V8EXPORT bool HasRealIndexedProperty(uint32_t index);
1574
+ V8EXPORT bool HasRealNamedCallbackProperty(Handle<String> key);
1575
+
1576
+ /**
1577
+ * If result.IsEmpty() no real property was located in the prototype chain.
1578
+ * This means interceptors in the prototype chain are not called.
1579
+ */
1580
+ V8EXPORT Local<Value> GetRealNamedPropertyInPrototypeChain(
1581
+ Handle<String> key);
1582
+
1583
+ /**
1584
+ * If result.IsEmpty() no real property was located on the object or
1585
+ * in the prototype chain.
1586
+ * This means interceptors in the prototype chain are not called.
1587
+ */
1588
+ V8EXPORT Local<Value> GetRealNamedProperty(Handle<String> key);
1589
+
1590
+ /** Tests for a named lookup interceptor.*/
1591
+ V8EXPORT bool HasNamedLookupInterceptor();
1592
+
1593
+ /** Tests for an index lookup interceptor.*/
1594
+ V8EXPORT bool HasIndexedLookupInterceptor();
1595
+
1596
+ /**
1597
+ * Turns on access check on the object if the object is an instance of
1598
+ * a template that has access check callbacks. If an object has no
1599
+ * access check info, the object cannot be accessed by anyone.
1600
+ */
1601
+ V8EXPORT void TurnOnAccessCheck();
1602
+
1603
+ /**
1604
+ * Returns the identity hash for this object. The current implementation
1605
+ * uses a hidden property on the object to store the identity hash.
1606
+ *
1607
+ * The return value will never be 0. Also, it is not guaranteed to be
1608
+ * unique.
1609
+ */
1610
+ V8EXPORT int GetIdentityHash();
1611
+
1612
+ /**
1613
+ * Access hidden properties on JavaScript objects. These properties are
1614
+ * hidden from the executing JavaScript and only accessible through the V8
1615
+ * C++ API. Hidden properties introduced by V8 internally (for example the
1616
+ * identity hash) are prefixed with "v8::".
1617
+ */
1618
+ V8EXPORT bool SetHiddenValue(Handle<String> key, Handle<Value> value);
1619
+ V8EXPORT Local<Value> GetHiddenValue(Handle<String> key);
1620
+ V8EXPORT bool DeleteHiddenValue(Handle<String> key);
1621
+
1622
+ /**
1623
+ * Returns true if this is an instance of an api function (one
1624
+ * created from a function created from a function template) and has
1625
+ * been modified since it was created. Note that this method is
1626
+ * conservative and may return true for objects that haven't actually
1627
+ * been modified.
1628
+ */
1629
+ V8EXPORT bool IsDirty();
1630
+
1631
+ /**
1632
+ * Clone this object with a fast but shallow copy. Values will point
1633
+ * to the same values as the original object.
1634
+ */
1635
+ V8EXPORT Local<Object> Clone();
1636
+
1637
+ /**
1638
+ * Returns the context in which the object was created.
1639
+ */
1640
+ V8EXPORT Local<Context> CreationContext();
1641
+
1642
+ /**
1643
+ * Set the backing store of the indexed properties to be managed by the
1644
+ * embedding layer. Access to the indexed properties will follow the rules
1645
+ * spelled out in CanvasPixelArray.
1646
+ * Note: The embedding program still owns the data and needs to ensure that
1647
+ * the backing store is preserved while V8 has a reference.
1648
+ */
1649
+ V8EXPORT void SetIndexedPropertiesToPixelData(uint8_t* data, int length);
1650
+ V8EXPORT bool HasIndexedPropertiesInPixelData();
1651
+ V8EXPORT uint8_t* GetIndexedPropertiesPixelData();
1652
+ V8EXPORT int GetIndexedPropertiesPixelDataLength();
1653
+
1654
+ /**
1655
+ * Set the backing store of the indexed properties to be managed by the
1656
+ * embedding layer. Access to the indexed properties will follow the rules
1657
+ * spelled out for the CanvasArray subtypes in the WebGL specification.
1658
+ * Note: The embedding program still owns the data and needs to ensure that
1659
+ * the backing store is preserved while V8 has a reference.
1660
+ */
1661
+ V8EXPORT void SetIndexedPropertiesToExternalArrayData(
1662
+ void* data,
1663
+ ExternalArrayType array_type,
1664
+ int number_of_elements);
1665
+ V8EXPORT bool HasIndexedPropertiesInExternalArrayData();
1666
+ V8EXPORT void* GetIndexedPropertiesExternalArrayData();
1667
+ V8EXPORT ExternalArrayType GetIndexedPropertiesExternalArrayDataType();
1668
+ V8EXPORT int GetIndexedPropertiesExternalArrayDataLength();
1669
+
1670
+ /**
1671
+ * Checks whether a callback is set by the
1672
+ * ObjectTemplate::SetCallAsFunctionHandler method.
1673
+ * When an Object is callable this method returns true.
1674
+ */
1675
+ V8EXPORT bool IsCallable();
1676
+
1677
+ /**
1678
+ * Call an Object as a function if a callback is set by the
1679
+ * ObjectTemplate::SetCallAsFunctionHandler method.
1680
+ */
1681
+ V8EXPORT Local<Value> CallAsFunction(Handle<Object> recv,
1682
+ int argc,
1683
+ Handle<Value> argv[]);
1684
+
1685
+ /**
1686
+ * Call an Object as a constructor if a callback is set by the
1687
+ * ObjectTemplate::SetCallAsFunctionHandler method.
1688
+ * Note: This method behaves like the Function::NewInstance method.
1689
+ */
1690
+ V8EXPORT Local<Value> CallAsConstructor(int argc,
1691
+ Handle<Value> argv[]);
1692
+
1693
+ V8EXPORT static Local<Object> New();
1694
+ static inline Object* Cast(Value* obj);
1695
+
1696
+ private:
1697
+ V8EXPORT Object();
1698
+ V8EXPORT static void CheckCast(Value* obj);
1699
+ V8EXPORT Local<Value> CheckedGetInternalField(int index);
1700
+ V8EXPORT void* SlowGetPointerFromInternalField(int index);
1701
+
1702
+ /**
1703
+ * If quick access to the internal field is possible this method
1704
+ * returns the value. Otherwise an empty handle is returned.
1705
+ */
1706
+ inline Local<Value> UncheckedGetInternalField(int index);
1707
+ };
1708
+
1709
+
1710
+ /**
1711
+ * An instance of the built-in array constructor (ECMA-262, 15.4.2).
1712
+ */
1713
+ class Array : public Object {
1714
+ public:
1715
+ V8EXPORT uint32_t Length() const;
1716
+
1717
+ /**
1718
+ * Clones an element at index |index|. Returns an empty
1719
+ * handle if cloning fails (for any reason).
1720
+ */
1721
+ V8EXPORT Local<Object> CloneElementAt(uint32_t index);
1722
+
1723
+ /**
1724
+ * Creates a JavaScript array with the given length. If the length
1725
+ * is negative the returned array will have length 0.
1726
+ */
1727
+ V8EXPORT static Local<Array> New(int length = 0);
1728
+
1729
+ static inline Array* Cast(Value* obj);
1730
+ private:
1731
+ V8EXPORT Array();
1732
+ V8EXPORT static void CheckCast(Value* obj);
1733
+ };
1734
+
1735
+
1736
+ /**
1737
+ * A JavaScript function object (ECMA-262, 15.3).
1738
+ */
1739
+ class Function : public Object {
1740
+ public:
1741
+ V8EXPORT Local<Object> NewInstance() const;
1742
+ V8EXPORT Local<Object> NewInstance(int argc, Handle<Value> argv[]) const;
1743
+ V8EXPORT Local<Value> Call(Handle<Object> recv,
1744
+ int argc,
1745
+ Handle<Value> argv[]);
1746
+ V8EXPORT void SetName(Handle<String> name);
1747
+ V8EXPORT Handle<Value> GetName() const;
1748
+
1749
+ /**
1750
+ * Name inferred from variable or property assignment of this function.
1751
+ * Used to facilitate debugging and profiling of JavaScript code written
1752
+ * in an OO style, where many functions are anonymous but are assigned
1753
+ * to object properties.
1754
+ */
1755
+ V8EXPORT Handle<Value> GetInferredName() const;
1756
+
1757
+ /**
1758
+ * Returns zero based line number of function body and
1759
+ * kLineOffsetNotFound if no information available.
1760
+ */
1761
+ V8EXPORT int GetScriptLineNumber() const;
1762
+ /**
1763
+ * Returns zero based column number of function body and
1764
+ * kLineOffsetNotFound if no information available.
1765
+ */
1766
+ V8EXPORT int GetScriptColumnNumber() const;
1767
+ V8EXPORT Handle<Value> GetScriptId() const;
1768
+ V8EXPORT ScriptOrigin GetScriptOrigin() const;
1769
+ static inline Function* Cast(Value* obj);
1770
+ V8EXPORT static const int kLineOffsetNotFound;
1771
+
1772
+ private:
1773
+ V8EXPORT Function();
1774
+ V8EXPORT static void CheckCast(Value* obj);
1775
+ };
1776
+
1777
+
1778
+ /**
1779
+ * An instance of the built-in Date constructor (ECMA-262, 15.9).
1780
+ */
1781
+ class Date : public Object {
1782
+ public:
1783
+ V8EXPORT static Local<Value> New(double time);
1784
+
1785
+ /**
1786
+ * A specialization of Value::NumberValue that is more efficient
1787
+ * because we know the structure of this object.
1788
+ */
1789
+ V8EXPORT double NumberValue() const;
1790
+
1791
+ static inline Date* Cast(v8::Value* obj);
1792
+
1793
+ /**
1794
+ * Notification that the embedder has changed the time zone,
1795
+ * daylight savings time, or other date / time configuration
1796
+ * parameters. V8 keeps a cache of various values used for
1797
+ * date / time computation. This notification will reset
1798
+ * those cached values for the current context so that date /
1799
+ * time configuration changes would be reflected in the Date
1800
+ * object.
1801
+ *
1802
+ * This API should not be called more than needed as it will
1803
+ * negatively impact the performance of date operations.
1804
+ */
1805
+ V8EXPORT static void DateTimeConfigurationChangeNotification();
1806
+
1807
+ private:
1808
+ V8EXPORT static void CheckCast(v8::Value* obj);
1809
+ };
1810
+
1811
+
1812
+ /**
1813
+ * A Number object (ECMA-262, 4.3.21).
1814
+ */
1815
+ class NumberObject : public Object {
1816
+ public:
1817
+ V8EXPORT static Local<Value> New(double value);
1818
+
1819
+ /**
1820
+ * Returns the Number held by the object.
1821
+ */
1822
+ V8EXPORT double NumberValue() const;
1823
+
1824
+ static inline NumberObject* Cast(v8::Value* obj);
1825
+
1826
+ private:
1827
+ V8EXPORT static void CheckCast(v8::Value* obj);
1828
+ };
1829
+
1830
+
1831
+ /**
1832
+ * A Boolean object (ECMA-262, 4.3.15).
1833
+ */
1834
+ class BooleanObject : public Object {
1835
+ public:
1836
+ V8EXPORT static Local<Value> New(bool value);
1837
+
1838
+ /**
1839
+ * Returns the Boolean held by the object.
1840
+ */
1841
+ V8EXPORT bool BooleanValue() const;
1842
+
1843
+ static inline BooleanObject* Cast(v8::Value* obj);
1844
+
1845
+ private:
1846
+ V8EXPORT static void CheckCast(v8::Value* obj);
1847
+ };
1848
+
1849
+
1850
+ /**
1851
+ * A String object (ECMA-262, 4.3.18).
1852
+ */
1853
+ class StringObject : public Object {
1854
+ public:
1855
+ V8EXPORT static Local<Value> New(Handle<String> value);
1856
+
1857
+ /**
1858
+ * Returns the String held by the object.
1859
+ */
1860
+ V8EXPORT Local<String> StringValue() const;
1861
+
1862
+ static inline StringObject* Cast(v8::Value* obj);
1863
+
1864
+ private:
1865
+ V8EXPORT static void CheckCast(v8::Value* obj);
1866
+ };
1867
+
1868
+
1869
+ /**
1870
+ * An instance of the built-in RegExp constructor (ECMA-262, 15.10).
1871
+ */
1872
+ class RegExp : public Object {
1873
+ public:
1874
+ /**
1875
+ * Regular expression flag bits. They can be or'ed to enable a set
1876
+ * of flags.
1877
+ */
1878
+ enum Flags {
1879
+ kNone = 0,
1880
+ kGlobal = 1,
1881
+ kIgnoreCase = 2,
1882
+ kMultiline = 4
1883
+ };
1884
+
1885
+ /**
1886
+ * Creates a regular expression from the given pattern string and
1887
+ * the flags bit field. May throw a JavaScript exception as
1888
+ * described in ECMA-262, 15.10.4.1.
1889
+ *
1890
+ * For example,
1891
+ * RegExp::New(v8::String::New("foo"),
1892
+ * static_cast<RegExp::Flags>(kGlobal | kMultiline))
1893
+ * is equivalent to evaluating "/foo/gm".
1894
+ */
1895
+ V8EXPORT static Local<RegExp> New(Handle<String> pattern,
1896
+ Flags flags);
1897
+
1898
+ /**
1899
+ * Returns the value of the source property: a string representing
1900
+ * the regular expression.
1901
+ */
1902
+ V8EXPORT Local<String> GetSource() const;
1903
+
1904
+ /**
1905
+ * Returns the flags bit field.
1906
+ */
1907
+ V8EXPORT Flags GetFlags() const;
1908
+
1909
+ static inline RegExp* Cast(v8::Value* obj);
1910
+
1911
+ private:
1912
+ V8EXPORT static void CheckCast(v8::Value* obj);
1913
+ };
1914
+
1915
+
1916
+ /**
1917
+ * A JavaScript value that wraps a C++ void*. This type of value is
1918
+ * mainly used to associate C++ data structures with JavaScript
1919
+ * objects.
1920
+ *
1921
+ * The Wrap function V8 will return the most optimal Value object wrapping the
1922
+ * C++ void*. The type of the value is not guaranteed to be an External object
1923
+ * and no assumptions about its type should be made. To access the wrapped
1924
+ * value Unwrap should be used, all other operations on that object will lead
1925
+ * to unpredictable results.
1926
+ */
1927
+ class External : public Value {
1928
+ public:
1929
+ V8EXPORT static Local<Value> Wrap(void* data);
1930
+ static inline void* Unwrap(Handle<Value> obj);
1931
+
1932
+ V8EXPORT static Local<External> New(void* value);
1933
+ static inline External* Cast(Value* obj);
1934
+ V8EXPORT void* Value() const;
1935
+ private:
1936
+ V8EXPORT External();
1937
+ V8EXPORT static void CheckCast(v8::Value* obj);
1938
+ static inline void* QuickUnwrap(Handle<v8::Value> obj);
1939
+ V8EXPORT static void* FullUnwrap(Handle<v8::Value> obj);
1940
+ };
1941
+
1942
+
1943
+ // --- Templates ---
1944
+
1945
+
1946
+ /**
1947
+ * The superclass of object and function templates.
1948
+ */
1949
+ class V8EXPORT Template : public Data {
1950
+ public:
1951
+ /** Adds a property to each instance created by this template.*/
1952
+ void Set(Handle<String> name, Handle<Data> value,
1953
+ PropertyAttribute attributes = None);
1954
+ inline void Set(const char* name, Handle<Data> value);
1955
+ private:
1956
+ Template();
1957
+
1958
+ friend class ObjectTemplate;
1959
+ friend class FunctionTemplate;
1960
+ };
1961
+
1962
+
1963
+ /**
1964
+ * The argument information given to function call callbacks. This
1965
+ * class provides access to information about the context of the call,
1966
+ * including the receiver, the number and values of arguments, and
1967
+ * the holder of the function.
1968
+ */
1969
+ class Arguments {
1970
+ public:
1971
+ inline int Length() const;
1972
+ inline Local<Value> operator[](int i) const;
1973
+ inline Local<Function> Callee() const;
1974
+ inline Local<Object> This() const;
1975
+ inline Local<Object> Holder() const;
1976
+ inline bool IsConstructCall() const;
1977
+ inline Local<Value> Data() const;
1978
+ inline Isolate* GetIsolate() const;
1979
+
1980
+ private:
1981
+ static const int kIsolateIndex = 0;
1982
+ static const int kDataIndex = -1;
1983
+ static const int kCalleeIndex = -2;
1984
+ static const int kHolderIndex = -3;
1985
+
1986
+ friend class ImplementationUtilities;
1987
+ inline Arguments(internal::Object** implicit_args,
1988
+ internal::Object** values,
1989
+ int length,
1990
+ bool is_construct_call);
1991
+ internal::Object** implicit_args_;
1992
+ internal::Object** values_;
1993
+ int length_;
1994
+ bool is_construct_call_;
1995
+ };
1996
+
1997
+
1998
+ /**
1999
+ * The information passed to an accessor callback about the context
2000
+ * of the property access.
2001
+ */
2002
+ class V8EXPORT AccessorInfo {
2003
+ public:
2004
+ inline AccessorInfo(internal::Object** args)
2005
+ : args_(args) { }
2006
+ inline Isolate* GetIsolate() const;
2007
+ inline Local<Value> Data() const;
2008
+ inline Local<Object> This() const;
2009
+ inline Local<Object> Holder() const;
2010
+
2011
+ private:
2012
+ internal::Object** args_;
2013
+ };
2014
+
2015
+
2016
+ typedef Handle<Value> (*InvocationCallback)(const Arguments& args);
2017
+
2018
+ /**
2019
+ * NamedProperty[Getter|Setter] are used as interceptors on object.
2020
+ * See ObjectTemplate::SetNamedPropertyHandler.
2021
+ */
2022
+ typedef Handle<Value> (*NamedPropertyGetter)(Local<String> property,
2023
+ const AccessorInfo& info);
2024
+
2025
+
2026
+ /**
2027
+ * Returns the value if the setter intercepts the request.
2028
+ * Otherwise, returns an empty handle.
2029
+ */
2030
+ typedef Handle<Value> (*NamedPropertySetter)(Local<String> property,
2031
+ Local<Value> value,
2032
+ const AccessorInfo& info);
2033
+
2034
+ /**
2035
+ * Returns a non-empty handle if the interceptor intercepts the request.
2036
+ * The result is an integer encoding property attributes (like v8::None,
2037
+ * v8::DontEnum, etc.)
2038
+ */
2039
+ typedef Handle<Integer> (*NamedPropertyQuery)(Local<String> property,
2040
+ const AccessorInfo& info);
2041
+
2042
+
2043
+ /**
2044
+ * Returns a non-empty handle if the deleter intercepts the request.
2045
+ * The return value is true if the property could be deleted and false
2046
+ * otherwise.
2047
+ */
2048
+ typedef Handle<Boolean> (*NamedPropertyDeleter)(Local<String> property,
2049
+ const AccessorInfo& info);
2050
+
2051
+ /**
2052
+ * Returns an array containing the names of the properties the named
2053
+ * property getter intercepts.
2054
+ */
2055
+ typedef Handle<Array> (*NamedPropertyEnumerator)(const AccessorInfo& info);
2056
+
2057
+
2058
+ /**
2059
+ * Returns the value of the property if the getter intercepts the
2060
+ * request. Otherwise, returns an empty handle.
2061
+ */
2062
+ typedef Handle<Value> (*IndexedPropertyGetter)(uint32_t index,
2063
+ const AccessorInfo& info);
2064
+
2065
+
2066
+ /**
2067
+ * Returns the value if the setter intercepts the request.
2068
+ * Otherwise, returns an empty handle.
2069
+ */
2070
+ typedef Handle<Value> (*IndexedPropertySetter)(uint32_t index,
2071
+ Local<Value> value,
2072
+ const AccessorInfo& info);
2073
+
2074
+
2075
+ /**
2076
+ * Returns a non-empty handle if the interceptor intercepts the request.
2077
+ * The result is an integer encoding property attributes.
2078
+ */
2079
+ typedef Handle<Integer> (*IndexedPropertyQuery)(uint32_t index,
2080
+ const AccessorInfo& info);
2081
+
2082
+ /**
2083
+ * Returns a non-empty handle if the deleter intercepts the request.
2084
+ * The return value is true if the property could be deleted and false
2085
+ * otherwise.
2086
+ */
2087
+ typedef Handle<Boolean> (*IndexedPropertyDeleter)(uint32_t index,
2088
+ const AccessorInfo& info);
2089
+
2090
+ /**
2091
+ * Returns an array containing the indices of the properties the
2092
+ * indexed property getter intercepts.
2093
+ */
2094
+ typedef Handle<Array> (*IndexedPropertyEnumerator)(const AccessorInfo& info);
2095
+
2096
+
2097
+ /**
2098
+ * Access type specification.
2099
+ */
2100
+ enum AccessType {
2101
+ ACCESS_GET,
2102
+ ACCESS_SET,
2103
+ ACCESS_HAS,
2104
+ ACCESS_DELETE,
2105
+ ACCESS_KEYS
2106
+ };
2107
+
2108
+
2109
+ /**
2110
+ * Returns true if cross-context access should be allowed to the named
2111
+ * property with the given key on the host object.
2112
+ */
2113
+ typedef bool (*NamedSecurityCallback)(Local<Object> host,
2114
+ Local<Value> key,
2115
+ AccessType type,
2116
+ Local<Value> data);
2117
+
2118
+
2119
+ /**
2120
+ * Returns true if cross-context access should be allowed to the indexed
2121
+ * property with the given index on the host object.
2122
+ */
2123
+ typedef bool (*IndexedSecurityCallback)(Local<Object> host,
2124
+ uint32_t index,
2125
+ AccessType type,
2126
+ Local<Value> data);
2127
+
2128
+
2129
+ /**
2130
+ * A FunctionTemplate is used to create functions at runtime. There
2131
+ * can only be one function created from a FunctionTemplate in a
2132
+ * context. The lifetime of the created function is equal to the
2133
+ * lifetime of the context. So in case the embedder needs to create
2134
+ * temporary functions that can be collected using Scripts is
2135
+ * preferred.
2136
+ *
2137
+ * A FunctionTemplate can have properties, these properties are added to the
2138
+ * function object when it is created.
2139
+ *
2140
+ * A FunctionTemplate has a corresponding instance template which is
2141
+ * used to create object instances when the function is used as a
2142
+ * constructor. Properties added to the instance template are added to
2143
+ * each object instance.
2144
+ *
2145
+ * A FunctionTemplate can have a prototype template. The prototype template
2146
+ * is used to create the prototype object of the function.
2147
+ *
2148
+ * The following example shows how to use a FunctionTemplate:
2149
+ *
2150
+ * \code
2151
+ * v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New();
2152
+ * t->Set("func_property", v8::Number::New(1));
2153
+ *
2154
+ * v8::Local<v8::Template> proto_t = t->PrototypeTemplate();
2155
+ * proto_t->Set("proto_method", v8::FunctionTemplate::New(InvokeCallback));
2156
+ * proto_t->Set("proto_const", v8::Number::New(2));
2157
+ *
2158
+ * v8::Local<v8::ObjectTemplate> instance_t = t->InstanceTemplate();
2159
+ * instance_t->SetAccessor("instance_accessor", InstanceAccessorCallback);
2160
+ * instance_t->SetNamedPropertyHandler(PropertyHandlerCallback, ...);
2161
+ * instance_t->Set("instance_property", Number::New(3));
2162
+ *
2163
+ * v8::Local<v8::Function> function = t->GetFunction();
2164
+ * v8::Local<v8::Object> instance = function->NewInstance();
2165
+ * \endcode
2166
+ *
2167
+ * Let's use "function" as the JS variable name of the function object
2168
+ * and "instance" for the instance object created above. The function
2169
+ * and the instance will have the following properties:
2170
+ *
2171
+ * \code
2172
+ * func_property in function == true;
2173
+ * function.func_property == 1;
2174
+ *
2175
+ * function.prototype.proto_method() invokes 'InvokeCallback'
2176
+ * function.prototype.proto_const == 2;
2177
+ *
2178
+ * instance instanceof function == true;
2179
+ * instance.instance_accessor calls 'InstanceAccessorCallback'
2180
+ * instance.instance_property == 3;
2181
+ * \endcode
2182
+ *
2183
+ * A FunctionTemplate can inherit from another one by calling the
2184
+ * FunctionTemplate::Inherit method. The following graph illustrates
2185
+ * the semantics of inheritance:
2186
+ *
2187
+ * \code
2188
+ * FunctionTemplate Parent -> Parent() . prototype -> { }
2189
+ * ^ ^
2190
+ * | Inherit(Parent) | .__proto__
2191
+ * | |
2192
+ * FunctionTemplate Child -> Child() . prototype -> { }
2193
+ * \endcode
2194
+ *
2195
+ * A FunctionTemplate 'Child' inherits from 'Parent', the prototype
2196
+ * object of the Child() function has __proto__ pointing to the
2197
+ * Parent() function's prototype object. An instance of the Child
2198
+ * function has all properties on Parent's instance templates.
2199
+ *
2200
+ * Let Parent be the FunctionTemplate initialized in the previous
2201
+ * section and create a Child FunctionTemplate by:
2202
+ *
2203
+ * \code
2204
+ * Local<FunctionTemplate> parent = t;
2205
+ * Local<FunctionTemplate> child = FunctionTemplate::New();
2206
+ * child->Inherit(parent);
2207
+ *
2208
+ * Local<Function> child_function = child->GetFunction();
2209
+ * Local<Object> child_instance = child_function->NewInstance();
2210
+ * \endcode
2211
+ *
2212
+ * The Child function and Child instance will have the following
2213
+ * properties:
2214
+ *
2215
+ * \code
2216
+ * child_func.prototype.__proto__ == function.prototype;
2217
+ * child_instance.instance_accessor calls 'InstanceAccessorCallback'
2218
+ * child_instance.instance_property == 3;
2219
+ * \endcode
2220
+ */
2221
+ class V8EXPORT FunctionTemplate : public Template {
2222
+ public:
2223
+ /** Creates a function template.*/
2224
+ static Local<FunctionTemplate> New(
2225
+ InvocationCallback callback = 0,
2226
+ Handle<Value> data = Handle<Value>(),
2227
+ Handle<Signature> signature = Handle<Signature>());
2228
+ /** Returns the unique function instance in the current execution context.*/
2229
+ Local<Function> GetFunction();
2230
+
2231
+ /**
2232
+ * Set the call-handler callback for a FunctionTemplate. This
2233
+ * callback is called whenever the function created from this
2234
+ * FunctionTemplate is called.
2235
+ */
2236
+ void SetCallHandler(InvocationCallback callback,
2237
+ Handle<Value> data = Handle<Value>());
2238
+
2239
+ /** Get the InstanceTemplate. */
2240
+ Local<ObjectTemplate> InstanceTemplate();
2241
+
2242
+ /** Causes the function template to inherit from a parent function template.*/
2243
+ void Inherit(Handle<FunctionTemplate> parent);
2244
+
2245
+ /**
2246
+ * A PrototypeTemplate is the template used to create the prototype object
2247
+ * of the function created by this template.
2248
+ */
2249
+ Local<ObjectTemplate> PrototypeTemplate();
2250
+
2251
+
2252
+ /**
2253
+ * Set the class name of the FunctionTemplate. This is used for
2254
+ * printing objects created with the function created from the
2255
+ * FunctionTemplate as its constructor.
2256
+ */
2257
+ void SetClassName(Handle<String> name);
2258
+
2259
+ /**
2260
+ * Determines whether the __proto__ accessor ignores instances of
2261
+ * the function template. If instances of the function template are
2262
+ * ignored, __proto__ skips all instances and instead returns the
2263
+ * next object in the prototype chain.
2264
+ *
2265
+ * Call with a value of true to make the __proto__ accessor ignore
2266
+ * instances of the function template. Call with a value of false
2267
+ * to make the __proto__ accessor not ignore instances of the
2268
+ * function template. By default, instances of a function template
2269
+ * are not ignored.
2270
+ */
2271
+ void SetHiddenPrototype(bool value);
2272
+
2273
+ /**
2274
+ * Sets the ReadOnly flag in the attributes of the 'prototype' property
2275
+ * of functions created from this FunctionTemplate to true.
2276
+ */
2277
+ void ReadOnlyPrototype();
2278
+
2279
+ /**
2280
+ * Returns true if the given object is an instance of this function
2281
+ * template.
2282
+ */
2283
+ bool HasInstance(Handle<Value> object);
2284
+
2285
+ private:
2286
+ FunctionTemplate();
2287
+ void AddInstancePropertyAccessor(Handle<String> name,
2288
+ AccessorGetter getter,
2289
+ AccessorSetter setter,
2290
+ Handle<Value> data,
2291
+ AccessControl settings,
2292
+ PropertyAttribute attributes);
2293
+ void SetNamedInstancePropertyHandler(NamedPropertyGetter getter,
2294
+ NamedPropertySetter setter,
2295
+ NamedPropertyQuery query,
2296
+ NamedPropertyDeleter remover,
2297
+ NamedPropertyEnumerator enumerator,
2298
+ Handle<Value> data);
2299
+ void SetIndexedInstancePropertyHandler(IndexedPropertyGetter getter,
2300
+ IndexedPropertySetter setter,
2301
+ IndexedPropertyQuery query,
2302
+ IndexedPropertyDeleter remover,
2303
+ IndexedPropertyEnumerator enumerator,
2304
+ Handle<Value> data);
2305
+ void SetInstanceCallAsFunctionHandler(InvocationCallback callback,
2306
+ Handle<Value> data);
2307
+
2308
+ friend class Context;
2309
+ friend class ObjectTemplate;
2310
+ };
2311
+
2312
+
2313
+ /**
2314
+ * An ObjectTemplate is used to create objects at runtime.
2315
+ *
2316
+ * Properties added to an ObjectTemplate are added to each object
2317
+ * created from the ObjectTemplate.
2318
+ */
2319
+ class V8EXPORT ObjectTemplate : public Template {
2320
+ public:
2321
+ /** Creates an ObjectTemplate. */
2322
+ static Local<ObjectTemplate> New();
2323
+
2324
+ /** Creates a new instance of this template.*/
2325
+ Local<Object> NewInstance();
2326
+
2327
+ /**
2328
+ * Sets an accessor on the object template.
2329
+ *
2330
+ * Whenever the property with the given name is accessed on objects
2331
+ * created from this ObjectTemplate the getter and setter callbacks
2332
+ * are called instead of getting and setting the property directly
2333
+ * on the JavaScript object.
2334
+ *
2335
+ * \param name The name of the property for which an accessor is added.
2336
+ * \param getter The callback to invoke when getting the property.
2337
+ * \param setter The callback to invoke when setting the property.
2338
+ * \param data A piece of data that will be passed to the getter and setter
2339
+ * callbacks whenever they are invoked.
2340
+ * \param settings Access control settings for the accessor. This is a bit
2341
+ * field consisting of one of more of
2342
+ * DEFAULT = 0, ALL_CAN_READ = 1, or ALL_CAN_WRITE = 2.
2343
+ * The default is to not allow cross-context access.
2344
+ * ALL_CAN_READ means that all cross-context reads are allowed.
2345
+ * ALL_CAN_WRITE means that all cross-context writes are allowed.
2346
+ * The combination ALL_CAN_READ | ALL_CAN_WRITE can be used to allow all
2347
+ * cross-context access.
2348
+ * \param attribute The attributes of the property for which an accessor
2349
+ * is added.
2350
+ */
2351
+ void SetAccessor(Handle<String> name,
2352
+ AccessorGetter getter,
2353
+ AccessorSetter setter = 0,
2354
+ Handle<Value> data = Handle<Value>(),
2355
+ AccessControl settings = DEFAULT,
2356
+ PropertyAttribute attribute = None);
2357
+
2358
+ /**
2359
+ * Sets a named property handler on the object template.
2360
+ *
2361
+ * Whenever a named property is accessed on objects created from
2362
+ * this object template, the provided callback is invoked instead of
2363
+ * accessing the property directly on the JavaScript object.
2364
+ *
2365
+ * \param getter The callback to invoke when getting a property.
2366
+ * \param setter The callback to invoke when setting a property.
2367
+ * \param query The callback to invoke to check if a property is present,
2368
+ * and if present, get its attributes.
2369
+ * \param deleter The callback to invoke when deleting a property.
2370
+ * \param enumerator The callback to invoke to enumerate all the named
2371
+ * properties of an object.
2372
+ * \param data A piece of data that will be passed to the callbacks
2373
+ * whenever they are invoked.
2374
+ */
2375
+ void SetNamedPropertyHandler(NamedPropertyGetter getter,
2376
+ NamedPropertySetter setter = 0,
2377
+ NamedPropertyQuery query = 0,
2378
+ NamedPropertyDeleter deleter = 0,
2379
+ NamedPropertyEnumerator enumerator = 0,
2380
+ Handle<Value> data = Handle<Value>());
2381
+
2382
+ /**
2383
+ * Sets an indexed property handler on the object template.
2384
+ *
2385
+ * Whenever an indexed property is accessed on objects created from
2386
+ * this object template, the provided callback is invoked instead of
2387
+ * accessing the property directly on the JavaScript object.
2388
+ *
2389
+ * \param getter The callback to invoke when getting a property.
2390
+ * \param setter The callback to invoke when setting a property.
2391
+ * \param query The callback to invoke to check if an object has a property.
2392
+ * \param deleter The callback to invoke when deleting a property.
2393
+ * \param enumerator The callback to invoke to enumerate all the indexed
2394
+ * properties of an object.
2395
+ * \param data A piece of data that will be passed to the callbacks
2396
+ * whenever they are invoked.
2397
+ */
2398
+ void SetIndexedPropertyHandler(IndexedPropertyGetter getter,
2399
+ IndexedPropertySetter setter = 0,
2400
+ IndexedPropertyQuery query = 0,
2401
+ IndexedPropertyDeleter deleter = 0,
2402
+ IndexedPropertyEnumerator enumerator = 0,
2403
+ Handle<Value> data = Handle<Value>());
2404
+
2405
+ /**
2406
+ * Sets the callback to be used when calling instances created from
2407
+ * this template as a function. If no callback is set, instances
2408
+ * behave like normal JavaScript objects that cannot be called as a
2409
+ * function.
2410
+ */
2411
+ void SetCallAsFunctionHandler(InvocationCallback callback,
2412
+ Handle<Value> data = Handle<Value>());
2413
+
2414
+ /**
2415
+ * Mark object instances of the template as undetectable.
2416
+ *
2417
+ * In many ways, undetectable objects behave as though they are not
2418
+ * there. They behave like 'undefined' in conditionals and when
2419
+ * printed. However, properties can be accessed and called as on
2420
+ * normal objects.
2421
+ */
2422
+ void MarkAsUndetectable();
2423
+
2424
+ /**
2425
+ * Sets access check callbacks on the object template.
2426
+ *
2427
+ * When accessing properties on instances of this object template,
2428
+ * the access check callback will be called to determine whether or
2429
+ * not to allow cross-context access to the properties.
2430
+ * The last parameter specifies whether access checks are turned
2431
+ * on by default on instances. If access checks are off by default,
2432
+ * they can be turned on on individual instances by calling
2433
+ * Object::TurnOnAccessCheck().
2434
+ */
2435
+ void SetAccessCheckCallbacks(NamedSecurityCallback named_handler,
2436
+ IndexedSecurityCallback indexed_handler,
2437
+ Handle<Value> data = Handle<Value>(),
2438
+ bool turned_on_by_default = true);
2439
+
2440
+ /**
2441
+ * Gets the number of internal fields for objects generated from
2442
+ * this template.
2443
+ */
2444
+ int InternalFieldCount();
2445
+
2446
+ /**
2447
+ * Sets the number of internal fields for objects generated from
2448
+ * this template.
2449
+ */
2450
+ void SetInternalFieldCount(int value);
2451
+
2452
+ private:
2453
+ ObjectTemplate();
2454
+ static Local<ObjectTemplate> New(Handle<FunctionTemplate> constructor);
2455
+ friend class FunctionTemplate;
2456
+ };
2457
+
2458
+
2459
+ /**
2460
+ * A Signature specifies which receivers and arguments a function can
2461
+ * legally be called with.
2462
+ */
2463
+ class V8EXPORT Signature : public Data {
2464
+ public:
2465
+ static Local<Signature> New(Handle<FunctionTemplate> receiver =
2466
+ Handle<FunctionTemplate>(),
2467
+ int argc = 0,
2468
+ Handle<FunctionTemplate> argv[] = 0);
2469
+ private:
2470
+ Signature();
2471
+ };
2472
+
2473
+
2474
+ /**
2475
+ * A utility for determining the type of objects based on the template
2476
+ * they were constructed from.
2477
+ */
2478
+ class V8EXPORT TypeSwitch : public Data {
2479
+ public:
2480
+ static Local<TypeSwitch> New(Handle<FunctionTemplate> type);
2481
+ static Local<TypeSwitch> New(int argc, Handle<FunctionTemplate> types[]);
2482
+ int match(Handle<Value> value);
2483
+ private:
2484
+ TypeSwitch();
2485
+ };
2486
+
2487
+
2488
+ // --- Extensions ---
2489
+
2490
+ class V8EXPORT ExternalAsciiStringResourceImpl
2491
+ : public String::ExternalAsciiStringResource {
2492
+ public:
2493
+ ExternalAsciiStringResourceImpl() : data_(0), length_(0) {}
2494
+ ExternalAsciiStringResourceImpl(const char* data, size_t length)
2495
+ : data_(data), length_(length) {}
2496
+ const char* data() const { return data_; }
2497
+ size_t length() const { return length_; }
2498
+
2499
+ private:
2500
+ const char* data_;
2501
+ size_t length_;
2502
+ };
2503
+
2504
+ /**
2505
+ * Ignore
2506
+ */
2507
+ class V8EXPORT Extension { // NOLINT
2508
+ public:
2509
+ // Note that the strings passed into this constructor must live as long
2510
+ // as the Extension itself.
2511
+ Extension(const char* name,
2512
+ const char* source = 0,
2513
+ int dep_count = 0,
2514
+ const char** deps = 0,
2515
+ int source_length = -1);
2516
+ virtual ~Extension() { }
2517
+ virtual v8::Handle<v8::FunctionTemplate>
2518
+ GetNativeFunction(v8::Handle<v8::String> name) {
2519
+ return v8::Handle<v8::FunctionTemplate>();
2520
+ }
2521
+
2522
+ const char* name() const { return name_; }
2523
+ size_t source_length() const { return source_length_; }
2524
+ const String::ExternalAsciiStringResource* source() const {
2525
+ return &source_; }
2526
+ int dependency_count() { return dep_count_; }
2527
+ const char** dependencies() { return deps_; }
2528
+ void set_auto_enable(bool value) { auto_enable_ = value; }
2529
+ bool auto_enable() { return auto_enable_; }
2530
+
2531
+ private:
2532
+ const char* name_;
2533
+ size_t source_length_; // expected to initialize before source_
2534
+ ExternalAsciiStringResourceImpl source_;
2535
+ int dep_count_;
2536
+ const char** deps_;
2537
+ bool auto_enable_;
2538
+
2539
+ // Disallow copying and assigning.
2540
+ Extension(const Extension&);
2541
+ void operator=(const Extension&);
2542
+ };
2543
+
2544
+
2545
+ void V8EXPORT RegisterExtension(Extension* extension);
2546
+
2547
+
2548
+ /**
2549
+ * Ignore
2550
+ */
2551
+ class V8EXPORT DeclareExtension {
2552
+ public:
2553
+ inline DeclareExtension(Extension* extension) {
2554
+ RegisterExtension(extension);
2555
+ }
2556
+ };
2557
+
2558
+
2559
+ // --- Statics ---
2560
+
2561
+
2562
+ Handle<Primitive> V8EXPORT Undefined();
2563
+ Handle<Primitive> V8EXPORT Null();
2564
+ Handle<Boolean> V8EXPORT True();
2565
+ Handle<Boolean> V8EXPORT False();
2566
+
2567
+ inline Handle<Primitive> Undefined(Isolate* isolate);
2568
+ inline Handle<Primitive> Null(Isolate* isolate);
2569
+ inline Handle<Boolean> True(Isolate* isolate);
2570
+ inline Handle<Boolean> False(Isolate* isolate);
2571
+
2572
+
2573
+ /**
2574
+ * A set of constraints that specifies the limits of the runtime's memory use.
2575
+ * You must set the heap size before initializing the VM - the size cannot be
2576
+ * adjusted after the VM is initialized.
2577
+ *
2578
+ * If you are using threads then you should hold the V8::Locker lock while
2579
+ * setting the stack limit and you must set a non-default stack limit separately
2580
+ * for each thread.
2581
+ */
2582
+ class V8EXPORT ResourceConstraints {
2583
+ public:
2584
+ ResourceConstraints();
2585
+ int max_young_space_size() const { return max_young_space_size_; }
2586
+ void set_max_young_space_size(int value) { max_young_space_size_ = value; }
2587
+ int max_old_space_size() const { return max_old_space_size_; }
2588
+ void set_max_old_space_size(int value) { max_old_space_size_ = value; }
2589
+ int max_executable_size() { return max_executable_size_; }
2590
+ void set_max_executable_size(int value) { max_executable_size_ = value; }
2591
+ uint32_t* stack_limit() const { return stack_limit_; }
2592
+ // Sets an address beyond which the VM's stack may not grow.
2593
+ void set_stack_limit(uint32_t* value) { stack_limit_ = value; }
2594
+ private:
2595
+ int max_young_space_size_;
2596
+ int max_old_space_size_;
2597
+ int max_executable_size_;
2598
+ uint32_t* stack_limit_;
2599
+ };
2600
+
2601
+
2602
+ bool V8EXPORT SetResourceConstraints(ResourceConstraints* constraints);
2603
+
2604
+
2605
+ // --- Exceptions ---
2606
+
2607
+
2608
+ typedef void (*FatalErrorCallback)(const char* location, const char* message);
2609
+
2610
+
2611
+ typedef void (*MessageCallback)(Handle<Message> message, Handle<Value> data);
2612
+
2613
+
2614
+ /**
2615
+ * Schedules an exception to be thrown when returning to JavaScript. When an
2616
+ * exception has been scheduled it is illegal to invoke any JavaScript
2617
+ * operation; the caller must return immediately and only after the exception
2618
+ * has been handled does it become legal to invoke JavaScript operations.
2619
+ */
2620
+ Handle<Value> V8EXPORT ThrowException(Handle<Value> exception);
2621
+
2622
+ /**
2623
+ * Create new error objects by calling the corresponding error object
2624
+ * constructor with the message.
2625
+ */
2626
+ class V8EXPORT Exception {
2627
+ public:
2628
+ static Local<Value> RangeError(Handle<String> message);
2629
+ static Local<Value> ReferenceError(Handle<String> message);
2630
+ static Local<Value> SyntaxError(Handle<String> message);
2631
+ static Local<Value> TypeError(Handle<String> message);
2632
+ static Local<Value> Error(Handle<String> message);
2633
+ };
2634
+
2635
+
2636
+ // --- Counters Callbacks ---
2637
+
2638
+ typedef int* (*CounterLookupCallback)(const char* name);
2639
+
2640
+ typedef void* (*CreateHistogramCallback)(const char* name,
2641
+ int min,
2642
+ int max,
2643
+ size_t buckets);
2644
+
2645
+ typedef void (*AddHistogramSampleCallback)(void* histogram, int sample);
2646
+
2647
+ // --- Memory Allocation Callback ---
2648
+ enum ObjectSpace {
2649
+ kObjectSpaceNewSpace = 1 << 0,
2650
+ kObjectSpaceOldPointerSpace = 1 << 1,
2651
+ kObjectSpaceOldDataSpace = 1 << 2,
2652
+ kObjectSpaceCodeSpace = 1 << 3,
2653
+ kObjectSpaceMapSpace = 1 << 4,
2654
+ kObjectSpaceLoSpace = 1 << 5,
2655
+
2656
+ kObjectSpaceAll = kObjectSpaceNewSpace | kObjectSpaceOldPointerSpace |
2657
+ kObjectSpaceOldDataSpace | kObjectSpaceCodeSpace | kObjectSpaceMapSpace |
2658
+ kObjectSpaceLoSpace
2659
+ };
2660
+
2661
+ enum AllocationAction {
2662
+ kAllocationActionAllocate = 1 << 0,
2663
+ kAllocationActionFree = 1 << 1,
2664
+ kAllocationActionAll = kAllocationActionAllocate | kAllocationActionFree
2665
+ };
2666
+
2667
+ typedef void (*MemoryAllocationCallback)(ObjectSpace space,
2668
+ AllocationAction action,
2669
+ int size);
2670
+
2671
+ // --- Leave Script Callback ---
2672
+ typedef void (*CallCompletedCallback)();
2673
+
2674
+ // --- Failed Access Check Callback ---
2675
+ typedef void (*FailedAccessCheckCallback)(Local<Object> target,
2676
+ AccessType type,
2677
+ Local<Value> data);
2678
+
2679
+ // --- AllowCodeGenerationFromStrings callbacks ---
2680
+
2681
+ /**
2682
+ * Callback to check if code generation from strings is allowed. See
2683
+ * Context::AllowCodeGenerationFromStrings.
2684
+ */
2685
+ typedef bool (*AllowCodeGenerationFromStringsCallback)(Local<Context> context);
2686
+
2687
+ // --- Garbage Collection Callbacks ---
2688
+
2689
+ /**
2690
+ * Applications can register callback functions which will be called
2691
+ * before and after a garbage collection. Allocations are not
2692
+ * allowed in the callback functions, you therefore cannot manipulate
2693
+ * objects (set or delete properties for example) since it is possible
2694
+ * such operations will result in the allocation of objects.
2695
+ */
2696
+ enum GCType {
2697
+ kGCTypeScavenge = 1 << 0,
2698
+ kGCTypeMarkSweepCompact = 1 << 1,
2699
+ kGCTypeAll = kGCTypeScavenge | kGCTypeMarkSweepCompact
2700
+ };
2701
+
2702
+ enum GCCallbackFlags {
2703
+ kNoGCCallbackFlags = 0,
2704
+ kGCCallbackFlagCompacted = 1 << 0
2705
+ };
2706
+
2707
+ typedef void (*GCPrologueCallback)(GCType type, GCCallbackFlags flags);
2708
+ typedef void (*GCEpilogueCallback)(GCType type, GCCallbackFlags flags);
2709
+
2710
+ typedef void (*GCCallback)();
2711
+
2712
+
2713
+ /**
2714
+ * Collection of V8 heap information.
2715
+ *
2716
+ * Instances of this class can be passed to v8::V8::HeapStatistics to
2717
+ * get heap statistics from V8.
2718
+ */
2719
+ class V8EXPORT HeapStatistics {
2720
+ public:
2721
+ HeapStatistics();
2722
+ size_t total_heap_size() { return total_heap_size_; }
2723
+ size_t total_heap_size_executable() { return total_heap_size_executable_; }
2724
+ size_t used_heap_size() { return used_heap_size_; }
2725
+ size_t heap_size_limit() { return heap_size_limit_; }
2726
+
2727
+ private:
2728
+ void set_total_heap_size(size_t size) { total_heap_size_ = size; }
2729
+ void set_total_heap_size_executable(size_t size) {
2730
+ total_heap_size_executable_ = size;
2731
+ }
2732
+ void set_used_heap_size(size_t size) { used_heap_size_ = size; }
2733
+ void set_heap_size_limit(size_t size) { heap_size_limit_ = size; }
2734
+
2735
+ size_t total_heap_size_;
2736
+ size_t total_heap_size_executable_;
2737
+ size_t used_heap_size_;
2738
+ size_t heap_size_limit_;
2739
+
2740
+ friend class V8;
2741
+ };
2742
+
2743
+
2744
+ class RetainedObjectInfo;
2745
+
2746
+ /**
2747
+ * Isolate represents an isolated instance of the V8 engine. V8
2748
+ * isolates have completely separate states. Objects from one isolate
2749
+ * must not be used in other isolates. When V8 is initialized a
2750
+ * default isolate is implicitly created and entered. The embedder
2751
+ * can create additional isolates and use them in parallel in multiple
2752
+ * threads. An isolate can be entered by at most one thread at any
2753
+ * given time. The Locker/Unlocker API must be used to synchronize.
2754
+ */
2755
+ class V8EXPORT Isolate {
2756
+ public:
2757
+ /**
2758
+ * Stack-allocated class which sets the isolate for all operations
2759
+ * executed within a local scope.
2760
+ */
2761
+ class V8EXPORT Scope {
2762
+ public:
2763
+ explicit Scope(Isolate* isolate) : isolate_(isolate) {
2764
+ isolate->Enter();
2765
+ }
2766
+
2767
+ ~Scope() { isolate_->Exit(); }
2768
+
2769
+ private:
2770
+ Isolate* const isolate_;
2771
+
2772
+ // Prevent copying of Scope objects.
2773
+ Scope(const Scope&);
2774
+ Scope& operator=(const Scope&);
2775
+ };
2776
+
2777
+ /**
2778
+ * Creates a new isolate. Does not change the currently entered
2779
+ * isolate.
2780
+ *
2781
+ * When an isolate is no longer used its resources should be freed
2782
+ * by calling Dispose(). Using the delete operator is not allowed.
2783
+ */
2784
+ static Isolate* New();
2785
+
2786
+ /**
2787
+ * Returns the entered isolate for the current thread or NULL in
2788
+ * case there is no current isolate.
2789
+ */
2790
+ static Isolate* GetCurrent();
2791
+
2792
+ /**
2793
+ * Methods below this point require holding a lock (using Locker) in
2794
+ * a multi-threaded environment.
2795
+ */
2796
+
2797
+ /**
2798
+ * Sets this isolate as the entered one for the current thread.
2799
+ * Saves the previously entered one (if any), so that it can be
2800
+ * restored when exiting. Re-entering an isolate is allowed.
2801
+ */
2802
+ void Enter();
2803
+
2804
+ /**
2805
+ * Exits this isolate by restoring the previously entered one in the
2806
+ * current thread. The isolate may still stay the same, if it was
2807
+ * entered more than once.
2808
+ *
2809
+ * Requires: this == Isolate::GetCurrent().
2810
+ */
2811
+ void Exit();
2812
+
2813
+ /**
2814
+ * Disposes the isolate. The isolate must not be entered by any
2815
+ * thread to be disposable.
2816
+ */
2817
+ void Dispose();
2818
+
2819
+ /**
2820
+ * Associate embedder-specific data with the isolate
2821
+ */
2822
+ inline void SetData(void* data);
2823
+
2824
+ /**
2825
+ * Retrieve embedder-specific data from the isolate.
2826
+ * Returns NULL if SetData has never been called.
2827
+ */
2828
+ inline void* GetData();
2829
+
2830
+ private:
2831
+ Isolate();
2832
+ Isolate(const Isolate&);
2833
+ ~Isolate();
2834
+ Isolate& operator=(const Isolate&);
2835
+ void* operator new(size_t size);
2836
+ void operator delete(void*, size_t);
2837
+ };
2838
+
2839
+
2840
+ class StartupData {
2841
+ public:
2842
+ enum CompressionAlgorithm {
2843
+ kUncompressed,
2844
+ kBZip2
2845
+ };
2846
+
2847
+ const char* data;
2848
+ int compressed_size;
2849
+ int raw_size;
2850
+ };
2851
+
2852
+
2853
+ /**
2854
+ * A helper class for driving V8 startup data decompression. It is based on
2855
+ * "CompressedStartupData" API functions from the V8 class. It isn't mandatory
2856
+ * for an embedder to use this class, instead, API functions can be used
2857
+ * directly.
2858
+ *
2859
+ * For an example of the class usage, see the "shell.cc" sample application.
2860
+ */
2861
+ class V8EXPORT StartupDataDecompressor { // NOLINT
2862
+ public:
2863
+ StartupDataDecompressor();
2864
+ virtual ~StartupDataDecompressor();
2865
+ int Decompress();
2866
+
2867
+ protected:
2868
+ virtual int DecompressData(char* raw_data,
2869
+ int* raw_data_size,
2870
+ const char* compressed_data,
2871
+ int compressed_data_size) = 0;
2872
+
2873
+ private:
2874
+ char** raw_data;
2875
+ };
2876
+
2877
+
2878
+ /**
2879
+ * EntropySource is used as a callback function when v8 needs a source
2880
+ * of entropy.
2881
+ */
2882
+ typedef bool (*EntropySource)(unsigned char* buffer, size_t length);
2883
+
2884
+
2885
+ /**
2886
+ * ReturnAddressLocationResolver is used as a callback function when v8 is
2887
+ * resolving the location of a return address on the stack. Profilers that
2888
+ * change the return address on the stack can use this to resolve the stack
2889
+ * location to whereever the profiler stashed the original return address.
2890
+ * When invoked, return_addr_location will point to a location on stack where
2891
+ * a machine return address resides, this function should return either the
2892
+ * same pointer, or a pointer to the profiler's copy of the original return
2893
+ * address.
2894
+ */
2895
+ typedef uintptr_t (*ReturnAddressLocationResolver)(
2896
+ uintptr_t return_addr_location);
2897
+
2898
+
2899
+ /**
2900
+ * Interface for iterating though all external resources in the heap.
2901
+ */
2902
+ class V8EXPORT ExternalResourceVisitor { // NOLINT
2903
+ public:
2904
+ virtual ~ExternalResourceVisitor() {}
2905
+ virtual void VisitExternalString(Handle<String> string) {}
2906
+ };
2907
+
2908
+
2909
+ /**
2910
+ * Container class for static utility functions.
2911
+ */
2912
+ class V8EXPORT V8 {
2913
+ public:
2914
+ /** Set the callback to invoke in case of fatal errors. */
2915
+ static void SetFatalErrorHandler(FatalErrorCallback that);
2916
+
2917
+ /**
2918
+ * Set the callback to invoke to check if code generation from
2919
+ * strings should be allowed.
2920
+ */
2921
+ static void SetAllowCodeGenerationFromStringsCallback(
2922
+ AllowCodeGenerationFromStringsCallback that);
2923
+
2924
+ /**
2925
+ * Ignore out-of-memory exceptions.
2926
+ *
2927
+ * V8 running out of memory is treated as a fatal error by default.
2928
+ * This means that the fatal error handler is called and that V8 is
2929
+ * terminated.
2930
+ *
2931
+ * IgnoreOutOfMemoryException can be used to not treat an
2932
+ * out-of-memory situation as a fatal error. This way, the contexts
2933
+ * that did not cause the out of memory problem might be able to
2934
+ * continue execution.
2935
+ */
2936
+ static void IgnoreOutOfMemoryException();
2937
+
2938
+ /**
2939
+ * Check if V8 is dead and therefore unusable. This is the case after
2940
+ * fatal errors such as out-of-memory situations.
2941
+ */
2942
+ static bool IsDead();
2943
+
2944
+ /**
2945
+ * The following 4 functions are to be used when V8 is built with
2946
+ * the 'compress_startup_data' flag enabled. In this case, the
2947
+ * embedder must decompress startup data prior to initializing V8.
2948
+ *
2949
+ * This is how interaction with V8 should look like:
2950
+ * int compressed_data_count = v8::V8::GetCompressedStartupDataCount();
2951
+ * v8::StartupData* compressed_data =
2952
+ * new v8::StartupData[compressed_data_count];
2953
+ * v8::V8::GetCompressedStartupData(compressed_data);
2954
+ * ... decompress data (compressed_data can be updated in-place) ...
2955
+ * v8::V8::SetDecompressedStartupData(compressed_data);
2956
+ * ... now V8 can be initialized
2957
+ * ... make sure the decompressed data stays valid until V8 shutdown
2958
+ *
2959
+ * A helper class StartupDataDecompressor is provided. It implements
2960
+ * the protocol of the interaction described above, and can be used in
2961
+ * most cases instead of calling these API functions directly.
2962
+ */
2963
+ static StartupData::CompressionAlgorithm GetCompressedStartupDataAlgorithm();
2964
+ static int GetCompressedStartupDataCount();
2965
+ static void GetCompressedStartupData(StartupData* compressed_data);
2966
+ static void SetDecompressedStartupData(StartupData* decompressed_data);
2967
+
2968
+ /**
2969
+ * Adds a message listener.
2970
+ *
2971
+ * The same message listener can be added more than once and in that
2972
+ * case it will be called more than once for each message.
2973
+ */
2974
+ static bool AddMessageListener(MessageCallback that,
2975
+ Handle<Value> data = Handle<Value>());
2976
+
2977
+ /**
2978
+ * Remove all message listeners from the specified callback function.
2979
+ */
2980
+ static void RemoveMessageListeners(MessageCallback that);
2981
+
2982
+ /**
2983
+ * Tells V8 to capture current stack trace when uncaught exception occurs
2984
+ * and report it to the message listeners. The option is off by default.
2985
+ */
2986
+ static void SetCaptureStackTraceForUncaughtExceptions(
2987
+ bool capture,
2988
+ int frame_limit = 10,
2989
+ StackTrace::StackTraceOptions options = StackTrace::kOverview);
2990
+
2991
+ /**
2992
+ * Sets V8 flags from a string.
2993
+ */
2994
+ static void SetFlagsFromString(const char* str, int length);
2995
+
2996
+ /**
2997
+ * Sets V8 flags from the command line.
2998
+ */
2999
+ static void SetFlagsFromCommandLine(int* argc,
3000
+ char** argv,
3001
+ bool remove_flags);
3002
+
3003
+ /** Get the version string. */
3004
+ static const char* GetVersion();
3005
+
3006
+ /**
3007
+ * Enables the host application to provide a mechanism for recording
3008
+ * statistics counters.
3009
+ */
3010
+ static void SetCounterFunction(CounterLookupCallback);
3011
+
3012
+ /**
3013
+ * Enables the host application to provide a mechanism for recording
3014
+ * histograms. The CreateHistogram function returns a
3015
+ * histogram which will later be passed to the AddHistogramSample
3016
+ * function.
3017
+ */
3018
+ static void SetCreateHistogramFunction(CreateHistogramCallback);
3019
+ static void SetAddHistogramSampleFunction(AddHistogramSampleCallback);
3020
+
3021
+ /**
3022
+ * Enables the computation of a sliding window of states. The sliding
3023
+ * window information is recorded in statistics counters.
3024
+ */
3025
+ static void EnableSlidingStateWindow();
3026
+
3027
+ /** Callback function for reporting failed access checks.*/
3028
+ static void SetFailedAccessCheckCallbackFunction(FailedAccessCheckCallback);
3029
+
3030
+ /**
3031
+ * Enables the host application to receive a notification before a
3032
+ * garbage collection. Allocations are not allowed in the
3033
+ * callback function, you therefore cannot manipulate objects (set
3034
+ * or delete properties for example) since it is possible such
3035
+ * operations will result in the allocation of objects. It is possible
3036
+ * to specify the GCType filter for your callback. But it is not possible to
3037
+ * register the same callback function two times with different
3038
+ * GCType filters.
3039
+ */
3040
+ static void AddGCPrologueCallback(
3041
+ GCPrologueCallback callback, GCType gc_type_filter = kGCTypeAll);
3042
+
3043
+ /**
3044
+ * This function removes callback which was installed by
3045
+ * AddGCPrologueCallback function.
3046
+ */
3047
+ static void RemoveGCPrologueCallback(GCPrologueCallback callback);
3048
+
3049
+ /**
3050
+ * The function is deprecated. Please use AddGCPrologueCallback instead.
3051
+ * Enables the host application to receive a notification before a
3052
+ * garbage collection. Allocations are not allowed in the
3053
+ * callback function, you therefore cannot manipulate objects (set
3054
+ * or delete properties for example) since it is possible such
3055
+ * operations will result in the allocation of objects.
3056
+ */
3057
+ static void SetGlobalGCPrologueCallback(GCCallback);
3058
+
3059
+ /**
3060
+ * Enables the host application to receive a notification after a
3061
+ * garbage collection. Allocations are not allowed in the
3062
+ * callback function, you therefore cannot manipulate objects (set
3063
+ * or delete properties for example) since it is possible such
3064
+ * operations will result in the allocation of objects. It is possible
3065
+ * to specify the GCType filter for your callback. But it is not possible to
3066
+ * register the same callback function two times with different
3067
+ * GCType filters.
3068
+ */
3069
+ static void AddGCEpilogueCallback(
3070
+ GCEpilogueCallback callback, GCType gc_type_filter = kGCTypeAll);
3071
+
3072
+ /**
3073
+ * This function removes callback which was installed by
3074
+ * AddGCEpilogueCallback function.
3075
+ */
3076
+ static void RemoveGCEpilogueCallback(GCEpilogueCallback callback);
3077
+
3078
+ /**
3079
+ * The function is deprecated. Please use AddGCEpilogueCallback instead.
3080
+ * Enables the host application to receive a notification after a
3081
+ * major garbage collection. Allocations are not allowed in the
3082
+ * callback function, you therefore cannot manipulate objects (set
3083
+ * or delete properties for example) since it is possible such
3084
+ * operations will result in the allocation of objects.
3085
+ */
3086
+ static void SetGlobalGCEpilogueCallback(GCCallback);
3087
+
3088
+ /**
3089
+ * Enables the host application to provide a mechanism to be notified
3090
+ * and perform custom logging when V8 Allocates Executable Memory.
3091
+ */
3092
+ static void AddMemoryAllocationCallback(MemoryAllocationCallback callback,
3093
+ ObjectSpace space,
3094
+ AllocationAction action);
3095
+
3096
+ /**
3097
+ * Removes callback that was installed by AddMemoryAllocationCallback.
3098
+ */
3099
+ static void RemoveMemoryAllocationCallback(MemoryAllocationCallback callback);
3100
+
3101
+ /**
3102
+ * Adds a callback to notify the host application when a script finished
3103
+ * running. If a script re-enters the runtime during executing, the
3104
+ * CallCompletedCallback is only invoked when the outer-most script
3105
+ * execution ends. Executing scripts inside the callback do not trigger
3106
+ * further callbacks.
3107
+ */
3108
+ static void AddCallCompletedCallback(CallCompletedCallback callback);
3109
+
3110
+ /**
3111
+ * Removes callback that was installed by AddCallCompletedCallback.
3112
+ */
3113
+ static void RemoveCallCompletedCallback(CallCompletedCallback callback);
3114
+
3115
+ /**
3116
+ * Allows the host application to group objects together. If one
3117
+ * object in the group is alive, all objects in the group are alive.
3118
+ * After each garbage collection, object groups are removed. It is
3119
+ * intended to be used in the before-garbage-collection callback
3120
+ * function, for instance to simulate DOM tree connections among JS
3121
+ * wrapper objects.
3122
+ * See v8-profiler.h for RetainedObjectInfo interface description.
3123
+ */
3124
+ static void AddObjectGroup(Persistent<Value>* objects,
3125
+ size_t length,
3126
+ RetainedObjectInfo* info = NULL);
3127
+
3128
+ /**
3129
+ * Allows the host application to declare implicit references between
3130
+ * the objects: if |parent| is alive, all |children| are alive too.
3131
+ * After each garbage collection, all implicit references
3132
+ * are removed. It is intended to be used in the before-garbage-collection
3133
+ * callback function.
3134
+ */
3135
+ static void AddImplicitReferences(Persistent<Object> parent,
3136
+ Persistent<Value>* children,
3137
+ size_t length);
3138
+
3139
+ /**
3140
+ * Initializes from snapshot if possible. Otherwise, attempts to
3141
+ * initialize from scratch. This function is called implicitly if
3142
+ * you use the API without calling it first.
3143
+ */
3144
+ static bool Initialize();
3145
+
3146
+ /**
3147
+ * Allows the host application to provide a callback which can be used
3148
+ * as a source of entropy for random number generators.
3149
+ */
3150
+ static void SetEntropySource(EntropySource source);
3151
+
3152
+ /**
3153
+ * Allows the host application to provide a callback that allows v8 to
3154
+ * cooperate with a profiler that rewrites return addresses on stack.
3155
+ */
3156
+ static void SetReturnAddressLocationResolver(
3157
+ ReturnAddressLocationResolver return_address_resolver);
3158
+
3159
+ /**
3160
+ * Adjusts the amount of registered external memory. Used to give
3161
+ * V8 an indication of the amount of externally allocated memory
3162
+ * that is kept alive by JavaScript objects. V8 uses this to decide
3163
+ * when to perform global garbage collections. Registering
3164
+ * externally allocated memory will trigger global garbage
3165
+ * collections more often than otherwise in an attempt to garbage
3166
+ * collect the JavaScript objects keeping the externally allocated
3167
+ * memory alive.
3168
+ *
3169
+ * \param change_in_bytes the change in externally allocated memory
3170
+ * that is kept alive by JavaScript objects.
3171
+ * \returns the adjusted value.
3172
+ */
3173
+ static intptr_t AdjustAmountOfExternalAllocatedMemory(
3174
+ intptr_t change_in_bytes);
3175
+
3176
+ /**
3177
+ * Suspends recording of tick samples in the profiler.
3178
+ * When the V8 profiling mode is enabled (usually via command line
3179
+ * switches) this function suspends recording of tick samples.
3180
+ * Profiling ticks are discarded until ResumeProfiler() is called.
3181
+ *
3182
+ * See also the --prof and --prof_auto command line switches to
3183
+ * enable V8 profiling.
3184
+ */
3185
+ static void PauseProfiler();
3186
+
3187
+ /**
3188
+ * Resumes recording of tick samples in the profiler.
3189
+ * See also PauseProfiler().
3190
+ */
3191
+ static void ResumeProfiler();
3192
+
3193
+ /**
3194
+ * Return whether profiler is currently paused.
3195
+ */
3196
+ static bool IsProfilerPaused();
3197
+
3198
+ /**
3199
+ * Retrieve the V8 thread id of the calling thread.
3200
+ *
3201
+ * The thread id for a thread should only be retrieved after the V8
3202
+ * lock has been acquired with a Locker object with that thread.
3203
+ */
3204
+ static int GetCurrentThreadId();
3205
+
3206
+ /**
3207
+ * Forcefully terminate execution of a JavaScript thread. This can
3208
+ * be used to terminate long-running scripts.
3209
+ *
3210
+ * TerminateExecution should only be called when then V8 lock has
3211
+ * been acquired with a Locker object. Therefore, in order to be
3212
+ * able to terminate long-running threads, preemption must be
3213
+ * enabled to allow the user of TerminateExecution to acquire the
3214
+ * lock.
3215
+ *
3216
+ * The termination is achieved by throwing an exception that is
3217
+ * uncatchable by JavaScript exception handlers. Termination
3218
+ * exceptions act as if they were caught by a C++ TryCatch exception
3219
+ * handler. If forceful termination is used, any C++ TryCatch
3220
+ * exception handler that catches an exception should check if that
3221
+ * exception is a termination exception and immediately return if
3222
+ * that is the case. Returning immediately in that case will
3223
+ * continue the propagation of the termination exception if needed.
3224
+ *
3225
+ * The thread id passed to TerminateExecution must have been
3226
+ * obtained by calling GetCurrentThreadId on the thread in question.
3227
+ *
3228
+ * \param thread_id The thread id of the thread to terminate.
3229
+ */
3230
+ static void TerminateExecution(int thread_id);
3231
+
3232
+ /**
3233
+ * Forcefully terminate the current thread of JavaScript execution
3234
+ * in the given isolate. If no isolate is provided, the default
3235
+ * isolate is used.
3236
+ *
3237
+ * This method can be used by any thread even if that thread has not
3238
+ * acquired the V8 lock with a Locker object.
3239
+ *
3240
+ * \param isolate The isolate in which to terminate the current JS execution.
3241
+ */
3242
+ static void TerminateExecution(Isolate* isolate = NULL);
3243
+
3244
+ /**
3245
+ * Is V8 terminating JavaScript execution.
3246
+ *
3247
+ * Returns true if JavaScript execution is currently terminating
3248
+ * because of a call to TerminateExecution. In that case there are
3249
+ * still JavaScript frames on the stack and the termination
3250
+ * exception is still active.
3251
+ *
3252
+ * \param isolate The isolate in which to check.
3253
+ */
3254
+ static bool IsExecutionTerminating(Isolate* isolate = NULL);
3255
+
3256
+ /**
3257
+ * Releases any resources used by v8 and stops any utility threads
3258
+ * that may be running. Note that disposing v8 is permanent, it
3259
+ * cannot be reinitialized.
3260
+ *
3261
+ * It should generally not be necessary to dispose v8 before exiting
3262
+ * a process, this should happen automatically. It is only necessary
3263
+ * to use if the process needs the resources taken up by v8.
3264
+ */
3265
+ static bool Dispose();
3266
+
3267
+ /**
3268
+ * Get statistics about the heap memory usage.
3269
+ */
3270
+ static void GetHeapStatistics(HeapStatistics* heap_statistics);
3271
+
3272
+ /**
3273
+ * Iterates through all external resources referenced from current isolate
3274
+ * heap. This method is not expected to be used except for debugging purposes
3275
+ * and may be quite slow.
3276
+ */
3277
+ static void VisitExternalResources(ExternalResourceVisitor* visitor);
3278
+
3279
+ /**
3280
+ * Optional notification that the embedder is idle.
3281
+ * V8 uses the notification to reduce memory footprint.
3282
+ * This call can be used repeatedly if the embedder remains idle.
3283
+ * Returns true if the embedder should stop calling IdleNotification
3284
+ * until real work has been done. This indicates that V8 has done
3285
+ * as much cleanup as it will be able to do.
3286
+ *
3287
+ * The hint argument specifies the amount of work to be done in the function
3288
+ * on scale from 1 to 1000. There is no guarantee that the actual work will
3289
+ * match the hint.
3290
+ */
3291
+ static bool IdleNotification(int hint = 1000);
3292
+
3293
+ /**
3294
+ * Optional notification that the system is running low on memory.
3295
+ * V8 uses these notifications to attempt to free memory.
3296
+ */
3297
+ static void LowMemoryNotification();
3298
+
3299
+ /**
3300
+ * Optional notification that a context has been disposed. V8 uses
3301
+ * these notifications to guide the GC heuristic. Returns the number
3302
+ * of context disposals - including this one - since the last time
3303
+ * V8 had a chance to clean up.
3304
+ */
3305
+ static int ContextDisposedNotification();
3306
+
3307
+ private:
3308
+ V8();
3309
+
3310
+ static internal::Object** GlobalizeReference(internal::Object** handle);
3311
+ static void DisposeGlobal(internal::Object** global_handle);
3312
+ static void MakeWeak(internal::Object** global_handle,
3313
+ void* data,
3314
+ WeakReferenceCallback);
3315
+ static void ClearWeak(internal::Object** global_handle);
3316
+ static void MarkIndependent(internal::Object** global_handle);
3317
+ static bool IsGlobalNearDeath(internal::Object** global_handle);
3318
+ static bool IsGlobalWeak(internal::Object** global_handle);
3319
+ static void SetWrapperClassId(internal::Object** global_handle,
3320
+ uint16_t class_id);
3321
+
3322
+ template <class T> friend class Handle;
3323
+ template <class T> friend class Local;
3324
+ template <class T> friend class Persistent;
3325
+ friend class Context;
3326
+ };
3327
+
3328
+
3329
+ /**
3330
+ * An external exception handler.
3331
+ */
3332
+ class V8EXPORT TryCatch {
3333
+ public:
3334
+ /**
3335
+ * Creates a new try/catch block and registers it with v8.
3336
+ */
3337
+ TryCatch();
3338
+
3339
+ /**
3340
+ * Unregisters and deletes this try/catch block.
3341
+ */
3342
+ ~TryCatch();
3343
+
3344
+ /**
3345
+ * Returns true if an exception has been caught by this try/catch block.
3346
+ */
3347
+ bool HasCaught() const;
3348
+
3349
+ /**
3350
+ * For certain types of exceptions, it makes no sense to continue
3351
+ * execution.
3352
+ *
3353
+ * Currently, the only type of exception that can be caught by a
3354
+ * TryCatch handler and for which it does not make sense to continue
3355
+ * is termination exception. Such exceptions are thrown when the
3356
+ * TerminateExecution methods are called to terminate a long-running
3357
+ * script.
3358
+ *
3359
+ * If CanContinue returns false, the correct action is to perform
3360
+ * any C++ cleanup needed and then return.
3361
+ */
3362
+ bool CanContinue() const;
3363
+
3364
+ /**
3365
+ * Throws the exception caught by this TryCatch in a way that avoids
3366
+ * it being caught again by this same TryCatch. As with ThrowException
3367
+ * it is illegal to execute any JavaScript operations after calling
3368
+ * ReThrow; the caller must return immediately to where the exception
3369
+ * is caught.
3370
+ */
3371
+ Handle<Value> ReThrow();
3372
+
3373
+ /**
3374
+ * Returns the exception caught by this try/catch block. If no exception has
3375
+ * been caught an empty handle is returned.
3376
+ *
3377
+ * The returned handle is valid until this TryCatch block has been destroyed.
3378
+ */
3379
+ Local<Value> Exception() const;
3380
+
3381
+ /**
3382
+ * Returns the .stack property of the thrown object. If no .stack
3383
+ * property is present an empty handle is returned.
3384
+ */
3385
+ Local<Value> StackTrace() const;
3386
+
3387
+ /**
3388
+ * Returns the message associated with this exception. If there is
3389
+ * no message associated an empty handle is returned.
3390
+ *
3391
+ * The returned handle is valid until this TryCatch block has been
3392
+ * destroyed.
3393
+ */
3394
+ Local<v8::Message> Message() const;
3395
+
3396
+ /**
3397
+ * Clears any exceptions that may have been caught by this try/catch block.
3398
+ * After this method has been called, HasCaught() will return false.
3399
+ *
3400
+ * It is not necessary to clear a try/catch block before using it again; if
3401
+ * another exception is thrown the previously caught exception will just be
3402
+ * overwritten. However, it is often a good idea since it makes it easier
3403
+ * to determine which operation threw a given exception.
3404
+ */
3405
+ void Reset();
3406
+
3407
+ /**
3408
+ * Set verbosity of the external exception handler.
3409
+ *
3410
+ * By default, exceptions that are caught by an external exception
3411
+ * handler are not reported. Call SetVerbose with true on an
3412
+ * external exception handler to have exceptions caught by the
3413
+ * handler reported as if they were not caught.
3414
+ */
3415
+ void SetVerbose(bool value);
3416
+
3417
+ /**
3418
+ * Set whether or not this TryCatch should capture a Message object
3419
+ * which holds source information about where the exception
3420
+ * occurred. True by default.
3421
+ */
3422
+ void SetCaptureMessage(bool value);
3423
+
3424
+ private:
3425
+ v8::internal::Isolate* isolate_;
3426
+ void* next_;
3427
+ void* exception_;
3428
+ void* message_;
3429
+ bool is_verbose_ : 1;
3430
+ bool can_continue_ : 1;
3431
+ bool capture_message_ : 1;
3432
+ bool rethrow_ : 1;
3433
+
3434
+ friend class v8::internal::Isolate;
3435
+ };
3436
+
3437
+
3438
+ // --- Context ---
3439
+
3440
+
3441
+ /**
3442
+ * Ignore
3443
+ */
3444
+ class V8EXPORT ExtensionConfiguration {
3445
+ public:
3446
+ ExtensionConfiguration(int name_count, const char* names[])
3447
+ : name_count_(name_count), names_(names) { }
3448
+ private:
3449
+ friend class ImplementationUtilities;
3450
+ int name_count_;
3451
+ const char** names_;
3452
+ };
3453
+
3454
+
3455
+ /**
3456
+ * A sandboxed execution context with its own set of built-in objects
3457
+ * and functions.
3458
+ */
3459
+ class V8EXPORT Context {
3460
+ public:
3461
+ /**
3462
+ * Returns the global proxy object or global object itself for
3463
+ * detached contexts.
3464
+ *
3465
+ * Global proxy object is a thin wrapper whose prototype points to
3466
+ * actual context's global object with the properties like Object, etc.
3467
+ * This is done that way for security reasons (for more details see
3468
+ * https://wiki.mozilla.org/Gecko:SplitWindow).
3469
+ *
3470
+ * Please note that changes to global proxy object prototype most probably
3471
+ * would break VM---v8 expects only global object as a prototype of
3472
+ * global proxy object.
3473
+ *
3474
+ * If DetachGlobal() has been invoked, Global() would return actual global
3475
+ * object until global is reattached with ReattachGlobal().
3476
+ */
3477
+ Local<Object> Global();
3478
+
3479
+ /**
3480
+ * Detaches the global object from its context before
3481
+ * the global object can be reused to create a new context.
3482
+ */
3483
+ void DetachGlobal();
3484
+
3485
+ /**
3486
+ * Reattaches a global object to a context. This can be used to
3487
+ * restore the connection between a global object and a context
3488
+ * after DetachGlobal has been called.
3489
+ *
3490
+ * \param global_object The global object to reattach to the
3491
+ * context. For this to work, the global object must be the global
3492
+ * object that was associated with this context before a call to
3493
+ * DetachGlobal.
3494
+ */
3495
+ void ReattachGlobal(Handle<Object> global_object);
3496
+
3497
+ /** Creates a new context.
3498
+ *
3499
+ * Returns a persistent handle to the newly allocated context. This
3500
+ * persistent handle has to be disposed when the context is no
3501
+ * longer used so the context can be garbage collected.
3502
+ *
3503
+ * \param extensions An optional extension configuration containing
3504
+ * the extensions to be installed in the newly created context.
3505
+ *
3506
+ * \param global_template An optional object template from which the
3507
+ * global object for the newly created context will be created.
3508
+ *
3509
+ * \param global_object An optional global object to be reused for
3510
+ * the newly created context. This global object must have been
3511
+ * created by a previous call to Context::New with the same global
3512
+ * template. The state of the global object will be completely reset
3513
+ * and only object identify will remain.
3514
+ */
3515
+ static Persistent<Context> New(
3516
+ ExtensionConfiguration* extensions = NULL,
3517
+ Handle<ObjectTemplate> global_template = Handle<ObjectTemplate>(),
3518
+ Handle<Value> global_object = Handle<Value>());
3519
+
3520
+ /** Returns the last entered context. */
3521
+ static Local<Context> GetEntered();
3522
+
3523
+ /** Returns the context that is on the top of the stack. */
3524
+ static Local<Context> GetCurrent();
3525
+
3526
+ /**
3527
+ * Returns the context of the calling JavaScript code. That is the
3528
+ * context of the top-most JavaScript frame. If there are no
3529
+ * JavaScript frames an empty handle is returned.
3530
+ */
3531
+ static Local<Context> GetCalling();
3532
+
3533
+ /**
3534
+ * Sets the security token for the context. To access an object in
3535
+ * another context, the security tokens must match.
3536
+ */
3537
+ void SetSecurityToken(Handle<Value> token);
3538
+
3539
+ /** Restores the security token to the default value. */
3540
+ void UseDefaultSecurityToken();
3541
+
3542
+ /** Returns the security token of this context.*/
3543
+ Handle<Value> GetSecurityToken();
3544
+
3545
+ /**
3546
+ * Enter this context. After entering a context, all code compiled
3547
+ * and run is compiled and run in this context. If another context
3548
+ * is already entered, this old context is saved so it can be
3549
+ * restored when the new context is exited.
3550
+ */
3551
+ void Enter();
3552
+
3553
+ /**
3554
+ * Exit this context. Exiting the current context restores the
3555
+ * context that was in place when entering the current context.
3556
+ */
3557
+ void Exit();
3558
+
3559
+ /** Returns true if the context has experienced an out of memory situation. */
3560
+ bool HasOutOfMemoryException();
3561
+
3562
+ /** Returns true if V8 has a current context. */
3563
+ static bool InContext();
3564
+
3565
+ /**
3566
+ * Associate an additional data object with the context. This is mainly used
3567
+ * with the debugger to provide additional information on the context through
3568
+ * the debugger API.
3569
+ */
3570
+ void SetData(Handle<String> data);
3571
+ Local<Value> GetData();
3572
+
3573
+ /**
3574
+ * Control whether code generation from strings is allowed. Calling
3575
+ * this method with false will disable 'eval' and the 'Function'
3576
+ * constructor for code running in this context. If 'eval' or the
3577
+ * 'Function' constructor are used an exception will be thrown.
3578
+ *
3579
+ * If code generation from strings is not allowed the
3580
+ * V8::AllowCodeGenerationFromStrings callback will be invoked if
3581
+ * set before blocking the call to 'eval' or the 'Function'
3582
+ * constructor. If that callback returns true, the call will be
3583
+ * allowed, otherwise an exception will be thrown. If no callback is
3584
+ * set an exception will be thrown.
3585
+ */
3586
+ void AllowCodeGenerationFromStrings(bool allow);
3587
+
3588
+ /**
3589
+ * Returns true if code generation from strings is allowed for the context.
3590
+ * For more details see AllowCodeGenerationFromStrings(bool) documentation.
3591
+ */
3592
+ bool IsCodeGenerationFromStringsAllowed();
3593
+
3594
+ /**
3595
+ * Stack-allocated class which sets the execution context for all
3596
+ * operations executed within a local scope.
3597
+ */
3598
+ class Scope {
3599
+ public:
3600
+ explicit inline Scope(Handle<Context> context) : context_(context) {
3601
+ context_->Enter();
3602
+ }
3603
+ inline ~Scope() { context_->Exit(); }
3604
+ private:
3605
+ Handle<Context> context_;
3606
+ };
3607
+
3608
+ private:
3609
+ friend class Value;
3610
+ friend class Script;
3611
+ friend class Object;
3612
+ friend class Function;
3613
+ };
3614
+
3615
+
3616
+ /**
3617
+ * Multiple threads in V8 are allowed, but only one thread at a time
3618
+ * is allowed to use any given V8 isolate. See Isolate class
3619
+ * comments. The definition of 'using V8 isolate' includes
3620
+ * accessing handles or holding onto object pointers obtained
3621
+ * from V8 handles while in the particular V8 isolate. It is up
3622
+ * to the user of V8 to ensure (perhaps with locking) that this
3623
+ * constraint is not violated. In addition to any other synchronization
3624
+ * mechanism that may be used, the v8::Locker and v8::Unlocker classes
3625
+ * must be used to signal thead switches to V8.
3626
+ *
3627
+ * v8::Locker is a scoped lock object. While it's
3628
+ * active (i.e. between its construction and destruction) the current thread is
3629
+ * allowed to use the locked isolate. V8 guarantees that an isolate can be
3630
+ * locked by at most one thread at any time. In other words, the scope of a
3631
+ * v8::Locker is a critical section.
3632
+ *
3633
+ * Sample usage:
3634
+ * \code
3635
+ * ...
3636
+ * {
3637
+ * v8::Locker locker(isolate);
3638
+ * v8::Isolate::Scope isolate_scope(isolate);
3639
+ * ...
3640
+ * // Code using V8 and isolate goes here.
3641
+ * ...
3642
+ * } // Destructor called here
3643
+ * \endcode
3644
+ *
3645
+ * If you wish to stop using V8 in a thread A you can do this either
3646
+ * by destroying the v8::Locker object as above or by constructing a
3647
+ * v8::Unlocker object:
3648
+ *
3649
+ * \code
3650
+ * {
3651
+ * isolate->Exit();
3652
+ * v8::Unlocker unlocker(isolate);
3653
+ * ...
3654
+ * // Code not using V8 goes here while V8 can run in another thread.
3655
+ * ...
3656
+ * } // Destructor called here.
3657
+ * isolate->Enter();
3658
+ * \endcode
3659
+ *
3660
+ * The Unlocker object is intended for use in a long-running callback
3661
+ * from V8, where you want to release the V8 lock for other threads to
3662
+ * use.
3663
+ *
3664
+ * The v8::Locker is a recursive lock. That is, you can lock more than
3665
+ * once in a given thread. This can be useful if you have code that can
3666
+ * be called either from code that holds the lock or from code that does
3667
+ * not. The Unlocker is not recursive so you can not have several
3668
+ * Unlockers on the stack at once, and you can not use an Unlocker in a
3669
+ * thread that is not inside a Locker's scope.
3670
+ *
3671
+ * An unlocker will unlock several lockers if it has to and reinstate
3672
+ * the correct depth of locking on its destruction. eg.:
3673
+ *
3674
+ * \code
3675
+ * // V8 not locked.
3676
+ * {
3677
+ * v8::Locker locker(isolate);
3678
+ * Isolate::Scope isolate_scope(isolate);
3679
+ * // V8 locked.
3680
+ * {
3681
+ * v8::Locker another_locker(isolate);
3682
+ * // V8 still locked (2 levels).
3683
+ * {
3684
+ * isolate->Exit();
3685
+ * v8::Unlocker unlocker(isolate);
3686
+ * // V8 not locked.
3687
+ * }
3688
+ * isolate->Enter();
3689
+ * // V8 locked again (2 levels).
3690
+ * }
3691
+ * // V8 still locked (1 level).
3692
+ * }
3693
+ * // V8 Now no longer locked.
3694
+ * \endcode
3695
+ *
3696
+ *
3697
+ */
3698
+ class V8EXPORT Unlocker {
3699
+ public:
3700
+ /**
3701
+ * Initialize Unlocker for a given Isolate. NULL means default isolate.
3702
+ */
3703
+ explicit Unlocker(Isolate* isolate = NULL);
3704
+ ~Unlocker();
3705
+ private:
3706
+ internal::Isolate* isolate_;
3707
+ };
3708
+
3709
+
3710
+ class V8EXPORT Locker {
3711
+ public:
3712
+ /**
3713
+ * Initialize Locker for a given Isolate. NULL means default isolate.
3714
+ */
3715
+ explicit Locker(Isolate* isolate = NULL);
3716
+ ~Locker();
3717
+
3718
+ /**
3719
+ * Start preemption.
3720
+ *
3721
+ * When preemption is started, a timer is fired every n milliseconds
3722
+ * that will switch between multiple threads that are in contention
3723
+ * for the V8 lock.
3724
+ */
3725
+ static void StartPreemption(int every_n_ms);
3726
+
3727
+ /**
3728
+ * Stop preemption.
3729
+ */
3730
+ static void StopPreemption();
3731
+
3732
+ /**
3733
+ * Returns whether or not the locker for a given isolate, or default isolate
3734
+ * if NULL is given, is locked by the current thread.
3735
+ */
3736
+ static bool IsLocked(Isolate* isolate = NULL);
3737
+
3738
+ /**
3739
+ * Returns whether v8::Locker is being used by this V8 instance.
3740
+ */
3741
+ static bool IsActive();
3742
+
3743
+ private:
3744
+ bool has_lock_;
3745
+ bool top_level_;
3746
+ internal::Isolate* isolate_;
3747
+
3748
+ static bool active_;
3749
+
3750
+ // Disallow copying and assigning.
3751
+ Locker(const Locker&);
3752
+ void operator=(const Locker&);
3753
+ };
3754
+
3755
+
3756
+ /**
3757
+ * A struct for exporting HeapStats data from V8, using "push" model.
3758
+ */
3759
+ struct HeapStatsUpdate;
3760
+
3761
+
3762
+ /**
3763
+ * An interface for exporting data from V8, using "push" model.
3764
+ */
3765
+ class V8EXPORT OutputStream { // NOLINT
3766
+ public:
3767
+ enum OutputEncoding {
3768
+ kAscii = 0 // 7-bit ASCII.
3769
+ };
3770
+ enum WriteResult {
3771
+ kContinue = 0,
3772
+ kAbort = 1
3773
+ };
3774
+ virtual ~OutputStream() {}
3775
+ /** Notify about the end of stream. */
3776
+ virtual void EndOfStream() = 0;
3777
+ /** Get preferred output chunk size. Called only once. */
3778
+ virtual int GetChunkSize() { return 1024; }
3779
+ /** Get preferred output encoding. Called only once. */
3780
+ virtual OutputEncoding GetOutputEncoding() { return kAscii; }
3781
+ /**
3782
+ * Writes the next chunk of snapshot data into the stream. Writing
3783
+ * can be stopped by returning kAbort as function result. EndOfStream
3784
+ * will not be called in case writing was aborted.
3785
+ */
3786
+ virtual WriteResult WriteAsciiChunk(char* data, int size) = 0;
3787
+ /**
3788
+ * Writes the next chunk of heap stats data into the stream. Writing
3789
+ * can be stopped by returning kAbort as function result. EndOfStream
3790
+ * will not be called in case writing was aborted.
3791
+ */
3792
+ virtual WriteResult WriteHeapStatsChunk(HeapStatsUpdate* data, int count) {
3793
+ return kAbort;
3794
+ };
3795
+ };
3796
+
3797
+
3798
+ /**
3799
+ * An interface for reporting progress and controlling long-running
3800
+ * activities.
3801
+ */
3802
+ class V8EXPORT ActivityControl { // NOLINT
3803
+ public:
3804
+ enum ControlOption {
3805
+ kContinue = 0,
3806
+ kAbort = 1
3807
+ };
3808
+ virtual ~ActivityControl() {}
3809
+ /**
3810
+ * Notify about current progress. The activity can be stopped by
3811
+ * returning kAbort as the callback result.
3812
+ */
3813
+ virtual ControlOption ReportProgressValue(int done, int total) = 0;
3814
+ };
3815
+
3816
+
3817
+ // --- Implementation ---
3818
+
3819
+
3820
+ namespace internal {
3821
+
3822
+ const int kApiPointerSize = sizeof(void*); // NOLINT
3823
+ const int kApiIntSize = sizeof(int); // NOLINT
3824
+
3825
+ // Tag information for HeapObject.
3826
+ const int kHeapObjectTag = 1;
3827
+ const int kHeapObjectTagSize = 2;
3828
+ const intptr_t kHeapObjectTagMask = (1 << kHeapObjectTagSize) - 1;
3829
+
3830
+ // Tag information for Smi.
3831
+ const int kSmiTag = 0;
3832
+ const int kSmiTagSize = 1;
3833
+ const intptr_t kSmiTagMask = (1 << kSmiTagSize) - 1;
3834
+
3835
+ template <size_t ptr_size> struct SmiTagging;
3836
+
3837
+ // Smi constants for 32-bit systems.
3838
+ template <> struct SmiTagging<4> {
3839
+ static const int kSmiShiftSize = 0;
3840
+ static const int kSmiValueSize = 31;
3841
+ static inline int SmiToInt(internal::Object* value) {
3842
+ int shift_bits = kSmiTagSize + kSmiShiftSize;
3843
+ // Throw away top 32 bits and shift down (requires >> to be sign extending).
3844
+ return static_cast<int>(reinterpret_cast<intptr_t>(value)) >> shift_bits;
3845
+ }
3846
+
3847
+ // For 32-bit systems any 2 bytes aligned pointer can be encoded as smi
3848
+ // with a plain reinterpret_cast.
3849
+ static const uintptr_t kEncodablePointerMask = 0x1;
3850
+ static const int kPointerToSmiShift = 0;
3851
+ };
3852
+
3853
+ // Smi constants for 64-bit systems.
3854
+ template <> struct SmiTagging<8> {
3855
+ static const int kSmiShiftSize = 31;
3856
+ static const int kSmiValueSize = 32;
3857
+ static inline int SmiToInt(internal::Object* value) {
3858
+ int shift_bits = kSmiTagSize + kSmiShiftSize;
3859
+ // Shift down and throw away top 32 bits.
3860
+ return static_cast<int>(reinterpret_cast<intptr_t>(value) >> shift_bits);
3861
+ }
3862
+
3863
+ // To maximize the range of pointers that can be encoded
3864
+ // in the available 32 bits, we require them to be 8 bytes aligned.
3865
+ // This gives 2 ^ (32 + 3) = 32G address space covered.
3866
+ // It might be not enough to cover stack allocated objects on some platforms.
3867
+ static const int kPointerAlignment = 3;
3868
+
3869
+ static const uintptr_t kEncodablePointerMask =
3870
+ ~(uintptr_t(0xffffffff) << kPointerAlignment);
3871
+
3872
+ static const int kPointerToSmiShift =
3873
+ kSmiTagSize + kSmiShiftSize - kPointerAlignment;
3874
+ };
3875
+
3876
+ typedef SmiTagging<kApiPointerSize> PlatformSmiTagging;
3877
+ const int kSmiShiftSize = PlatformSmiTagging::kSmiShiftSize;
3878
+ const int kSmiValueSize = PlatformSmiTagging::kSmiValueSize;
3879
+ const uintptr_t kEncodablePointerMask =
3880
+ PlatformSmiTagging::kEncodablePointerMask;
3881
+ const int kPointerToSmiShift = PlatformSmiTagging::kPointerToSmiShift;
3882
+
3883
+ /**
3884
+ * This class exports constants and functionality from within v8 that
3885
+ * is necessary to implement inline functions in the v8 api. Don't
3886
+ * depend on functions and constants defined here.
3887
+ */
3888
+ class Internals {
3889
+ public:
3890
+ // These values match non-compiler-dependent values defined within
3891
+ // the implementation of v8.
3892
+ static const int kHeapObjectMapOffset = 0;
3893
+ static const int kMapInstanceTypeOffset = 1 * kApiPointerSize + kApiIntSize;
3894
+ static const int kStringResourceOffset = 3 * kApiPointerSize;
3895
+
3896
+ static const int kOddballKindOffset = 3 * kApiPointerSize;
3897
+ static const int kForeignAddressOffset = kApiPointerSize;
3898
+ static const int kJSObjectHeaderSize = 3 * kApiPointerSize;
3899
+ static const int kFullStringRepresentationMask = 0x07;
3900
+ static const int kExternalTwoByteRepresentationTag = 0x02;
3901
+
3902
+ static const int kIsolateStateOffset = 0;
3903
+ static const int kIsolateEmbedderDataOffset = 1 * kApiPointerSize;
3904
+ static const int kIsolateRootsOffset = 3 * kApiPointerSize;
3905
+ static const int kUndefinedValueRootIndex = 5;
3906
+ static const int kNullValueRootIndex = 7;
3907
+ static const int kTrueValueRootIndex = 8;
3908
+ static const int kFalseValueRootIndex = 9;
3909
+ static const int kEmptySymbolRootIndex = 128;
3910
+
3911
+ static const int kJSObjectType = 0xaa;
3912
+ static const int kFirstNonstringType = 0x80;
3913
+ static const int kOddballType = 0x82;
3914
+ static const int kForeignType = 0x85;
3915
+
3916
+ static const int kUndefinedOddballKind = 5;
3917
+ static const int kNullOddballKind = 3;
3918
+
3919
+ static inline bool HasHeapObjectTag(internal::Object* value) {
3920
+ return ((reinterpret_cast<intptr_t>(value) & kHeapObjectTagMask) ==
3921
+ kHeapObjectTag);
3922
+ }
3923
+
3924
+ static inline bool HasSmiTag(internal::Object* value) {
3925
+ return ((reinterpret_cast<intptr_t>(value) & kSmiTagMask) == kSmiTag);
3926
+ }
3927
+
3928
+ static inline int SmiValue(internal::Object* value) {
3929
+ return PlatformSmiTagging::SmiToInt(value);
3930
+ }
3931
+
3932
+ static inline int GetInstanceType(internal::Object* obj) {
3933
+ typedef internal::Object O;
3934
+ O* map = ReadField<O*>(obj, kHeapObjectMapOffset);
3935
+ return ReadField<uint8_t>(map, kMapInstanceTypeOffset);
3936
+ }
3937
+
3938
+ static inline int GetOddballKind(internal::Object* obj) {
3939
+ typedef internal::Object O;
3940
+ return SmiValue(ReadField<O*>(obj, kOddballKindOffset));
3941
+ }
3942
+
3943
+ static inline void* GetExternalPointerFromSmi(internal::Object* value) {
3944
+ const uintptr_t address = reinterpret_cast<uintptr_t>(value);
3945
+ return reinterpret_cast<void*>(address >> kPointerToSmiShift);
3946
+ }
3947
+
3948
+ static inline void* GetExternalPointer(internal::Object* obj) {
3949
+ if (HasSmiTag(obj)) {
3950
+ return GetExternalPointerFromSmi(obj);
3951
+ } else if (GetInstanceType(obj) == kForeignType) {
3952
+ return ReadField<void*>(obj, kForeignAddressOffset);
3953
+ } else {
3954
+ return NULL;
3955
+ }
3956
+ }
3957
+
3958
+ static inline bool IsExternalTwoByteString(int instance_type) {
3959
+ int representation = (instance_type & kFullStringRepresentationMask);
3960
+ return representation == kExternalTwoByteRepresentationTag;
3961
+ }
3962
+
3963
+ static inline bool IsInitialized(v8::Isolate* isolate) {
3964
+ uint8_t* addr = reinterpret_cast<uint8_t*>(isolate) + kIsolateStateOffset;
3965
+ return *reinterpret_cast<int*>(addr) == 1;
3966
+ }
3967
+
3968
+ static inline void SetEmbedderData(v8::Isolate* isolate, void* data) {
3969
+ uint8_t* addr = reinterpret_cast<uint8_t*>(isolate) +
3970
+ kIsolateEmbedderDataOffset;
3971
+ *reinterpret_cast<void**>(addr) = data;
3972
+ }
3973
+
3974
+ static inline void* GetEmbedderData(v8::Isolate* isolate) {
3975
+ uint8_t* addr = reinterpret_cast<uint8_t*>(isolate) +
3976
+ kIsolateEmbedderDataOffset;
3977
+ return *reinterpret_cast<void**>(addr);
3978
+ }
3979
+
3980
+ static inline internal::Object** GetRoot(v8::Isolate* isolate, int index) {
3981
+ uint8_t* addr = reinterpret_cast<uint8_t*>(isolate) + kIsolateRootsOffset;
3982
+ return reinterpret_cast<internal::Object**>(addr + index * kApiPointerSize);
3983
+ }
3984
+
3985
+ template <typename T>
3986
+ static inline T ReadField(Object* ptr, int offset) {
3987
+ uint8_t* addr = reinterpret_cast<uint8_t*>(ptr) + offset - kHeapObjectTag;
3988
+ return *reinterpret_cast<T*>(addr);
3989
+ }
3990
+
3991
+ static inline bool CanCastToHeapObject(void* o) { return false; }
3992
+ static inline bool CanCastToHeapObject(Context* o) { return true; }
3993
+ static inline bool CanCastToHeapObject(String* o) { return true; }
3994
+ static inline bool CanCastToHeapObject(Object* o) { return true; }
3995
+ static inline bool CanCastToHeapObject(Message* o) { return true; }
3996
+ static inline bool CanCastToHeapObject(StackTrace* o) { return true; }
3997
+ static inline bool CanCastToHeapObject(StackFrame* o) { return true; }
3998
+ };
3999
+
4000
+ } // namespace internal
4001
+
4002
+
4003
+ template <class T>
4004
+ Local<T>::Local() : Handle<T>() { }
4005
+
4006
+
4007
+ template <class T>
4008
+ Local<T> Local<T>::New(Handle<T> that) {
4009
+ if (that.IsEmpty()) return Local<T>();
4010
+ T* that_ptr = *that;
4011
+ internal::Object** p = reinterpret_cast<internal::Object**>(that_ptr);
4012
+ if (internal::Internals::CanCastToHeapObject(that_ptr)) {
4013
+ return Local<T>(reinterpret_cast<T*>(HandleScope::CreateHandle(
4014
+ reinterpret_cast<internal::HeapObject*>(*p))));
4015
+ }
4016
+ return Local<T>(reinterpret_cast<T*>(HandleScope::CreateHandle(*p)));
4017
+ }
4018
+
4019
+
4020
+ template <class T>
4021
+ Persistent<T> Persistent<T>::New(Handle<T> that) {
4022
+ if (that.IsEmpty()) return Persistent<T>();
4023
+ internal::Object** p = reinterpret_cast<internal::Object**>(*that);
4024
+ return Persistent<T>(reinterpret_cast<T*>(V8::GlobalizeReference(p)));
4025
+ }
4026
+
4027
+
4028
+ template <class T>
4029
+ bool Persistent<T>::IsNearDeath() const {
4030
+ if (this->IsEmpty()) return false;
4031
+ return V8::IsGlobalNearDeath(reinterpret_cast<internal::Object**>(**this));
4032
+ }
4033
+
4034
+
4035
+ template <class T>
4036
+ bool Persistent<T>::IsWeak() const {
4037
+ if (this->IsEmpty()) return false;
4038
+ return V8::IsGlobalWeak(reinterpret_cast<internal::Object**>(**this));
4039
+ }
4040
+
4041
+
4042
+ template <class T>
4043
+ void Persistent<T>::Dispose() {
4044
+ if (this->IsEmpty()) return;
4045
+ V8::DisposeGlobal(reinterpret_cast<internal::Object**>(**this));
4046
+ }
4047
+
4048
+
4049
+ template <class T>
4050
+ Persistent<T>::Persistent() : Handle<T>() { }
4051
+
4052
+ template <class T>
4053
+ void Persistent<T>::MakeWeak(void* parameters, WeakReferenceCallback callback) {
4054
+ V8::MakeWeak(reinterpret_cast<internal::Object**>(**this),
4055
+ parameters,
4056
+ callback);
4057
+ }
4058
+
4059
+ template <class T>
4060
+ void Persistent<T>::ClearWeak() {
4061
+ V8::ClearWeak(reinterpret_cast<internal::Object**>(**this));
4062
+ }
4063
+
4064
+ template <class T>
4065
+ void Persistent<T>::MarkIndependent() {
4066
+ V8::MarkIndependent(reinterpret_cast<internal::Object**>(**this));
4067
+ }
4068
+
4069
+ template <class T>
4070
+ void Persistent<T>::SetWrapperClassId(uint16_t class_id) {
4071
+ V8::SetWrapperClassId(reinterpret_cast<internal::Object**>(**this), class_id);
4072
+ }
4073
+
4074
+ Arguments::Arguments(internal::Object** implicit_args,
4075
+ internal::Object** values, int length,
4076
+ bool is_construct_call)
4077
+ : implicit_args_(implicit_args),
4078
+ values_(values),
4079
+ length_(length),
4080
+ is_construct_call_(is_construct_call) { }
4081
+
4082
+
4083
+ Local<Value> Arguments::operator[](int i) const {
4084
+ if (i < 0 || length_ <= i) return Local<Value>(*Undefined());
4085
+ return Local<Value>(reinterpret_cast<Value*>(values_ - i));
4086
+ }
4087
+
4088
+
4089
+ Local<Function> Arguments::Callee() const {
4090
+ return Local<Function>(reinterpret_cast<Function*>(
4091
+ &implicit_args_[kCalleeIndex]));
4092
+ }
4093
+
4094
+
4095
+ Local<Object> Arguments::This() const {
4096
+ return Local<Object>(reinterpret_cast<Object*>(values_ + 1));
4097
+ }
4098
+
4099
+
4100
+ Local<Object> Arguments::Holder() const {
4101
+ return Local<Object>(reinterpret_cast<Object*>(
4102
+ &implicit_args_[kHolderIndex]));
4103
+ }
4104
+
4105
+
4106
+ Local<Value> Arguments::Data() const {
4107
+ return Local<Value>(reinterpret_cast<Value*>(&implicit_args_[kDataIndex]));
4108
+ }
4109
+
4110
+
4111
+ Isolate* Arguments::GetIsolate() const {
4112
+ return *reinterpret_cast<Isolate**>(&implicit_args_[kIsolateIndex]);
4113
+ }
4114
+
4115
+
4116
+ bool Arguments::IsConstructCall() const {
4117
+ return is_construct_call_;
4118
+ }
4119
+
4120
+
4121
+ int Arguments::Length() const {
4122
+ return length_;
4123
+ }
4124
+
4125
+
4126
+ template <class T>
4127
+ Local<T> HandleScope::Close(Handle<T> value) {
4128
+ internal::Object** before = reinterpret_cast<internal::Object**>(*value);
4129
+ internal::Object** after = RawClose(before);
4130
+ return Local<T>(reinterpret_cast<T*>(after));
4131
+ }
4132
+
4133
+ Handle<Value> ScriptOrigin::ResourceName() const {
4134
+ return resource_name_;
4135
+ }
4136
+
4137
+
4138
+ Handle<Integer> ScriptOrigin::ResourceLineOffset() const {
4139
+ return resource_line_offset_;
4140
+ }
4141
+
4142
+
4143
+ Handle<Integer> ScriptOrigin::ResourceColumnOffset() const {
4144
+ return resource_column_offset_;
4145
+ }
4146
+
4147
+
4148
+ Handle<Boolean> Boolean::New(bool value) {
4149
+ return value ? True() : False();
4150
+ }
4151
+
4152
+
4153
+ void Template::Set(const char* name, v8::Handle<Data> value) {
4154
+ Set(v8::String::New(name), value);
4155
+ }
4156
+
4157
+
4158
+ Local<Value> Object::GetInternalField(int index) {
4159
+ #ifndef V8_ENABLE_CHECKS
4160
+ Local<Value> quick_result = UncheckedGetInternalField(index);
4161
+ if (!quick_result.IsEmpty()) return quick_result;
4162
+ #endif
4163
+ return CheckedGetInternalField(index);
4164
+ }
4165
+
4166
+
4167
+ Local<Value> Object::UncheckedGetInternalField(int index) {
4168
+ typedef internal::Object O;
4169
+ typedef internal::Internals I;
4170
+ O* obj = *reinterpret_cast<O**>(this);
4171
+ if (I::GetInstanceType(obj) == I::kJSObjectType) {
4172
+ // If the object is a plain JSObject, which is the common case,
4173
+ // we know where to find the internal fields and can return the
4174
+ // value directly.
4175
+ int offset = I::kJSObjectHeaderSize + (internal::kApiPointerSize * index);
4176
+ O* value = I::ReadField<O*>(obj, offset);
4177
+ O** result = HandleScope::CreateHandle(value);
4178
+ return Local<Value>(reinterpret_cast<Value*>(result));
4179
+ } else {
4180
+ return Local<Value>();
4181
+ }
4182
+ }
4183
+
4184
+
4185
+ void* External::Unwrap(Handle<v8::Value> obj) {
4186
+ #ifdef V8_ENABLE_CHECKS
4187
+ return FullUnwrap(obj);
4188
+ #else
4189
+ return QuickUnwrap(obj);
4190
+ #endif
4191
+ }
4192
+
4193
+
4194
+ void* External::QuickUnwrap(Handle<v8::Value> wrapper) {
4195
+ typedef internal::Object O;
4196
+ O* obj = *reinterpret_cast<O**>(const_cast<v8::Value*>(*wrapper));
4197
+ return internal::Internals::GetExternalPointer(obj);
4198
+ }
4199
+
4200
+
4201
+ void* Object::GetPointerFromInternalField(int index) {
4202
+ typedef internal::Object O;
4203
+ typedef internal::Internals I;
4204
+
4205
+ O* obj = *reinterpret_cast<O**>(this);
4206
+
4207
+ if (I::GetInstanceType(obj) == I::kJSObjectType) {
4208
+ // If the object is a plain JSObject, which is the common case,
4209
+ // we know where to find the internal fields and can return the
4210
+ // value directly.
4211
+ int offset = I::kJSObjectHeaderSize + (internal::kApiPointerSize * index);
4212
+ O* value = I::ReadField<O*>(obj, offset);
4213
+ return I::GetExternalPointer(value);
4214
+ }
4215
+
4216
+ return SlowGetPointerFromInternalField(index);
4217
+ }
4218
+
4219
+
4220
+ String* String::Cast(v8::Value* value) {
4221
+ #ifdef V8_ENABLE_CHECKS
4222
+ CheckCast(value);
4223
+ #endif
4224
+ return static_cast<String*>(value);
4225
+ }
4226
+
4227
+
4228
+ Local<String> String::Empty(Isolate* isolate) {
4229
+ typedef internal::Object* S;
4230
+ typedef internal::Internals I;
4231
+ if (!I::IsInitialized(isolate)) return Empty();
4232
+ S* slot = I::GetRoot(isolate, I::kEmptySymbolRootIndex);
4233
+ return Local<String>(reinterpret_cast<String*>(slot));
4234
+ }
4235
+
4236
+
4237
+ String::ExternalStringResource* String::GetExternalStringResource() const {
4238
+ typedef internal::Object O;
4239
+ typedef internal::Internals I;
4240
+ O* obj = *reinterpret_cast<O**>(const_cast<String*>(this));
4241
+ String::ExternalStringResource* result;
4242
+ if (I::IsExternalTwoByteString(I::GetInstanceType(obj))) {
4243
+ void* value = I::ReadField<void*>(obj, I::kStringResourceOffset);
4244
+ result = reinterpret_cast<String::ExternalStringResource*>(value);
4245
+ } else {
4246
+ result = NULL;
4247
+ }
4248
+ #ifdef V8_ENABLE_CHECKS
4249
+ VerifyExternalStringResource(result);
4250
+ #endif
4251
+ return result;
4252
+ }
4253
+
4254
+
4255
+ bool Value::IsUndefined() const {
4256
+ #ifdef V8_ENABLE_CHECKS
4257
+ return FullIsUndefined();
4258
+ #else
4259
+ return QuickIsUndefined();
4260
+ #endif
4261
+ }
4262
+
4263
+ bool Value::QuickIsUndefined() const {
4264
+ typedef internal::Object O;
4265
+ typedef internal::Internals I;
4266
+ O* obj = *reinterpret_cast<O**>(const_cast<Value*>(this));
4267
+ if (!I::HasHeapObjectTag(obj)) return false;
4268
+ if (I::GetInstanceType(obj) != I::kOddballType) return false;
4269
+ return (I::GetOddballKind(obj) == I::kUndefinedOddballKind);
4270
+ }
4271
+
4272
+
4273
+ bool Value::IsNull() const {
4274
+ #ifdef V8_ENABLE_CHECKS
4275
+ return FullIsNull();
4276
+ #else
4277
+ return QuickIsNull();
4278
+ #endif
4279
+ }
4280
+
4281
+ bool Value::QuickIsNull() const {
4282
+ typedef internal::Object O;
4283
+ typedef internal::Internals I;
4284
+ O* obj = *reinterpret_cast<O**>(const_cast<Value*>(this));
4285
+ if (!I::HasHeapObjectTag(obj)) return false;
4286
+ if (I::GetInstanceType(obj) != I::kOddballType) return false;
4287
+ return (I::GetOddballKind(obj) == I::kNullOddballKind);
4288
+ }
4289
+
4290
+
4291
+ bool Value::IsString() const {
4292
+ #ifdef V8_ENABLE_CHECKS
4293
+ return FullIsString();
4294
+ #else
4295
+ return QuickIsString();
4296
+ #endif
4297
+ }
4298
+
4299
+ bool Value::QuickIsString() const {
4300
+ typedef internal::Object O;
4301
+ typedef internal::Internals I;
4302
+ O* obj = *reinterpret_cast<O**>(const_cast<Value*>(this));
4303
+ if (!I::HasHeapObjectTag(obj)) return false;
4304
+ return (I::GetInstanceType(obj) < I::kFirstNonstringType);
4305
+ }
4306
+
4307
+
4308
+ Number* Number::Cast(v8::Value* value) {
4309
+ #ifdef V8_ENABLE_CHECKS
4310
+ CheckCast(value);
4311
+ #endif
4312
+ return static_cast<Number*>(value);
4313
+ }
4314
+
4315
+
4316
+ Integer* Integer::Cast(v8::Value* value) {
4317
+ #ifdef V8_ENABLE_CHECKS
4318
+ CheckCast(value);
4319
+ #endif
4320
+ return static_cast<Integer*>(value);
4321
+ }
4322
+
4323
+
4324
+ Date* Date::Cast(v8::Value* value) {
4325
+ #ifdef V8_ENABLE_CHECKS
4326
+ CheckCast(value);
4327
+ #endif
4328
+ return static_cast<Date*>(value);
4329
+ }
4330
+
4331
+
4332
+ StringObject* StringObject::Cast(v8::Value* value) {
4333
+ #ifdef V8_ENABLE_CHECKS
4334
+ CheckCast(value);
4335
+ #endif
4336
+ return static_cast<StringObject*>(value);
4337
+ }
4338
+
4339
+
4340
+ NumberObject* NumberObject::Cast(v8::Value* value) {
4341
+ #ifdef V8_ENABLE_CHECKS
4342
+ CheckCast(value);
4343
+ #endif
4344
+ return static_cast<NumberObject*>(value);
4345
+ }
4346
+
4347
+
4348
+ BooleanObject* BooleanObject::Cast(v8::Value* value) {
4349
+ #ifdef V8_ENABLE_CHECKS
4350
+ CheckCast(value);
4351
+ #endif
4352
+ return static_cast<BooleanObject*>(value);
4353
+ }
4354
+
4355
+
4356
+ RegExp* RegExp::Cast(v8::Value* value) {
4357
+ #ifdef V8_ENABLE_CHECKS
4358
+ CheckCast(value);
4359
+ #endif
4360
+ return static_cast<RegExp*>(value);
4361
+ }
4362
+
4363
+
4364
+ Object* Object::Cast(v8::Value* value) {
4365
+ #ifdef V8_ENABLE_CHECKS
4366
+ CheckCast(value);
4367
+ #endif
4368
+ return static_cast<Object*>(value);
4369
+ }
4370
+
4371
+
4372
+ Array* Array::Cast(v8::Value* value) {
4373
+ #ifdef V8_ENABLE_CHECKS
4374
+ CheckCast(value);
4375
+ #endif
4376
+ return static_cast<Array*>(value);
4377
+ }
4378
+
4379
+
4380
+ Function* Function::Cast(v8::Value* value) {
4381
+ #ifdef V8_ENABLE_CHECKS
4382
+ CheckCast(value);
4383
+ #endif
4384
+ return static_cast<Function*>(value);
4385
+ }
4386
+
4387
+
4388
+ External* External::Cast(v8::Value* value) {
4389
+ #ifdef V8_ENABLE_CHECKS
4390
+ CheckCast(value);
4391
+ #endif
4392
+ return static_cast<External*>(value);
4393
+ }
4394
+
4395
+
4396
+ Isolate* AccessorInfo::GetIsolate() const {
4397
+ return *reinterpret_cast<Isolate**>(&args_[-3]);
4398
+ }
4399
+
4400
+
4401
+ Local<Value> AccessorInfo::Data() const {
4402
+ return Local<Value>(reinterpret_cast<Value*>(&args_[-2]));
4403
+ }
4404
+
4405
+
4406
+ Local<Object> AccessorInfo::This() const {
4407
+ return Local<Object>(reinterpret_cast<Object*>(&args_[0]));
4408
+ }
4409
+
4410
+
4411
+ Local<Object> AccessorInfo::Holder() const {
4412
+ return Local<Object>(reinterpret_cast<Object*>(&args_[-1]));
4413
+ }
4414
+
4415
+
4416
+ Handle<Primitive> Undefined(Isolate* isolate) {
4417
+ typedef internal::Object* S;
4418
+ typedef internal::Internals I;
4419
+ if (!I::IsInitialized(isolate)) return Undefined();
4420
+ S* slot = I::GetRoot(isolate, I::kUndefinedValueRootIndex);
4421
+ return Handle<Primitive>(reinterpret_cast<Primitive*>(slot));
4422
+ }
4423
+
4424
+
4425
+ Handle<Primitive> Null(Isolate* isolate) {
4426
+ typedef internal::Object* S;
4427
+ typedef internal::Internals I;
4428
+ if (!I::IsInitialized(isolate)) return Null();
4429
+ S* slot = I::GetRoot(isolate, I::kNullValueRootIndex);
4430
+ return Handle<Primitive>(reinterpret_cast<Primitive*>(slot));
4431
+ }
4432
+
4433
+
4434
+ Handle<Boolean> True(Isolate* isolate) {
4435
+ typedef internal::Object* S;
4436
+ typedef internal::Internals I;
4437
+ if (!I::IsInitialized(isolate)) return True();
4438
+ S* slot = I::GetRoot(isolate, I::kTrueValueRootIndex);
4439
+ return Handle<Boolean>(reinterpret_cast<Boolean*>(slot));
4440
+ }
4441
+
4442
+
4443
+ Handle<Boolean> False(Isolate* isolate) {
4444
+ typedef internal::Object* S;
4445
+ typedef internal::Internals I;
4446
+ if (!I::IsInitialized(isolate)) return False();
4447
+ S* slot = I::GetRoot(isolate, I::kFalseValueRootIndex);
4448
+ return Handle<Boolean>(reinterpret_cast<Boolean*>(slot));
4449
+ }
4450
+
4451
+
4452
+ void Isolate::SetData(void* data) {
4453
+ typedef internal::Internals I;
4454
+ I::SetEmbedderData(this, data);
4455
+ }
4456
+
4457
+
4458
+ void* Isolate::GetData() {
4459
+ typedef internal::Internals I;
4460
+ return I::GetEmbedderData(this);
4461
+ }
4462
+
4463
+
4464
+ /**
4465
+ * \example shell.cc
4466
+ * A simple shell that takes a list of expressions on the
4467
+ * command-line and executes them.
4468
+ */
4469
+
4470
+
4471
+ /**
4472
+ * \example process.cc
4473
+ */
4474
+
4475
+
4476
+ } // namespace v8
4477
+
4478
+
4479
+ #undef V8EXPORT
4480
+ #undef TYPE_CHECK
4481
+
4482
+
4483
+ #endif // V8_H_