// Copyright 2012 the V8 project authors. All rights reserved.
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-// * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following
-// disclaimer in the documentation and/or other materials provided
-// with the distribution.
-// * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived
-// from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
/** \mainpage V8 API Reference Guide
*
class Platform;
class Primitive;
class RawOperationDescriptor;
+class Script;
class Signature;
class StackFrame;
class StackTrace;
template<class T,
class M = NonCopyablePersistentTraits<T> > class Persistent;
template<class T> class UniquePersistent;
+template<class K, class V, class T> class PersistentValueMap;
+template<class V, class T> class PersistentValueVector;
template<class T, class P> class WeakCallbackObject;
class FunctionTemplate;
class ObjectTemplate;
class Data;
+template<typename T> class FunctionCallbackInfo;
template<typename T> class PropertyCallbackInfo;
class StackTrace;
class StackFrame;
class RawOperationDescriptor;
class CallHandlerHelper;
class EscapableHandleScope;
+template<typename T> class ReturnValue;
namespace internal {
class Arguments;
return New(isolate, that.val_);
}
-#ifndef V8_ALLOW_ACCESS_TO_RAW_HANDLE_CONSTRUCTOR
-
- private:
-#endif
- /**
- * Creates a new handle for the specified value.
- */
- V8_INLINE explicit Handle(T* val) : val_(val) {}
-
private:
friend class Utils;
template<class F, class M> friend class Persistent;
friend class Object;
friend class Private;
+ /**
+ * Creates a new handle for the specified value.
+ */
+ V8_INLINE explicit Handle(T* val) : val_(val) {}
+
V8_INLINE static Handle<T> New(Isolate* isolate, T* that);
T* val_;
V8_INLINE static Local<T> New(Isolate* isolate,
const PersistentBase<T>& that);
-#ifndef V8_ALLOW_ACCESS_TO_RAW_HANDLE_CONSTRUCTOR
-
- private:
-#endif
- template <class S> V8_INLINE Local(S* that) : Handle<T>(that) { }
-
private:
friend class Utils;
template<class F> friend class Eternal;
template<class F> friend class internal::CustomArguments;
friend class HandleScope;
friend class EscapableHandleScope;
+ template<class F1, class F2, class F3> friend class PersistentValueMap;
+ template<class F1, class F2> friend class PersistentValueVector;
+ template <class S> V8_INLINE Local(S* that) : Handle<T>(that) { }
V8_INLINE static Local<T> New(Isolate* isolate, T* that);
};
return !operator==(that);
}
+ /**
+ * Install a finalization callback on this object.
+ * NOTE: There is no guarantee as to *when* or even *if* the callback is
+ * invoked. The invocation is performed solely on a best effort basis.
+ * As always, GC-based finalization should *not* be relied upon for any
+ * critical form of resource management!
+ */
template<typename P>
V8_INLINE void SetWeak(
P* parameter,
P* parameter,
typename WeakCallbackData<S, P>::Callback callback);
- V8_INLINE void ClearWeak();
+ template<typename P>
+ V8_INLINE P* ClearWeak();
+
+ // TODO(dcarney): remove this.
+ V8_INLINE void ClearWeak() { ClearWeak<void>(); }
/**
* Marks the reference to this object independent. Garbage collector is free
template<class F> friend class UniquePersistent;
template<class F> friend class PersistentBase;
template<class F> friend class ReturnValue;
+ template<class F1, class F2, class F3> friend class PersistentValueMap;
+ template<class F1, class F2> friend class PersistentValueVector;
+ friend class Object;
explicit V8_INLINE PersistentBase(T* val) : val_(val) {}
PersistentBase(PersistentBase& other); // NOLINT
// This will be removed.
V8_INLINE T* ClearAndLeak();
- // TODO(dcarney): remove
-#ifndef V8_ALLOW_ACCESS_TO_RAW_HANDLE_CONSTRUCTOR
-
- private:
-#endif
- template <class S> V8_INLINE Persistent(S* that) : PersistentBase<T>(that) { }
-
- V8_INLINE T* operator*() const { return this->val_; }
-
private:
friend class Isolate;
friend class Utils;
template<class F1, class F2> friend class Persistent;
template<class F> friend class ReturnValue;
+ template <class S> V8_INLINE Persistent(S* that) : PersistentBase<T>(that) { }
+ V8_INLINE T* operator*() const { return this->val_; }
template<class S, class M2>
V8_INLINE void Copy(const Persistent<S, M2>& that);
};
};
public:
- /**
+ /**
* A UniquePersistent with no storage cell.
*/
V8_INLINE UniquePersistent() : PersistentBase<T>(0) { }
template<class S>
V8_INLINE UniquePersistent& operator=(UniquePersistent<S> rhs) {
TYPE_CHECK(T, S);
+ this->Reset();
this->val_ = rhs.val_;
rhs.val_ = 0;
return *this;
/**
* Pass allows returning uniques from functions, etc.
*/
- V8_INLINE UniquePersistent Pass() { return UniquePersistent(RValue(this)); }
+ UniquePersistent Pass() { return UniquePersistent(RValue(this)); }
private:
UniquePersistent(UniquePersistent&);
/**
- * Pre-compilation data that can be associated with a script. This
- * data can be calculated for a script in advance of actually
- * compiling it, and can be stored between compilations. When script
- * data is given to the compile method compilation will be faster.
- */
-class V8_EXPORT ScriptData { // NOLINT
- public:
- virtual ~ScriptData() { }
-
- /**
- * Pre-compiles the specified script (context-independent).
- *
- * NOTE: Pre-compilation using this method cannot happen on another thread
- * without using Lockers.
- *
- * \param source Script source code.
- */
- static ScriptData* PreCompile(Handle<String> source);
-
- /**
- * Load previous pre-compilation data.
- *
- * \param data Pointer to data returned by a call to Data() of a previous
- * ScriptData. Ownership is not transferred.
- * \param length Length of data.
- */
- static ScriptData* New(const char* data, int length);
-
- /**
- * Returns the length of Data().
- */
- virtual int Length() = 0;
-
- /**
- * Returns a serialized representation of this ScriptData that can later be
- * passed to New(). NOTE: Serialized data is platform-dependent.
- */
- virtual const char* Data() = 0;
-
- /**
- * Returns true if the source code could not be parsed.
- */
- virtual bool HasError() = 0;
-};
-
-
-/**
* The origin, within a file, of a script.
*/
class ScriptOrigin {
/**
- * A compiled JavaScript script.
+ * A compiled JavaScript script, not yet tied to a Context.
*/
-class V8_EXPORT Script {
+class V8_EXPORT UnboundScript {
public:
/**
- * Compiles the specified script (context-independent).
- *
- * \param source Script source code.
- * \param origin Script origin, owned by caller, no references are kept
- * when New() returns
- * \param pre_data Pre-parsing data, as obtained by ScriptData::PreCompile()
- * using pre_data speeds compilation if it's done multiple times.
- * Owned by caller, no references are kept when New() returns.
- * \param script_data Arbitrary data associated with script. Using
- * this has same effect as calling SetData(), but allows data to be
- * available to compile event handlers.
- * \return Compiled script object (context independent; when run it
- * will use the currently entered context).
+ * Binds the script to the currently entered context.
*/
- static Local<Script> New(Handle<String> source,
- ScriptOrigin* origin = NULL,
- ScriptData* pre_data = NULL,
- Handle<String> script_data = Handle<String>());
+ Local<Script> BindToCurrentContext();
+
+ int GetId();
+ Handle<Value> GetScriptName();
/**
- * Compiles the specified script using the specified file name
- * object (typically a string) as the script's origin.
- *
- * \param source Script source code.
- * \param file_name file name object (typically a string) to be used
- * as the script's origin.
- * \return Compiled script object (context independent; when run it
- * will use the currently entered context).
+ * Returns zero based line number of the code_pos location in the script.
+ * -1 will be returned if no information available.
*/
- static Local<Script> New(Handle<String> source,
- Handle<Value> file_name);
+ int GetLineNumber(int code_pos);
+ static const int kNoScriptId = 0;
+};
+
+
+/**
+ * A compiled JavaScript script, tied to a Context which was active when the
+ * script was compiled.
+ */
+class V8_EXPORT Script {
+ public:
/**
- * Compiles the specified script (bound to current context).
- *
- * \param source Script source code.
- * \param origin Script origin, owned by caller, no references are kept
- * when Compile() returns
- * \param pre_data Pre-parsing data, as obtained by ScriptData::PreCompile()
- * using pre_data speeds compilation if it's done multiple times.
- * Owned by caller, no references are kept when Compile() returns.
- * \param script_data Arbitrary data associated with script. Using
- * this has same effect as calling SetData(), but makes data available
- * earlier (i.e. to compile event handlers).
- * \return Compiled script object, bound to the context that was active
- * when this function was called. When run it will always use this
- * context.
+ * A shorthand for ScriptCompiler::Compile().
*/
static Local<Script> Compile(Handle<String> source,
- ScriptOrigin* origin = NULL,
- ScriptData* pre_data = NULL,
- Handle<String> script_data = Handle<String>());
+ ScriptOrigin* origin = NULL);
- /**
- * Compiles the specified script using the specified file name
- * object (typically a string) as the script's origin.
- *
- * \param source Script source code.
- * \param file_name File name to use as script's origin
- * \param script_data Arbitrary data associated with script. Using
- * this has same effect as calling SetData(), but makes data available
- * earlier (i.e. to compile event handlers).
- * \return Compiled script object, bound to the context that was active
- * when this function was called. When run it will always use this
- * context.
- */
+ // To be decprecated, use the Compile above.
static Local<Script> Compile(Handle<String> source,
- Handle<Value> file_name,
- Handle<String> script_data = Handle<String>());
+ Handle<String> file_name);
/**
- * Runs the script returning the resulting value. If the script is
- * context independent (created using ::New) it will be run in the
- * currently entered context. If it is context specific (created
- * using ::Compile) it will be run in the context in which it was
- * compiled.
+ * Runs the script returning the resulting value. It will be run in the
+ * context in which it was created (ScriptCompiler::CompileBound or
+ * UnboundScript::BindToGlobalContext()).
*/
Local<Value> Run();
/**
- * Returns the script id.
+ * Returns the corresponding context-unbound script.
*/
- int GetId();
+ Local<UnboundScript> GetUnboundScript();
+
+ // To be deprecated; use GetUnboundScript()->GetId();
+ int GetId() {
+ return GetUnboundScript()->GetId();
+ }
+
+ // Use GetUnboundScript()->GetId();
+ V8_DEPRECATED("Use GetUnboundScript()->GetId()",
+ Handle<Value> GetScriptName()) {
+ return GetUnboundScript()->GetScriptName();
+ }
/**
- * Associate an additional data object with the script. This is mainly used
- * with the debugger as this data object is only available through the
- * debugger API.
+ * Returns zero based line number of the code_pos location in the script.
+ * -1 will be returned if no information available.
*/
- void SetData(Handle<String> data);
+ V8_DEPRECATED("Use GetUnboundScript()->GetLineNumber()",
+ int GetLineNumber(int code_pos)) {
+ return GetUnboundScript()->GetLineNumber(code_pos);
+ }
+};
+
+/**
+ * For compiling scripts.
+ */
+class V8_EXPORT ScriptCompiler {
+ public:
/**
- * Returns the name value of one Script.
+ * Compilation data that the embedder can cache and pass back to speed up
+ * future compilations. The data is produced if the CompilerOptions passed to
+ * the compilation functions in ScriptCompiler contains produce_data_to_cache
+ * = true. The data to cache can then can be retrieved from
+ * UnboundScript.
+ */
+ struct V8_EXPORT CachedData {
+ enum BufferPolicy {
+ BufferNotOwned,
+ BufferOwned
+ };
+
+ CachedData() : data(NULL), length(0), buffer_policy(BufferNotOwned) {}
+
+ // If buffer_policy is BufferNotOwned, the caller keeps the ownership of
+ // data and guarantees that it stays alive until the CachedData object is
+ // destroyed. If the policy is BufferOwned, the given data will be deleted
+ // (with delete[]) when the CachedData object is destroyed.
+ CachedData(const uint8_t* data, int length,
+ BufferPolicy buffer_policy = BufferNotOwned);
+ ~CachedData();
+ // TODO(marja): Async compilation; add constructors which take a callback
+ // which will be called when V8 no longer needs the data.
+ const uint8_t* data;
+ int length;
+ BufferPolicy buffer_policy;
+
+ private:
+ // Prevent copying. Not implemented.
+ CachedData(const CachedData&);
+ CachedData& operator=(const CachedData&);
+ };
+
+ /**
+ * Source code which can be then compiled to a UnboundScript or
+ * BoundScript.
*/
- Handle<Value> GetScriptName();
+ class Source {
+ public:
+ // Source takes ownership of CachedData.
+ V8_INLINE Source(Local<String> source_string, const ScriptOrigin& origin,
+ CachedData* cached_data = NULL);
+ V8_INLINE Source(Local<String> source_string,
+ CachedData* cached_data = NULL);
+ V8_INLINE ~Source();
+
+ // Ownership of the CachedData or its buffers is *not* transferred to the
+ // caller. The CachedData object is alive as long as the Source object is
+ // alive.
+ V8_INLINE const CachedData* GetCachedData() const;
+
+ private:
+ friend class ScriptCompiler;
+ // Prevent copying. Not implemented.
+ Source(const Source&);
+ Source& operator=(const Source&);
+
+ Local<String> source_string;
+
+ // Origin information
+ Handle<Value> resource_name;
+ Handle<Integer> resource_line_offset;
+ Handle<Integer> resource_column_offset;
+ Handle<Boolean> resource_is_shared_cross_origin;
+
+ // Cached data from previous compilation (if any), or generated during
+ // compilation (if the generate_cached_data flag is passed to
+ // ScriptCompiler).
+ CachedData* cached_data;
+ };
+
+ enum CompileOptions {
+ kNoCompileOptions,
+ kProduceDataToCache = 1 << 0
+ };
/**
- * Returns zero based line number of the code_pos location in the script.
- * -1 will be returned if no information available.
+ * Compiles the specified script (context-independent).
+ *
+ * \param source Script source code.
+ * \return Compiled script object (context independent; for running it must be
+ * bound to a context).
*/
- int GetLineNumber(int code_pos);
+ static Local<UnboundScript> CompileUnbound(
+ Isolate* isolate, Source* source,
+ CompileOptions options = kNoCompileOptions);
- static const int kNoScriptId = 0;
+ /**
+ * Compiles the specified script (bound to current context).
+ *
+ * \param source Script source code.
+ * \param pre_data Pre-parsing data, as obtained by ScriptData::PreCompile()
+ * using pre_data speeds compilation if it's done multiple times.
+ * Owned by caller, no references are kept when this function returns.
+ * \return Compiled script object, bound to the context that was active
+ * when this function was called. When run it will always use this
+ * context.
+ */
+ static Local<Script> Compile(
+ Isolate* isolate, Source* source,
+ CompileOptions options = kNoCompileOptions);
};
Handle<Value> GetScriptResourceName() const;
/**
- * Returns the resource data for the script from where the function causing
- * the error originates.
- */
- Handle<Value> GetScriptData() const;
-
- /**
* Exception stack trace. By default stack traces are not captured for
* uncaught exceptions. SetCaptureStackTraceForUncaughtExceptions allows
* to change this option.
*/
bool IsRegExp() const;
+ /**
+ * Returns true if this value is a Promise.
+ * This is an experimental feature.
+ */
+ bool IsPromise() const;
/**
* Returns true if this value is an ArrayBuffer.
bool IsFloat32Array() const;
/**
+ * Returns true if this value is a Float32x4Array.
+ * This is an experimental feature.
+ */
+ bool IsFloat32x4Array() const;
+
+ /**
+ * Returns true if this value is a Float64x2Array.
+ * This is an experimental feature.
+ */
+ bool IsFloat64x2Array() const;
+
+ /**
+ * Returns true if this value is a Int32x4Array.
+ * This is an experimental feature.
+ */
+ bool IsInt32x4Array() const;
+
+ /**
* Returns true if this value is a Float64Array.
* This is an experimental feature.
*/
// Returns the print name string of the symbol, or undefined if none.
Local<Value> Name() const;
- // Create a symbol. If data is not NULL, it will be used as a print name.
+ // Create a symbol. If name is not empty, it will be used as the description.
static Local<Symbol> New(
- Isolate *isolate, const char* data = NULL, int length = -1);
+ Isolate *isolate, Local<String> name = Local<String>());
+
+ // Access global symbol registry.
+ // Note that symbols created this way are never collected, so
+ // they should only be used for statically fixed properties.
+ // Also, there is only one global name space for the names used as keys.
+ // To minimize the potential for clashes, use qualified names as keys.
+ static Local<Symbol> For(Isolate *isolate, Local<String> name);
+
+ // Retrieve a global symbol. Similar to |For|, but using a separate
+ // registry that is not accessible by (and cannot clash with) JavaScript code.
+ static Local<Symbol> ForApi(Isolate *isolate, Local<String> name);
V8_INLINE static Symbol* Cast(v8::Value* obj);
private:
// Returns the print name string of the private symbol, or undefined if none.
Local<Value> Name() const;
- // Create a private symbol. If data is not NULL, it will be the print name.
+ // Create a private symbol. If name is not empty, it will be the description.
static Local<Private> New(
- Isolate *isolate, const char* data = NULL, int length = -1);
+ Isolate *isolate, Local<String> name = Local<String>());
+
+ // Retrieve a global private symbol. If a symbol with this name has not
+ // been retrieved in the same isolate before, it is created.
+ // Note that private symbols created this way are never collected, so
+ // they should only be used for statically fixed properties.
+ // Also, there is only one global name space for the names used as keys.
+ // To minimize the potential for clashes, use qualified names as keys,
+ // e.g., "Class#property".
+ static Local<Private> ForApi(Isolate *isolate, Local<String> name);
private:
Private();
kExternalInt16Array,
kExternalUint16Array,
kExternalInt32Array,
+ kExternalInt32x4Array,
kExternalUint32Array,
kExternalFloat32Array,
+ kExternalFloat32x4Array,
+ kExternalFloat64x2Array,
kExternalFloat64Array,
kExternalUint8ClampedArray,
PropertyAttribute attribute = None,
AccessControl settings = DEFAULT);
+ void SetAccessorProperty(Local<String> name,
+ Local<Function> getter,
+ Handle<Function> setter = Handle<Function>(),
+ PropertyAttribute attribute = None,
+ AccessControl settings = DEFAULT);
+
/**
* Functionality for private properties.
* This is an experimental feature, use at your own risk.
/** Gets the number of internal fields for this Object. */
int InternalFieldCount();
+ /** Same as above, but works for Persistents */
+ V8_INLINE static int InternalFieldCount(
+ const PersistentBase<Object>& object) {
+ return object.val_->InternalFieldCount();
+ }
+
/** Gets the value from an internal field. */
V8_INLINE Local<Value> GetInternalField(int index);
*/
V8_INLINE void* GetAlignedPointerFromInternalField(int index);
+ /** Same as above, but works for Persistents */
+ V8_INLINE static void* GetAlignedPointerFromInternalField(
+ const PersistentBase<Object>& object, int index) {
+ return object.val_->GetAlignedPointerFromInternalField(index);
+ }
+
/**
* Sets a 2-byte-aligned native pointer in an internal field. To retrieve such
* a field, GetAlignedPointerFromInternalField must be used, everything else
template<class F> friend class ReturnValue;
template<class F> friend class FunctionCallbackInfo;
template<class F> friend class PropertyCallbackInfo;
+ template<class F, class G, class H> friend class PersistentValueMap;
+ V8_INLINE void SetInternal(internal::Object* value) { *value_ = value; }
V8_INLINE internal::Object* GetDefaultValue();
V8_INLINE explicit ReturnValue(internal::Object** slot);
internal::Object** value_;
public:
V8_INLINE Isolate* GetIsolate() const;
V8_INLINE Local<Value> Data() const;
- V8_INLINE Local<Object> This() const;
+ V8_INLINE Local<Value> This() const;
V8_INLINE Local<Object> Holder() const;
V8_INLINE ReturnValue<T> GetReturnValue() const;
// This shouldn't be public, but the arm compiler needs it.
static void CheckCast(Value* obj);
};
+
+/**
+ * An instance of the built-in Promise constructor (ES6 draft).
+ * This API is experimental. Only works with --harmony flag.
+ */
+class V8_EXPORT Promise : public Object {
+ public:
+ class V8_EXPORT Resolver : public Object {
+ public:
+ /**
+ * Create a new resolver, along with an associated promise in pending state.
+ */
+ static Local<Resolver> New(Isolate* isolate);
+
+ /**
+ * Extract the associated promise.
+ */
+ Local<Promise> GetPromise();
+
+ /**
+ * Resolve/reject the associated promise with a given value.
+ * Ignored if the promise is no longer pending.
+ */
+ void Resolve(Handle<Value> value);
+ void Reject(Handle<Value> value);
+
+ V8_INLINE static Resolver* Cast(Value* obj);
+
+ private:
+ Resolver();
+ static void CheckCast(Value* obj);
+ };
+
+ /**
+ * Register a resolution/rejection handler with a promise.
+ * The handler is given the respective resolution/rejection value as
+ * an argument. If the promise is already resolved/rejected, the handler is
+ * invoked at the end of turn.
+ */
+ Local<Promise> Chain(Handle<Function> handler);
+ Local<Promise> Catch(Handle<Function> handler);
+
+ V8_INLINE static Promise* Cast(Value* obj);
+
+ private:
+ Promise();
+ static void CheckCast(Value* obj);
+};
+
+
#ifndef V8_ARRAY_BUFFER_INTERNAL_FIELD_COUNT
// The number of required internal fields can be defined by embedder.
#define V8_ARRAY_BUFFER_INTERNAL_FIELD_COUNT 2
};
+class V8_EXPORT Float32x4Array : public TypedArray {
+ public:
+ static Local<Float32x4Array> New(Handle<ArrayBuffer> array_buffer,
+ size_t byte_offset, size_t length);
+ V8_INLINE static Float32x4Array* Cast(Value* obj);
+
+ private:
+ Float32x4Array();
+ static void CheckCast(Value* obj);
+};
+
+
+class V8_EXPORT Float64x2Array : public TypedArray {
+ public:
+ static Local<Float64x2Array> New(Handle<ArrayBuffer> array_buffer,
+ size_t byte_offset, size_t length);
+ V8_INLINE static Float64x2Array* Cast(Value* obj);
+
+ private:
+ Float64x2Array();
+ static void CheckCast(Value* obj);
+};
+
+
+class V8_EXPORT Int32x4Array : public TypedArray {
+ public:
+ static Local<Int32x4Array> New(Handle<ArrayBuffer> array_buffer,
+ size_t byte_offset, size_t length);
+ V8_INLINE static Int32x4Array* Cast(Value* obj);
+
+ private:
+ Int32x4Array();
+ static void CheckCast(Value* obj);
+};
+
+
/**
* An instance of Float64Array constructor (ES6 draft 15.13.6).
* This API is experimental and may change significantly.
*
* \param physical_memory The total amount of physical memory on the current
* device, in bytes.
+ * \param virtual_memory_limit The amount of virtual memory on the current
+ * device, in bytes, or zero, if there is no limit.
* \param number_of_processors The number of CPUs available on the current
* device.
*/
void ConfigureDefaults(uint64_t physical_memory,
+ uint64_t virtual_memory_limit,
uint32_t number_of_processors);
- int max_young_space_size() const { return max_young_space_size_; }
- void set_max_young_space_size(int value) { max_young_space_size_ = value; }
+ int max_new_space_size() const { return max_new_space_size_; }
+ void set_max_new_space_size(int value) { max_new_space_size_ = value; }
int max_old_space_size() const { return max_old_space_size_; }
void set_max_old_space_size(int value) { max_old_space_size_ = value; }
int max_executable_size() const { return max_executable_size_; }
void set_max_available_threads(int value) {
max_available_threads_ = value;
}
+ int code_range_size() const { return code_range_size_; }
+ void set_code_range_size(int value) {
+ code_range_size_ = value;
+ }
private:
- int max_young_space_size_;
+ int max_new_space_size_;
int max_old_space_size_;
int max_executable_size_;
uint32_t* stack_limit_;
int max_available_threads_;
+ int code_range_size_;
};
typedef void (*MessageCallback)(Handle<Message> message, Handle<Value> error);
+// --- Tracing ---
+
+typedef void (*LogEventCallback)(const char* name, int event);
/**
* Create new error objects by calling the corresponding error object
Scope& operator=(const Scope&);
};
+
+ /**
+ * Assert that no Javascript code is invoked.
+ */
+ class V8_EXPORT DisallowJavascriptExecutionScope {
+ public:
+ enum OnFailure { CRASH_ON_FAILURE, THROW_ON_FAILURE };
+
+ DisallowJavascriptExecutionScope(Isolate* isolate, OnFailure on_failure);
+ ~DisallowJavascriptExecutionScope();
+
+ private:
+ bool on_failure_;
+ void* internal_;
+
+ // Prevent copying of Scope objects.
+ DisallowJavascriptExecutionScope(const DisallowJavascriptExecutionScope&);
+ DisallowJavascriptExecutionScope& operator=(
+ const DisallowJavascriptExecutionScope&);
+ };
+
+
+ /**
+ * Introduce exception to DisallowJavascriptExecutionScope.
+ */
+ class V8_EXPORT AllowJavascriptExecutionScope {
+ public:
+ explicit AllowJavascriptExecutionScope(Isolate* isolate);
+ ~AllowJavascriptExecutionScope();
+
+ private:
+ void* internal_throws_;
+ void* internal_assert_;
+
+ // Prevent copying of Scope objects.
+ AllowJavascriptExecutionScope(const AllowJavascriptExecutionScope&);
+ AllowJavascriptExecutionScope& operator=(
+ const AllowJavascriptExecutionScope&);
+ };
+
+ /**
+ * Do not run microtasks while this scope is active, even if microtasks are
+ * automatically executed otherwise.
+ */
+ class V8_EXPORT SuppressMicrotaskExecutionScope {
+ public:
+ explicit SuppressMicrotaskExecutionScope(Isolate* isolate);
+ ~SuppressMicrotaskExecutionScope();
+
+ private:
+ internal::Isolate* isolate_;
+
+ // Prevent copying of Scope objects.
+ SuppressMicrotaskExecutionScope(const SuppressMicrotaskExecutionScope&);
+ SuppressMicrotaskExecutionScope& operator=(
+ const SuppressMicrotaskExecutionScope&);
+ };
+
/**
* Types of garbage collections that can be requested via
* RequestGarbageCollectionForTesting.
/**
* Enables the host application to receive a notification before a
- * garbage collection. Allocations are not allowed in the
- * callback function, you therefore cannot manipulate objects (set
- * or delete properties for example) since it is possible such
- * operations will result in the allocation of objects. It is possible
- * to specify the GCType filter for your callback. But it is not possible to
- * register the same callback function two times with different
- * GCType filters.
+ * garbage collection. Allocations are allowed in the callback function,
+ * but the callback is not re-entrant: if the allocation inside it will
+ * trigger the garbage collection, the callback won't be called again.
+ * It is possible to specify the GCType filter for your callback. But it is
+ * not possible to register the same callback function two times with
+ * different GCType filters.
*/
void AddGCPrologueCallback(
GCPrologueCallback callback, GCType gc_type_filter = kGCTypeAll);
/**
* Enables the host application to receive a notification after a
- * garbage collection. Allocations are not allowed in the
- * callback function, you therefore cannot manipulate objects (set
- * or delete properties for example) since it is possible such
- * operations will result in the allocation of objects. It is possible
- * to specify the GCType filter for your callback. But it is not possible to
- * register the same callback function two times with different
- * GCType filters.
+ * garbage collection. Allocations are allowed in the callback function,
+ * but the callback is not re-entrant: if the allocation inside it will
+ * trigger the garbage collection, the callback won't be called again.
+ * It is possible to specify the GCType filter for your callback. But it is
+ * not possible to register the same callback function two times with
+ * different GCType filters.
*/
void AddGCEpilogueCallback(
GCEpilogueCallback callback, GCType gc_type_filter = kGCTypeAll);
*/
void RequestGarbageCollectionForTesting(GarbageCollectionType type);
+ /**
+ * Set the callback to invoke for logging event.
+ */
+ void SetEventLogger(LogEventCallback that);
+
+ /**
+ * Adds a callback to notify the host application when a script finished
+ * running. If a script re-enters the runtime during executing, the
+ * CallCompletedCallback is only invoked when the outer-most script
+ * execution ends. Executing scripts inside the callback do not trigger
+ * further callbacks.
+ */
+ void AddCallCompletedCallback(CallCompletedCallback callback);
+
+ /**
+ * Removes callback that was installed by AddCallCompletedCallback.
+ */
+ void RemoveCallCompletedCallback(CallCompletedCallback callback);
+
+ /**
+ * Experimental: Runs the Microtask Work Queue until empty
+ */
+ void RunMicrotasks();
+
+ /**
+ * Experimental: Enqueues the callback to the Microtask Work Queue
+ */
+ void EnqueueMicrotask(Handle<Function> microtask);
+
+ /**
+ * Experimental: Controls whether the Microtask Work Queue is automatically
+ * run when the script call depth decrements to zero.
+ */
+ void SetAutorunMicrotasks(bool autorun);
+
private:
+ template<class K, class V, class Traits> friend class PersistentValueMap;
+
Isolate();
Isolate(const Isolate&);
~Isolate();
static void SetArrayBufferAllocator(ArrayBuffer::Allocator* allocator);
/**
- * Ignore out-of-memory exceptions.
- *
- * V8 running out of memory is treated as a fatal error by default.
- * This means that the fatal error handler is called and that V8 is
- * terminated.
- *
- * IgnoreOutOfMemoryException can be used to not treat an
- * out-of-memory situation as a fatal error. This way, the contexts
- * that did not cause the out of memory problem might be able to
- * continue execution.
- */
- static void IgnoreOutOfMemoryException();
-
- /**
* Check if V8 is dead and therefore unusable. This is the case after
* fatal errors such as out-of-memory situations.
*/
static void RemoveMemoryAllocationCallback(MemoryAllocationCallback callback);
/**
- * Adds a callback to notify the host application when a script finished
- * running. If a script re-enters the runtime during executing, the
- * CallCompletedCallback is only invoked when the outer-most script
- * execution ends. Executing scripts inside the callback do not trigger
- * further callbacks.
+ * Experimental: Runs the Microtask Work Queue until empty
+ *
+ * Deprecated: Use methods on Isolate instead.
*/
- static void AddCallCompletedCallback(CallCompletedCallback callback);
+ static void RunMicrotasks(Isolate* isolate);
/**
- * Removes callback that was installed by AddCallCompletedCallback.
+ * Experimental: Enqueues the callback to the Microtask Work Queue
+ *
+ * Deprecated: Use methods on Isolate instead.
*/
- static void RemoveCallCompletedCallback(CallCompletedCallback callback);
+ static void EnqueueMicrotask(Isolate* isolate, Handle<Function> microtask);
+
+ /**
+ * Experimental: Controls whether the Microtask Work Queue is automatically
+ * run when the script call depth decrements to zero.
+ *
+ * Deprecated: Use methods on Isolate instead.
+ */
+ static void SetAutorunMicrotasks(Isolate *source, bool autorun);
/**
* Initializes from snapshot if possible. Otherwise, attempts to
/**
* Forcefully terminate the current thread of JavaScript execution
- * in the given isolate. If no isolate is provided, the default
- * isolate is used.
+ * in the given isolate.
*
* This method can be used by any thread even if that thread has not
* acquired the V8 lock with a Locker object.
*
* \param isolate The isolate in which to terminate the current JS execution.
*/
- static void TerminateExecution(Isolate* isolate = NULL);
+ static void TerminateExecution(Isolate* isolate);
/**
* Is V8 terminating JavaScript execution.
/**
* Initialize the ICU library bundled with V8. The embedder should only
* invoke this method when using the bundled ICU. Returns true on success.
+ *
+ * If V8 was compiled with the ICU data in an external file, the location
+ * of the data file has to be provided.
*/
- static bool InitializeICU();
+ static bool InitializeICU(const char* icu_data_file = NULL);
/**
* Sets the v8::Platform to use. This should be invoked before V8 is
static void MakeWeak(internal::Object** global_handle,
void* data,
WeakCallback weak_callback);
- static void ClearWeak(internal::Object** global_handle);
+ static void* ClearWeak(internal::Object** global_handle);
static void Eternalize(Isolate* isolate,
Value* handle,
int* index);
*/
void Exit();
- /** Returns true if the context has experienced an out of memory situation. */
- bool HasOutOfMemoryException();
+ /**
+ * Returns true if the context has experienced an out of memory situation.
+ * Since V8 always treats OOM as fatal error, this can no longer return true.
+ * Therefore this is now deprecated.
+ * */
+ V8_DEPRECATED("This can no longer happen. OOM is a fatal error.",
+ bool HasOutOfMemoryException()) { return false; }
/** Returns an isolate associated with a current context. */
v8::Isolate* GetIsolate();
};
-/**
- * A struct for exporting HeapStats data from V8, using "push" model.
- */
-struct HeapStatsUpdate;
-
-
-/**
- * An interface for exporting data from V8, using "push" model.
- */
-class V8_EXPORT OutputStream { // NOLINT
- public:
- enum OutputEncoding {
- kAscii = 0 // 7-bit ASCII.
- };
- enum WriteResult {
- kContinue = 0,
- kAbort = 1
- };
- virtual ~OutputStream() {}
- /** Notify about the end of stream. */
- virtual void EndOfStream() = 0;
- /** Get preferred output chunk size. Called only once. */
- virtual int GetChunkSize() { return 1024; }
- /** Get preferred output encoding. Called only once. */
- virtual OutputEncoding GetOutputEncoding() { return kAscii; }
- /**
- * Writes the next chunk of snapshot data into the stream. Writing
- * can be stopped by returning kAbort as function result. EndOfStream
- * will not be called in case writing was aborted.
- */
- virtual WriteResult WriteAsciiChunk(char* data, int size) = 0;
- /**
- * Writes the next chunk of heap stats data into the stream. Writing
- * can be stopped by returning kAbort as function result. EndOfStream
- * will not be called in case writing was aborted.
- */
- virtual WriteResult WriteHeapStatsChunk(HeapStatsUpdate* data, int count) {
- return kAbort;
- };
-};
-
-
-/**
- * An interface for reporting progress and controlling long-running
- * activities.
- */
-class V8_EXPORT ActivityControl { // NOLINT
- public:
- enum ControlOption {
- kContinue = 0,
- kAbort = 1
- };
- virtual ~ActivityControl() {}
- /**
- * Notify about current progress. The activity can be stopped by
- * returning kAbort as the callback result.
- */
- virtual ControlOption ReportProgressValue(int done, int total) = 0;
-};
-
-
// --- Implementation ---
static const int kJSObjectHeaderSize = 3 * kApiPointerSize;
static const int kFixedArrayHeaderSize = 2 * kApiPointerSize;
static const int kContextHeaderSize = 2 * kApiPointerSize;
- static const int kContextEmbedderDataIndex = 65;
+ static const int kContextEmbedderDataIndex = 87;
static const int kFullStringRepresentationMask = 0x07;
static const int kStringEncodingMask = 0x4;
static const int kExternalTwoByteRepresentationTag = 0x02;
static const int kNullValueRootIndex = 7;
static const int kTrueValueRootIndex = 8;
static const int kFalseValueRootIndex = 9;
- static const int kEmptyStringRootIndex = 145;
+ static const int kEmptyStringRootIndex = 177;
static const int kNodeClassIdOffset = 1 * kApiPointerSize;
static const int kNodeFlagsOffset = 1 * kApiPointerSize + 3;
static const int kNodeIsIndependentShift = 4;
static const int kNodeIsPartiallyDependentShift = 5;
- static const int kJSObjectType = 0xbb;
+ static const int kJSObjectType = 0xc4;
static const int kFirstNonstringType = 0x80;
static const int kOddballType = 0x83;
- static const int kForeignType = 0x87;
+ static const int kForeignType = 0x8a;
static const int kUndefinedOddballKind = 5;
static const int kNullOddballKind = 3;
template <class T>
-void PersistentBase<T>::ClearWeak() {
- V8::ClearWeak(reinterpret_cast<internal::Object**>(this->val_));
+template<typename P>
+P* PersistentBase<T>::ClearWeak() {
+ return reinterpret_cast<P*>(
+ V8::ClearWeak(reinterpret_cast<internal::Object**>(this->val_)));
}
}
+ScriptCompiler::Source::Source(Local<String> string, const ScriptOrigin& origin,
+ CachedData* data)
+ : source_string(string),
+ resource_name(origin.ResourceName()),
+ resource_line_offset(origin.ResourceLineOffset()),
+ resource_column_offset(origin.ResourceColumnOffset()),
+ resource_is_shared_cross_origin(origin.ResourceIsSharedCrossOrigin()),
+ cached_data(data) {}
+
+
+ScriptCompiler::Source::Source(Local<String> string,
+ CachedData* data)
+ : source_string(string), cached_data(data) {}
+
+
+ScriptCompiler::Source::~Source() {
+ delete cached_data;
+}
+
+
+const ScriptCompiler::CachedData* ScriptCompiler::Source::GetCachedData()
+ const {
+ return cached_data;
+}
+
+
Handle<Boolean> Boolean::New(Isolate* isolate, bool value) {
return value ? True(isolate) : False(isolate);
}
}
+Promise* Promise::Cast(v8::Value* value) {
+#ifdef V8_ENABLE_CHECKS
+ CheckCast(value);
+#endif
+ return static_cast<Promise*>(value);
+}
+
+
+Promise::Resolver* Promise::Resolver::Cast(v8::Value* value) {
+#ifdef V8_ENABLE_CHECKS
+ CheckCast(value);
+#endif
+ return static_cast<Promise::Resolver*>(value);
+}
+
+
ArrayBuffer* ArrayBuffer::Cast(v8::Value* value) {
#ifdef V8_ENABLE_CHECKS
CheckCast(value);
}
+Float32x4Array* Float32x4Array::Cast(v8::Value* value) {
+#ifdef V8_ENABLE_CHECKS
+ CheckCast(value);
+#endif
+ return static_cast<Float32x4Array*>(value);
+}
+
+
+Float64x2Array* Float64x2Array::Cast(v8::Value* value) {
+#ifdef V8_ENABLE_CHECKS
+ CheckCast(value);
+#endif
+ return static_cast<Float64x2Array*>(value);
+}
+
+
+Int32x4Array* Int32x4Array::Cast(v8::Value* value) {
+#ifdef V8_ENABLE_CHECKS
+ CheckCast(value);
+#endif
+ return static_cast<Int32x4Array*>(value);
+}
+
+
Float64Array* Float64Array::Cast(v8::Value* value) {
#ifdef V8_ENABLE_CHECKS
CheckCast(value);
template<typename T>
-Local<Object> PropertyCallbackInfo<T>::This() const {
- return Local<Object>(reinterpret_cast<Object*>(&args_[kThisIndex]));
+Local<Value> PropertyCallbackInfo<T>::This() const {
+ return Local<Value>(reinterpret_cast<Value*>(&args_[kThisIndex]));
}
projects / platform / framework / web / crosswalk.git / blobdiff