class Int32;
class Integer;
class Isolate;
+class Name;
class Number;
class NumberObject;
class Object;
class HeapObject;
class Isolate;
class Object;
+struct StreamedSource;
template<typename T> class CustomArguments;
class PropertyCallbackArguments;
class FunctionCallbackArguments;
};
+// Convenience wrapper.
+template <class T>
+inline Maybe<T> maybe(T t) {
+ return Maybe<T>(t);
+}
+
+
// --- Special objects ---
Handle<Value> resource_name,
Handle<Integer> resource_line_offset = Handle<Integer>(),
Handle<Integer> resource_column_offset = Handle<Integer>(),
- Handle<Boolean> resource_is_shared_cross_origin = Handle<Boolean>())
+ Handle<Boolean> resource_is_shared_cross_origin = Handle<Boolean>(),
+ Handle<Integer> script_id = Handle<Integer>())
: resource_name_(resource_name),
resource_line_offset_(resource_line_offset),
resource_column_offset_(resource_column_offset),
- resource_is_shared_cross_origin_(resource_is_shared_cross_origin) { }
+ resource_is_shared_cross_origin_(resource_is_shared_cross_origin),
+ script_id_(script_id) { }
V8_INLINE Handle<Value> ResourceName() const;
V8_INLINE Handle<Integer> ResourceLineOffset() const;
V8_INLINE Handle<Integer> ResourceColumnOffset() const;
V8_INLINE Handle<Boolean> ResourceIsSharedCrossOrigin() const;
+ V8_INLINE Handle<Integer> ScriptID() const;
private:
Handle<Value> resource_name_;
Handle<Integer> resource_line_offset_;
Handle<Integer> resource_column_offset_;
Handle<Boolean> resource_is_shared_cross_origin_;
+ Handle<Integer> script_id_;
};
Handle<Value> GetScriptName();
/**
+ * Data read from magic sourceURL comments.
+ */
+ Handle<Value> GetSourceURL();
+ /**
+ * Data read from magic sourceMappingURL comments.
+ */
+ Handle<Value> GetSourceMappingURL();
+
+ /**
* Returns zero based line number of the code_pos location in the script.
* -1 will be returned if no information available.
*/
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).
+ // Cached data from previous compilation (if a kConsume*Cache flag is
+ // set), or hold newly generated cache data (kProduce*Cache flags) are
+ // set when calling a compile method.
CachedData* cached_data;
};
+ /**
+ * For streaming incomplete script data to V8. The embedder should implement a
+ * subclass of this class.
+ */
+ class ExternalSourceStream {
+ public:
+ virtual ~ExternalSourceStream() {}
+
+ /**
+ * V8 calls this to request the next chunk of data from the embedder. This
+ * function will be called on a background thread, so it's OK to block and
+ * wait for the data, if the embedder doesn't have data yet. Returns the
+ * length of the data returned. When the data ends, GetMoreData should
+ * return 0. Caller takes ownership of the data.
+ *
+ * When streaming UTF-8 data, V8 handles multi-byte characters split between
+ * two data chunks, but doesn't handle multi-byte characters split between
+ * more than two data chunks. The embedder can avoid this problem by always
+ * returning at least 2 bytes of data.
+ *
+ * If the embedder wants to cancel the streaming, they should make the next
+ * GetMoreData call return 0. V8 will interpret it as end of data (and most
+ * probably, parsing will fail). The streaming task will return as soon as
+ * V8 has parsed the data it received so far.
+ */
+ virtual size_t GetMoreData(const uint8_t** src) = 0;
+ };
+
+
+ /**
+ * Source code which can be streamed into V8 in pieces. It will be parsed
+ * while streaming. It can be compiled after the streaming is complete.
+ * StreamedSource must be kept alive while the streaming task is ran (see
+ * ScriptStreamingTask below).
+ */
+ class V8_EXPORT StreamedSource {
+ public:
+ enum Encoding { ONE_BYTE, TWO_BYTE, UTF8 };
+
+ StreamedSource(ExternalSourceStream* source_stream, Encoding encoding);
+ ~StreamedSource();
+
+ // Ownership of the CachedData or its buffers is *not* transferred to the
+ // caller. The CachedData object is alive as long as the StreamedSource
+ // object is alive.
+ const CachedData* GetCachedData() const;
+
+ internal::StreamedSource* impl() const { return impl_; }
+
+ private:
+ // Prevent copying. Not implemented.
+ StreamedSource(const StreamedSource&);
+ StreamedSource& operator=(const StreamedSource&);
+
+ internal::StreamedSource* impl_;
+ };
+
+ /**
+ * A streaming task which the embedder must run on a background thread to
+ * stream scripts into V8. Returned by ScriptCompiler::StartStreamingScript.
+ */
+ class ScriptStreamingTask {
+ public:
+ virtual ~ScriptStreamingTask() {}
+ virtual void Run() = 0;
+ };
+
enum CompileOptions {
- kNoCompileOptions,
- kProduceDataToCache = 1 << 0
+ kNoCompileOptions = 0,
+ kProduceParserCache,
+ kConsumeParserCache,
+ kProduceCodeCache,
+ kConsumeCodeCache,
+
+ // Support the previous API for a transition period.
+ kProduceDataToCache
};
/**
* Compiles the specified script (context-independent).
+ * Cached data as part of the source object can be optionally produced to be
+ * consumed later to speed up compilation of identical source scripts.
+ *
+ * Note that when producing cached data, the source must point to NULL for
+ * cached data. When consuming cached data, the cached data must have been
+ * produced by the same version of V8.
*
* \param source Script source code.
* \return Compiled script object (context independent; for running it must be
static Local<Script> Compile(
Isolate* isolate, Source* source,
CompileOptions options = kNoCompileOptions);
+
+ /**
+ * Returns a task which streams script data into V8, or NULL if the script
+ * cannot be streamed. The user is responsible for running the task on a
+ * background thread and deleting it. When ran, the task starts parsing the
+ * script, and it will request data from the StreamedSource as needed. When
+ * ScriptStreamingTask::Run exits, all data has been streamed and the script
+ * can be compiled (see Compile below).
+ *
+ * This API allows to start the streaming with as little data as possible, and
+ * the remaining data (for example, the ScriptOrigin) is passed to Compile.
+ */
+ static ScriptStreamingTask* StartStreamingScript(
+ Isolate* isolate, StreamedSource* source,
+ CompileOptions options = kNoCompileOptions);
+
+ /**
+ * Compiles a streamed script (bound to current context).
+ *
+ * This can only be called after the streaming has finished
+ * (ScriptStreamingTask has been run). V8 doesn't construct the source string
+ * during streaming, so the embedder needs to pass the full source here.
+ */
+ static Local<Script> Compile(Isolate* isolate, StreamedSource* source,
+ Handle<String> full_source_string,
+ const ScriptOrigin& origin);
};
Local<String> GetSourceLine() const;
/**
+ * Returns the origin for the script from where the function causing the
+ * error originates.
+ */
+ ScriptOrigin GetScriptOrigin() const;
+
+ /**
* Returns the resource name for the script from where the function causing
* the error originates.
*/
bool IsFalse() const;
/**
+ * Returns true if this value is a symbol or a string.
+ * This is an experimental feature.
+ */
+ bool IsName() const;
+
+ /**
* Returns true if this value is an instance of the String type.
* See ECMA-262 8.4.
*/
bool IsDate() const;
/**
+ * Returns true if this value is an Arguments object.
+ */
+ bool IsArgumentsObject() const;
+
+ /**
* Returns true if this value is a Boolean object.
*/
bool IsBooleanObject() const;
bool IsPromise() const;
/**
+ * Returns true if this value is a Map.
+ * This is an experimental feature.
+ */
+ bool IsMap() const;
+
+ /**
+ * Returns true if this value is a Set.
+ * This is an experimental feature.
+ */
+ bool IsSet() const;
+
+ /**
+ * Returns true if this value is a WeakMap.
+ * This is an experimental feature.
+ */
+ bool IsWeakMap() const;
+
+ /**
+ * Returns true if this value is a WeakSet.
+ * This is an experimental feature.
+ */
+ bool IsWeakSet() const;
+
+ /**
* Returns true if this value is an ArrayBuffer.
* This is an experimental feature.
*/
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.
*/
/**
+ * A superclass for symbols and strings.
+ */
+class V8_EXPORT Name : public Primitive {
+ public:
+ V8_INLINE static Name* Cast(v8::Value* obj);
+ private:
+ static void CheckCast(v8::Value* obj);
+};
+
+
+/**
* A JavaScript string value (ECMA-262, 4.3.17).
*/
-class V8_EXPORT String : public Primitive {
+class V8_EXPORT String : public Name {
public:
enum Encoding {
UNKNOWN_ENCODING = 0x1,
TWO_BYTE_ENCODING = 0x0,
- ASCII_ENCODING = 0x4,
+ ASCII_ENCODING = 0x4, // TODO(yangguo): deprecate this.
ONE_BYTE_ENCODING = 0x4
};
/**
NO_OPTIONS = 0,
HINT_MANY_WRITES_EXPECTED = 1,
NO_NULL_TERMINATION = 2,
- PRESERVE_ASCII_NULL = 4,
+ PRESERVE_ASCII_NULL = 4, // TODO(yangguo): deprecate this.
+ PRESERVE_ONE_BYTE_NULL = 4,
// Used by WriteUtf8 to replace orphan surrogate code units with the
// unicode replacement character. Needs to be set to guarantee valid UTF-8
// output.
bool IsExternal() const;
/**
- * Returns true if the string is both external and ASCII
+ * Returns true if the string is both external and one-byte.
*/
- bool IsExternalAscii() const;
+ bool IsExternalOneByte() const;
+
+ // TODO(yangguo): deprecate this.
+ bool IsExternalAscii() const { return IsExternalOneByte(); }
class V8_EXPORT ExternalStringResourceBase { // NOLINT
public:
};
/**
- * An ExternalAsciiStringResource is a wrapper around an ASCII
+ * An ExternalOneByteStringResource is a wrapper around an one-byte
* string buffer that resides outside V8's heap. Implement an
- * ExternalAsciiStringResource to manage the life cycle of the
+ * ExternalOneByteStringResource to manage the life cycle of the
* underlying buffer. Note that the string data must be immutable
- * and that the data must be strict (7-bit) ASCII, not Latin-1 or
- * UTF-8, which would require special treatment internally in the
- * engine and, in the case of UTF-8, do not allow efficient indexing.
- * Use String::New or convert to 16 bit data for non-ASCII.
+ * and that the data must be Latin-1 and not UTF-8, which would require
+ * special treatment internally in the engine and do not allow efficient
+ * indexing. Use String::New or convert to 16 bit data for non-Latin1.
*/
- class V8_EXPORT ExternalAsciiStringResource
+ class V8_EXPORT ExternalOneByteStringResource
: public ExternalStringResourceBase {
public:
/**
* Override the destructor to manage the life cycle of the underlying
* buffer.
*/
- virtual ~ExternalAsciiStringResource() {}
+ virtual ~ExternalOneByteStringResource() {}
/** The string data from the underlying buffer.*/
virtual const char* data() const = 0;
- /** The number of ASCII characters in the string.*/
+ /** The number of Latin-1 characters in the string.*/
virtual size_t length() const = 0;
protected:
- ExternalAsciiStringResource() {}
+ ExternalOneByteStringResource() {}
};
- typedef ExternalAsciiStringResource ExternalOneByteStringResource;
+ typedef ExternalOneByteStringResource ExternalAsciiStringResource;
/**
* If the string is an external string, return the ExternalStringResourceBase
V8_INLINE ExternalStringResource* GetExternalStringResource() const;
/**
- * Get the ExternalAsciiStringResource for an external ASCII string.
- * Returns NULL if IsExternalAscii() doesn't return true.
+ * Get the ExternalOneByteStringResource for an external one-byte string.
+ * Returns NULL if IsExternalOneByte() doesn't return true.
*/
- const ExternalAsciiStringResource* GetExternalAsciiStringResource() const;
+ const ExternalOneByteStringResource* GetExternalOneByteStringResource() const;
+
+ // TODO(yangguo): deprecate this.
+ const ExternalAsciiStringResource* GetExternalAsciiStringResource() const {
+ return GetExternalOneByteStringResource();
+ }
V8_INLINE static String* Cast(v8::Value* obj);
bool MakeExternal(ExternalStringResource* resource);
/**
- * Creates a new external string using the ASCII data defined in the given
+ * Creates a new external string using the one-byte data defined in the given
* resource. When the external string is no longer live on V8's heap the
* resource will be disposed by calling its Dispose method. The caller of
* this function should not otherwise delete or modify the resource. Neither
* destructor of the external string resource.
*/
static Local<String> NewExternal(Isolate* isolate,
- ExternalAsciiStringResource* resource);
+ ExternalOneByteStringResource* resource);
/**
* Associate an external string resource with this string by transforming it
* The string is not modified if the operation fails. See NewExternal for
* information on the lifetime of the resource.
*/
- bool MakeExternal(ExternalAsciiStringResource* resource);
+ bool MakeExternal(ExternalOneByteStringResource* resource);
/**
* Returns true if this string can be made external.
*
* This is an experimental feature. Use at your own risk.
*/
-class V8_EXPORT Symbol : public Primitive {
+class V8_EXPORT Symbol : public Name {
public:
// Returns the print name string of the symbol, or undefined if none.
Local<Value> Name() const;
// registry that is not accessible by (and cannot clash with) JavaScript code.
static Local<Symbol> ForApi(Isolate *isolate, Local<String> name);
+ // Well-known symbols
+ static Local<Symbol> GetIterator(Isolate* isolate);
+ static Local<Symbol> GetUnscopables(Isolate* isolate);
+
V8_INLINE static Symbol* Cast(v8::Value* obj);
+
private:
Symbol();
static void CheckCast(v8::Value* obj);
kExternalInt16Array,
kExternalUint16Array,
kExternalInt32Array,
- kExternalInt32x4Array,
kExternalUint32Array,
kExternalFloat32Array,
- kExternalFloat32x4Array,
- kExternalFloat64x2Array,
kExternalFloat64Array,
kExternalUint8ClampedArray,
typedef void (*AccessorGetterCallback)(
Local<String> property,
const PropertyCallbackInfo<Value>& info);
+typedef void (*AccessorNameGetterCallback)(
+ Local<Name> property,
+ const PropertyCallbackInfo<Value>& info);
typedef void (*AccessorSetterCallback)(
Local<String> property,
Local<Value> value,
const PropertyCallbackInfo<void>& info);
+typedef void (*AccessorNameSetterCallback)(
+ Local<Name> property,
+ Local<Value> value,
+ const PropertyCallbackInfo<void>& info);
/**
*/
class V8_EXPORT Object : public Value {
public:
- bool Set(Handle<Value> key,
- Handle<Value> value,
- PropertyAttribute attribs = None);
+ bool Set(Handle<Value> key, Handle<Value> value);
bool Set(uint32_t index, Handle<Value> value);
*/
PropertyAttribute GetPropertyAttributes(Handle<Value> key);
+ /**
+ * Returns Object.getOwnPropertyDescriptor as per ES5 section 15.2.3.3.
+ */
+ Local<Value> GetOwnPropertyDescriptor(Local<String> key);
+
bool Has(Handle<Value> key);
bool Delete(Handle<Value> key);
Handle<Value> data = Handle<Value>(),
AccessControl settings = DEFAULT,
PropertyAttribute attribute = None);
+ bool SetAccessor(Handle<Name> name,
+ AccessorNameGetterCallback getter,
+ AccessorNameSetterCallback setter = 0,
+ Handle<Value> data = Handle<Value>(),
+ AccessControl settings = DEFAULT,
+ PropertyAttribute attribute = None);
// This function is not yet stable and should not be used at this time.
- bool SetDeclaredAccessor(Local<String> name,
+ bool SetDeclaredAccessor(Local<Name> name,
Local<DeclaredAccessorDescriptor> descriptor,
PropertyAttribute attribute = None,
AccessControl settings = DEFAULT);
- void SetAccessorProperty(Local<String> name,
+ void SetAccessorProperty(Local<Name> name,
Local<Function> getter,
Handle<Function> setter = Handle<Function>(),
PropertyAttribute attribute = None,
Local<String> ObjectProtoToString();
/**
- * Returns the function invoked as a constructor for this object.
- * May be the null value.
- */
- Local<Value> GetConstructor();
-
- /**
* Returns the name of the function invoked as a constructor for this object.
*/
Local<String> GetConstructorName();
};
-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.
class V8_EXPORT Template : public Data {
public:
/** Adds a property to each instance created by this template.*/
- void Set(Handle<String> name, Handle<Data> value,
+ void Set(Handle<Name> name, Handle<Data> value,
PropertyAttribute attributes = None);
V8_INLINE void Set(Isolate* isolate, const char* name, Handle<Data> value);
void SetAccessorProperty(
- Local<String> name,
+ Local<Name> name,
Local<FunctionTemplate> getter = Local<FunctionTemplate>(),
Local<FunctionTemplate> setter = Local<FunctionTemplate>(),
PropertyAttribute attribute = None,
Local<AccessorSignature> signature =
Local<AccessorSignature>(),
AccessControl settings = DEFAULT);
+ void SetNativeDataProperty(Local<Name> name,
+ AccessorNameGetterCallback getter,
+ AccessorNameSetterCallback setter = 0,
+ // TODO(dcarney): gcc can't handle Local below
+ Handle<Value> data = Handle<Value>(),
+ PropertyAttribute attribute = None,
+ Local<AccessorSignature> signature =
+ Local<AccessorSignature>(),
+ AccessControl settings = DEFAULT);
// This function is not yet stable and should not be used at this time.
- bool SetDeclaredAccessor(Local<String> name,
+ bool SetDeclaredAccessor(Local<Name> name,
Local<DeclaredAccessorDescriptor> descriptor,
PropertyAttribute attribute = None,
Local<AccessorSignature> signature =
PropertyAttribute attribute = None,
Handle<AccessorSignature> signature =
Handle<AccessorSignature>());
+ void SetAccessor(Handle<Name> name,
+ AccessorNameGetterCallback getter,
+ AccessorNameSetterCallback setter = 0,
+ Handle<Value> data = Handle<Value>(),
+ AccessControl settings = DEFAULT,
+ PropertyAttribute attribute = None,
+ Handle<AccessorSignature> signature =
+ Handle<AccessorSignature>());
/**
* Sets a named property handler on the object template.
*
- * Whenever a named property is accessed on objects created from
- * this object template, the provided callback is invoked instead of
+ * Whenever a property whose name is a string is accessed on objects created
+ * from this object template, the provided callback is invoked instead of
* accessing the property directly on the JavaScript object.
*
* \param getter The callback to invoke when getting a property.
// --- Extensions ---
-class V8_EXPORT ExternalAsciiStringResourceImpl
- : public String::ExternalAsciiStringResource {
+class V8_EXPORT ExternalOneByteStringResourceImpl
+ : public String::ExternalOneByteStringResource {
public:
- ExternalAsciiStringResourceImpl() : data_(0), length_(0) {}
- ExternalAsciiStringResourceImpl(const char* data, size_t length)
+ ExternalOneByteStringResourceImpl() : data_(0), length_(0) {}
+ ExternalOneByteStringResourceImpl(const char* data, size_t length)
: data_(data), length_(length) {}
const char* data() const { return data_; }
size_t length() const { return length_; }
const char* name() const { return name_; }
size_t source_length() const { return source_length_; }
- const String::ExternalAsciiStringResource* source() const {
+ const String::ExternalOneByteStringResource* source() const {
return &source_; }
int dependency_count() { return dep_count_; }
const char** dependencies() { return deps_; }
private:
const char* name_;
size_t source_length_; // expected to initialize before source_
- ExternalAsciiStringResourceImpl source_;
+ ExternalOneByteStringResourceImpl source_;
int dep_count_;
const char** deps_;
bool auto_enable_;
};
-/**
- * Sets the given ResourceConstraints on the given Isolate.
- */
-bool V8_EXPORT SetResourceConstraints(Isolate* isolate,
- ResourceConstraints* constraints);
-
-
// --- Exceptions ---
class RetainedObjectInfo;
+
/**
- * Isolate represents an isolated instance of the V8 engine. V8
- * isolates have completely separate states. Objects from one isolate
- * must not be used in other isolates. When V8 is initialized a
- * default isolate is implicitly created and entered. The embedder
- * can create additional isolates and use them in parallel in multiple
- * threads. An isolate can be entered by at most one thread at any
- * given time. The Locker/Unlocker API must be used to synchronize.
+ * FunctionEntryHook is the type of the profile entry hook called at entry to
+ * any generated function when function-level profiling is enabled.
+ *
+ * \param function the address of the function that's being entered.
+ * \param return_addr_location points to a location on stack where the machine
+ * return address resides. This can be used to identify the caller of
+ * \p function, and/or modified to divert execution when \p function exits.
+ *
+ * \note the entry hook must not cause garbage collection.
*/
-class V8_EXPORT Isolate {
- public:
- /**
- * Stack-allocated class which sets the isolate for all operations
- * executed within a local scope.
- */
- class V8_EXPORT Scope {
- public:
- explicit Scope(Isolate* isolate) : isolate_(isolate) {
- isolate->Enter();
- }
+typedef void (*FunctionEntryHook)(uintptr_t function,
+ uintptr_t return_addr_location);
- ~Scope() { isolate_->Exit(); }
+/**
+ * A JIT code event is issued each time code is added, moved or removed.
+ *
+ * \note removal events are not currently issued.
+ */
+struct JitCodeEvent {
+ enum EventType {
+ CODE_ADDED,
+ CODE_MOVED,
+ CODE_REMOVED,
+ CODE_ADD_LINE_POS_INFO,
+ CODE_START_LINE_INFO_RECORDING,
+ CODE_END_LINE_INFO_RECORDING
+ };
+ // Definition of the code position type. The "POSITION" type means the place
+ // in the source code which are of interest when making stack traces to
+ // pin-point the source location of a stack frame as close as possible.
+ // The "STATEMENT_POSITION" means the place at the beginning of each
+ // statement, and is used to indicate possible break locations.
+ enum PositionType { POSITION, STATEMENT_POSITION };
- private:
- Isolate* const isolate_;
+ // Type of event.
+ EventType type;
+ // Start of the instructions.
+ void* code_start;
+ // Size of the instructions.
+ size_t code_len;
+ // Script info for CODE_ADDED event.
+ Handle<UnboundScript> script;
+ // User-defined data for *_LINE_INFO_* event. It's used to hold the source
+ // code line information which is returned from the
+ // CODE_START_LINE_INFO_RECORDING event. And it's passed to subsequent
+ // CODE_ADD_LINE_POS_INFO and CODE_END_LINE_INFO_RECORDING events.
+ void* user_data;
- // Prevent copying of Scope objects.
- Scope(const Scope&);
- Scope& operator=(const Scope&);
+ struct name_t {
+ // Name of the object associated with the code, note that the string is not
+ // zero-terminated.
+ const char* str;
+ // Number of chars in str.
+ size_t len;
};
+ struct line_info_t {
+ // PC offset
+ size_t offset;
+ // Code postion
+ size_t pos;
+ // The position type.
+ PositionType position_type;
+ };
- /**
- * 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();
+ union {
+ // Only valid for CODE_ADDED.
+ struct name_t name;
- private:
- bool on_failure_;
- void* internal_;
+ // Only valid for CODE_ADD_LINE_POS_INFO
+ struct line_info_t line_info;
- // Prevent copying of Scope objects.
- DisallowJavascriptExecutionScope(const DisallowJavascriptExecutionScope&);
- DisallowJavascriptExecutionScope& operator=(
- const DisallowJavascriptExecutionScope&);
+ // New location of instructions. Only valid for CODE_MOVED.
+ void* new_code_start;
};
+};
+/**
+ * Option flags passed to the SetJitCodeEventHandler function.
+ */
+enum JitCodeEventOptions {
+ kJitCodeEventDefault = 0,
+ // Generate callbacks for already existent code.
+ kJitCodeEventEnumExisting = 1
+};
- /**
- * Introduce exception to DisallowJavascriptExecutionScope.
- */
+
+/**
+ * Callback function passed to SetJitCodeEventHandler.
+ *
+ * \param event code add, move or removal event.
+ */
+typedef void (*JitCodeEventHandler)(const JitCodeEvent* event);
+
+
+/**
+ * Isolate represents an isolated instance of the V8 engine. V8 isolates have
+ * completely separate states. Objects from one isolate must not be used in
+ * other isolates. The embedder can create multiple isolates and use them in
+ * parallel in multiple threads. An isolate can be entered by at most one
+ * thread at any given time. The Locker/Unlocker API must be used to
+ * synchronize.
+ */
+class V8_EXPORT Isolate {
+ public:
+ /**
+ * Initial configuration parameters for a new Isolate.
+ */
+ struct CreateParams {
+ CreateParams()
+ : entry_hook(NULL),
+ code_event_handler(NULL),
+ enable_serializer(false) {}
+
+ /**
+ * The optional entry_hook allows the host application to provide the
+ * address of a function that's invoked on entry to every V8-generated
+ * function. Note that entry_hook is invoked at the very start of each
+ * generated function. Furthermore, if an entry_hook is given, V8 will
+ * always run without a context snapshot.
+ */
+ FunctionEntryHook entry_hook;
+
+ /**
+ * Allows the host application to provide the address of a function that is
+ * notified each time code is added, moved or removed.
+ */
+ JitCodeEventHandler code_event_handler;
+
+ /**
+ * ResourceConstraints to use for the new Isolate.
+ */
+ ResourceConstraints constraints;
+
+ /**
+ * This flag currently renders the Isolate unusable.
+ */
+ bool enable_serializer;
+ };
+
+
+ /**
+ * Stack-allocated class which sets the isolate for all operations
+ * executed within a local scope.
+ */
+ class V8_EXPORT Scope {
+ public:
+ explicit Scope(Isolate* isolate) : isolate_(isolate) {
+ isolate->Enter();
+ }
+
+ ~Scope() { isolate_->Exit(); }
+
+ private:
+ Isolate* const isolate_;
+
+ // Prevent copying of Scope objects.
+ Scope(const Scope&);
+ 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);
};
/**
+ * Features reported via the SetUseCounterCallback callback. Do not chang
+ * assigned numbers of existing items; add new features to the end of this
+ * list.
+ */
+ enum UseCounterFeature {
+ kUseAsm = 0,
+ kUseCounterFeatureCount // This enum value must be last.
+ };
+
+ typedef void (*UseCounterCallback)(Isolate* isolate,
+ UseCounterFeature feature);
+
+
+ /**
* Creates a new isolate. Does not change the currently entered
* isolate.
*
* When an isolate is no longer used its resources should be freed
* by calling Dispose(). Using the delete operator is not allowed.
+ *
+ * V8::Initialize() must have run prior to this.
*/
- static Isolate* New();
+ static Isolate* New(const CreateParams& params = CreateParams());
/**
* Returns the entered isolate for the current thread or NULL in
*/
bool WillAutorunMicrotasks() const;
+ /**
+ * Sets a callback for counting the number of times a feature of V8 is used.
+ */
+ void SetUseCounterCallback(UseCounterCallback callback);
+
+ /**
+ * Enables the host application to provide a mechanism for recording
+ * statistics counters.
+ */
+ void SetCounterFunction(CounterLookupCallback);
+
+ /**
+ * Enables the host application to provide a mechanism for recording
+ * histograms. The CreateHistogram function returns a
+ * histogram which will later be passed to the AddHistogramSample
+ * function.
+ */
+ void SetCreateHistogramFunction(CreateHistogramCallback);
+ void SetAddHistogramSampleFunction(AddHistogramSampleCallback);
+
+ /**
+ * Optional notification that the embedder is idle.
+ * V8 uses the notification to reduce memory footprint.
+ * This call can be used repeatedly if the embedder remains idle.
+ * Returns true if the embedder should stop calling IdleNotification
+ * until real work has been done. This indicates that V8 has done
+ * as much cleanup as it will be able to do.
+ *
+ * The idle_time_in_ms argument specifies the time V8 has to do reduce
+ * the memory footprint. There is no guarantee that the actual work will be
+ * done within the time limit.
+ */
+ bool IdleNotification(int idle_time_in_ms);
+
+ /**
+ * Optional notification that the system is running low on memory.
+ * V8 uses these notifications to attempt to free memory.
+ */
+ void LowMemoryNotification();
+
+ /**
+ * Optional notification that a context has been disposed. V8 uses
+ * these notifications to guide the GC heuristic. Returns the number
+ * of context disposals - including this one - since the last time
+ * V8 had a chance to clean up.
+ */
+ int ContextDisposedNotification();
+
+ /**
+ * Allows the host application to provide the address of a function that is
+ * notified each time code is added, moved or removed.
+ *
+ * \param options options for the JIT code event handler.
+ * \param event_handler the JIT code event handler, which will be invoked
+ * each time code is added, moved or removed.
+ * \note \p event_handler won't get notified of existent code.
+ * \note since code removal notifications are not currently issued, the
+ * \p event_handler may get notifications of code that overlaps earlier
+ * code notifications. This happens when code areas are reused, and the
+ * earlier overlapping code areas should therefore be discarded.
+ * \note the events passed to \p event_handler and the strings they point to
+ * are not guaranteed to live past each call. The \p event_handler must
+ * copy strings and other parameters it needs to keep around.
+ * \note the set of events declared in JitCodeEvent::EventType is expected to
+ * grow over time, and the JitCodeEvent structure is expected to accrue
+ * new members. The \p event_handler function must ignore event codes
+ * it does not recognize to maintain future compatibility.
+ * \note Use Isolate::CreateParams to get events for code executed during
+ * Isolate setup.
+ */
+ void SetJitCodeEventHandler(JitCodeEventOptions options,
+ JitCodeEventHandler event_handler);
+
+ /**
+ * Modifies the stack limit for this Isolate.
+ *
+ * \param stack_limit An address beyond which the Vm's stack may not grow.
+ *
+ * \note If you are using threads then you should hold the V8::Locker lock
+ * while setting the stack limit and you must set a non-default stack
+ * limit separately for each thread.
+ */
+ void SetStackLimit(uintptr_t stack_limit);
+
private:
template<class K, class V, class Traits> friend class PersistentValueMap;
/**
- * FunctionEntryHook is the type of the profile entry hook called at entry to
- * any generated function when function-level profiling is enabled.
- *
- * \param function the address of the function that's being entered.
- * \param return_addr_location points to a location on stack where the machine
- * return address resides. This can be used to identify the caller of
- * \p function, and/or modified to divert execution when \p function exits.
- *
- * \note the entry hook must not cause garbage collection.
- */
-typedef void (*FunctionEntryHook)(uintptr_t function,
- uintptr_t return_addr_location);
-
-
-/**
- * A JIT code event is issued each time code is added, moved or removed.
- *
- * \note removal events are not currently issued.
- */
-struct JitCodeEvent {
- enum EventType {
- CODE_ADDED,
- CODE_MOVED,
- CODE_REMOVED,
- CODE_ADD_LINE_POS_INFO,
- CODE_START_LINE_INFO_RECORDING,
- CODE_END_LINE_INFO_RECORDING
- };
- // Definition of the code position type. The "POSITION" type means the place
- // in the source code which are of interest when making stack traces to
- // pin-point the source location of a stack frame as close as possible.
- // The "STATEMENT_POSITION" means the place at the beginning of each
- // statement, and is used to indicate possible break locations.
- enum PositionType {
- POSITION,
- STATEMENT_POSITION
- };
-
- // Type of event.
- EventType type;
- // Start of the instructions.
- void* code_start;
- // Size of the instructions.
- size_t code_len;
- // Script info for CODE_ADDED event.
- Handle<Script> script;
- // User-defined data for *_LINE_INFO_* event. It's used to hold the source
- // code line information which is returned from the
- // CODE_START_LINE_INFO_RECORDING event. And it's passed to subsequent
- // CODE_ADD_LINE_POS_INFO and CODE_END_LINE_INFO_RECORDING events.
- void* user_data;
-
- struct name_t {
- // Name of the object associated with the code, note that the string is not
- // zero-terminated.
- const char* str;
- // Number of chars in str.
- size_t len;
- };
-
- struct line_info_t {
- // PC offset
- size_t offset;
- // Code postion
- size_t pos;
- // The position type.
- PositionType position_type;
- };
-
- union {
- // Only valid for CODE_ADDED.
- struct name_t name;
-
- // Only valid for CODE_ADD_LINE_POS_INFO
- struct line_info_t line_info;
-
- // New location of instructions. Only valid for CODE_MOVED.
- void* new_code_start;
- };
-};
-
-/**
- * Option flags passed to the SetJitCodeEventHandler function.
- */
-enum JitCodeEventOptions {
- kJitCodeEventDefault = 0,
- // Generate callbacks for already existent code.
- kJitCodeEventEnumExisting = 1
-};
-
-
-/**
- * Callback function passed to SetJitCodeEventHandler.
- *
- * \param event code add, move or removal event.
- */
-typedef void (*JitCodeEventHandler)(const JitCodeEvent* event);
-
-
-/**
* Interface for iterating through all external resources in the heap.
*/
class V8_EXPORT ExternalResourceVisitor { // NOLINT
static void SetDecompressedStartupData(StartupData* decompressed_data);
/**
+ * Hand startup data to V8, in case the embedder has chosen to build
+ * V8 with external startup data.
+ *
+ * Note:
+ * - By default the startup data is linked into the V8 library, in which
+ * case this function is not meaningful.
+ * - If this needs to be called, it needs to be called before V8
+ * tries to make use of its built-ins.
+ * - To avoid unnecessary copies of data, V8 will point directly into the
+ * given data blob, so pretty please keep it around until V8 exit.
+ * - Compression of the startup blob might be useful, but needs to
+ * handled entirely on the embedders' side.
+ * - The call will abort if the data is invalid.
+ */
+ static void SetNativesDataBlob(StartupData* startup_blob);
+ static void SetSnapshotDataBlob(StartupData* startup_blob);
+
+ /**
* Adds a message listener.
*
* The same message listener can be added more than once and in that
/** Get the version string. */
static const char* GetVersion();
- /**
- * Enables the host application to provide a mechanism for recording
- * statistics counters.
- */
- static void SetCounterFunction(CounterLookupCallback);
-
- /**
- * Enables the host application to provide a mechanism for recording
- * histograms. The CreateHistogram function returns a
- * histogram which will later be passed to the AddHistogramSample
- * function.
- */
- static void SetCreateHistogramFunction(CreateHistogramCallback);
- static void SetAddHistogramSampleFunction(AddHistogramSampleCallback);
-
/** Callback function for reporting failed access checks.*/
static void SetFailedAccessCheckCallbackFunction(FailedAccessCheckCallback);
static void RemoveMemoryAllocationCallback(MemoryAllocationCallback callback);
/**
- * Initializes from snapshot if possible. Otherwise, attempts to
- * initialize from scratch. This function is called implicitly if
- * you use the API without calling it first.
+ * Initializes V8. This function needs to be called before the first Isolate
+ * is created. It always returns true.
*/
static bool Initialize();
ReturnAddressLocationResolver return_address_resolver);
/**
- * Allows the host application to provide the address of a function that's
- * invoked on entry to every V8-generated function.
- * Note that \p entry_hook is invoked at the very start of each
- * generated function.
- *
- * \param isolate the isolate to operate on.
- * \param entry_hook a function that will be invoked on entry to every
- * V8-generated function.
- * \returns true on success on supported platforms, false on failure.
- * \note Setting an entry hook can only be done very early in an isolates
- * lifetime, and once set, the entry hook cannot be revoked.
- */
- static bool SetFunctionEntryHook(Isolate* isolate,
- FunctionEntryHook entry_hook);
-
- /**
- * Allows the host application to provide the address of a function that is
- * notified each time code is added, moved or removed.
- *
- * \param options options for the JIT code event handler.
- * \param event_handler the JIT code event handler, which will be invoked
- * each time code is added, moved or removed.
- * \note \p event_handler won't get notified of existent code.
- * \note since code removal notifications are not currently issued, the
- * \p event_handler may get notifications of code that overlaps earlier
- * code notifications. This happens when code areas are reused, and the
- * earlier overlapping code areas should therefore be discarded.
- * \note the events passed to \p event_handler and the strings they point to
- * are not guaranteed to live past each call. The \p event_handler must
- * copy strings and other parameters it needs to keep around.
- * \note the set of events declared in JitCodeEvent::EventType is expected to
- * grow over time, and the JitCodeEvent structure is expected to accrue
- * new members. The \p event_handler function must ignore event codes
- * it does not recognize to maintain future compatibility.
- */
- static void SetJitCodeEventHandler(JitCodeEventOptions options,
- JitCodeEventHandler event_handler);
-
- /**
* Forcefully terminate the current thread of JavaScript execution
* in the given isolate.
*
Isolate* isolate, PersistentHandleVisitor* visitor);
/**
- * Optional notification that the embedder is idle.
- * V8 uses the notification to reduce memory footprint.
- * This call can be used repeatedly if the embedder remains idle.
- * Returns true if the embedder should stop calling IdleNotification
- * until real work has been done. This indicates that V8 has done
- * as much cleanup as it will be able to do.
- *
- * The hint argument specifies the amount of work to be done in the function
- * on scale from 1 to 1000. There is no guarantee that the actual work will
- * match the hint.
- */
- static bool IdleNotification(int hint = 1000);
-
- /**
- * Optional notification that the system is running low on memory.
- * V8 uses these notifications to attempt to free memory.
- */
- static void LowMemoryNotification();
-
- /**
- * Optional notification that a context has been disposed. V8 uses
- * these notifications to guide the GC heuristic. Returns the number
- * of context disposals - including this one - since the last time
- * V8 had a chance to clean up.
- */
- static int ContextDisposedNotification();
-
- /**
* Initialize the ICU library bundled with V8. The embedder should only
* invoke this method when using the bundled ICU. Returns true on success.
*
/**
* Clears any exceptions that may have been caught by this try/catch block.
- * After this method has been called, HasCaught() will return false.
+ * After this method has been called, HasCaught() will return false. Cancels
+ * the scheduled exception if it is caught and ReThrow() is not called before.
*
* It is not necessary to clear a try/catch block before using it again; if
* another exception is thrown the previously caught exception will just be
}
private:
+ void ResetInternal();
+
// Make it hard to create heap-allocated TryCatch blocks.
TryCatch(const TryCatch&);
void operator=(const TryCatch&);
*/
void Exit();
- /**
- * 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();
template<int kSmiShiftSize>
V8_INLINE internal::Object* IntToSmi(int value) {
int smi_shift_bits = kSmiTagSize + kSmiShiftSize;
- intptr_t tagged_value =
- (static_cast<intptr_t>(value) << smi_shift_bits) | kSmiTag;
+ uintptr_t tagged_value =
+ (static_cast<uintptr_t>(value) << smi_shift_bits) | kSmiTag;
return reinterpret_cast<internal::Object*>(tagged_value);
}
// Smi constants for 32-bit systems.
template <> struct SmiTagging<4> {
- static const int kSmiShiftSize = 0;
- static const int kSmiValueSize = 31;
- V8_INLINE static int SmiToInt(internal::Object* value) {
+ enum { kSmiShiftSize = 0, kSmiValueSize = 31 };
+ static int SmiShiftSize() { return kSmiShiftSize; }
+ static int SmiValueSize() { return kSmiValueSize; }
+ V8_INLINE static int SmiToInt(const internal::Object* value) {
int shift_bits = kSmiTagSize + kSmiShiftSize;
// Throw away top 32 bits and shift down (requires >> to be sign extending).
return static_cast<int>(reinterpret_cast<intptr_t>(value)) >> shift_bits;
// Smi constants for 64-bit systems.
template <> struct SmiTagging<8> {
- static const int kSmiShiftSize = 31;
- static const int kSmiValueSize = 32;
- V8_INLINE static int SmiToInt(internal::Object* value) {
+ enum { kSmiShiftSize = 31, kSmiValueSize = 32 };
+ static int SmiShiftSize() { return kSmiShiftSize; }
+ static int SmiValueSize() { return kSmiValueSize; }
+ V8_INLINE static int SmiToInt(const internal::Object* value) {
int shift_bits = kSmiTagSize + kSmiShiftSize;
// Shift down and throw away top 32 bits.
return static_cast<int>(reinterpret_cast<intptr_t>(value) >> shift_bits);
// These values match non-compiler-dependent values defined within
// the implementation of v8.
static const int kHeapObjectMapOffset = 0;
- static const int kMapInstanceTypeOffset = 1 * kApiPointerSize + kApiIntSize;
+ static const int kMapInstanceTypeAndBitFieldOffset =
+ 1 * kApiPointerSize + kApiIntSize;
static const int kStringResourceOffset = 3 * kApiPointerSize;
static const int kOddballKindOffset = 3 * kApiPointerSize;
static const int kJSObjectHeaderSize = 3 * kApiPointerSize;
static const int kFixedArrayHeaderSize = 2 * kApiPointerSize;
static const int kContextHeaderSize = 2 * kApiPointerSize;
- static const int kContextEmbedderDataIndex = 89;
+ static const int kContextEmbedderDataIndex = 95;
static const int kFullStringRepresentationMask = 0x07;
static const int kStringEncodingMask = 0x4;
static const int kExternalTwoByteRepresentationTag = 0x02;
- static const int kExternalAsciiRepresentationTag = 0x06;
+ static const int kExternalOneByteRepresentationTag = 0x06;
static const int kIsolateEmbedderDataOffset = 0 * kApiPointerSize;
static const int kAmountOfExternalAllocatedMemoryOffset =
static const int kNullValueRootIndex = 7;
static const int kTrueValueRootIndex = 8;
static const int kFalseValueRootIndex = 9;
- static const int kEmptyStringRootIndex = 175;
+ static const int kEmptyStringRootIndex = 164;
// The external allocation limit should be below 256 MB on all architectures
// to avoid that resource-constrained embedders run low on memory.
static const int kNodeIsIndependentShift = 4;
static const int kNodeIsPartiallyDependentShift = 5;
- static const int kJSObjectType = 0xc1;
+ static const int kJSObjectType = 0xbc;
static const int kFirstNonstringType = 0x80;
static const int kOddballType = 0x83;
- static const int kForeignType = 0x87;
+ static const int kForeignType = 0x88;
static const int kUndefinedOddballKind = 5;
static const int kNullOddballKind = 3;
#endif
}
- V8_INLINE static bool HasHeapObjectTag(internal::Object* value) {
+ V8_INLINE static bool HasHeapObjectTag(const internal::Object* value) {
return ((reinterpret_cast<intptr_t>(value) & kHeapObjectTagMask) ==
kHeapObjectTag);
}
- V8_INLINE static int SmiValue(internal::Object* value) {
+ V8_INLINE static int SmiValue(const internal::Object* value) {
return PlatformSmiTagging::SmiToInt(value);
}
return PlatformSmiTagging::IsValidSmi(value);
}
- V8_INLINE static int GetInstanceType(internal::Object* obj) {
+ V8_INLINE static int GetInstanceType(const internal::Object* obj) {
typedef internal::Object O;
O* map = ReadField<O*>(obj, kHeapObjectMapOffset);
- return ReadField<uint8_t>(map, kMapInstanceTypeOffset);
+ // Map::InstanceType is defined so that it will always be loaded into
+ // the LS 8 bits of one 16-bit word, regardless of endianess.
+ return ReadField<uint16_t>(map, kMapInstanceTypeAndBitFieldOffset) & 0xff;
}
- V8_INLINE static int GetOddballKind(internal::Object* obj) {
+ V8_INLINE static int GetOddballKind(const internal::Object* obj) {
typedef internal::Object O;
return SmiValue(ReadField<O*>(obj, kOddballKindOffset));
}
V8_INLINE static void UpdateNodeFlag(internal::Object** obj,
bool value, int shift) {
uint8_t* addr = reinterpret_cast<uint8_t*>(obj) + kNodeFlagsOffset;
- uint8_t mask = static_cast<uint8_t>(1 << shift);
+ uint8_t mask = static_cast<uint8_t>(1U << shift);
*addr = static_cast<uint8_t>((*addr & ~mask) | (value << shift));
}
*addr = static_cast<uint8_t>((*addr & ~kNodeStateMask) | value);
}
- V8_INLINE static void SetEmbedderData(v8::Isolate *isolate,
+ V8_INLINE static void SetEmbedderData(v8::Isolate* isolate,
uint32_t slot,
- void *data) {
+ void* data) {
uint8_t *addr = reinterpret_cast<uint8_t *>(isolate) +
kIsolateEmbedderDataOffset + slot * kApiPointerSize;
*reinterpret_cast<void**>(addr) = data;
}
- V8_INLINE static void* GetEmbedderData(v8::Isolate* isolate, uint32_t slot) {
- uint8_t* addr = reinterpret_cast<uint8_t*>(isolate) +
+ V8_INLINE static void* GetEmbedderData(const v8::Isolate* isolate,
+ uint32_t slot) {
+ const uint8_t* addr = reinterpret_cast<const uint8_t*>(isolate) +
kIsolateEmbedderDataOffset + slot * kApiPointerSize;
- return *reinterpret_cast<void**>(addr);
+ return *reinterpret_cast<void* const*>(addr);
}
V8_INLINE static internal::Object** GetRoot(v8::Isolate* isolate,
}
template <typename T>
- V8_INLINE static T ReadField(internal::Object* ptr, int offset) {
- uint8_t* addr = reinterpret_cast<uint8_t*>(ptr) + offset - kHeapObjectTag;
- return *reinterpret_cast<T*>(addr);
+ V8_INLINE static T ReadField(const internal::Object* ptr, int offset) {
+ const uint8_t* addr =
+ reinterpret_cast<const uint8_t*>(ptr) + offset - kHeapObjectTag;
+ return *reinterpret_cast<const T*>(addr);
}
template <typename T>
- V8_INLINE static T ReadEmbedderData(v8::Context* context, int index) {
+ V8_INLINE static T ReadEmbedderData(const v8::Context* context, int index) {
typedef internal::Object O;
typedef internal::Internals I;
- O* ctx = *reinterpret_cast<O**>(context);
+ O* ctx = *reinterpret_cast<O* const*>(context);
int embedder_data_offset = I::kContextHeaderSize +
(internal::kApiPointerSize * I::kContextEmbedderDataIndex);
O* embedder_data = I::ReadField<O*>(ctx, embedder_data_offset);
return resource_column_offset_;
}
+
Handle<Boolean> ScriptOrigin::ResourceIsSharedCrossOrigin() const {
return resource_is_shared_cross_origin_;
}
+Handle<Integer> ScriptOrigin::ScriptID() const {
+ return script_id_;
+}
+
+
ScriptCompiler::Source::Source(Local<String> string, const ScriptOrigin& origin,
CachedData* data)
: source_string(string),
String::ExternalStringResource* String::GetExternalStringResource() const {
typedef internal::Object O;
typedef internal::Internals I;
- O* obj = *reinterpret_cast<O**>(const_cast<String*>(this));
+ O* obj = *reinterpret_cast<O* const*>(this);
String::ExternalStringResource* result;
if (I::IsExternalTwoByteString(I::GetInstanceType(obj))) {
void* value = I::ReadField<void*>(obj, I::kStringResourceOffset);
String::Encoding* encoding_out) const {
typedef internal::Object O;
typedef internal::Internals I;
- O* obj = *reinterpret_cast<O**>(const_cast<String*>(this));
+ O* obj = *reinterpret_cast<O* const*>(this);
int type = I::GetInstanceType(obj) & I::kFullStringRepresentationMask;
*encoding_out = static_cast<Encoding>(type & I::kStringEncodingMask);
ExternalStringResourceBase* resource = NULL;
- if (type == I::kExternalAsciiRepresentationTag ||
+ if (type == I::kExternalOneByteRepresentationTag ||
type == I::kExternalTwoByteRepresentationTag) {
void* value = I::ReadField<void*>(obj, I::kStringResourceOffset);
resource = static_cast<ExternalStringResourceBase*>(value);
bool Value::QuickIsUndefined() const {
typedef internal::Object O;
typedef internal::Internals I;
- O* obj = *reinterpret_cast<O**>(const_cast<Value*>(this));
+ O* obj = *reinterpret_cast<O* const*>(this);
if (!I::HasHeapObjectTag(obj)) return false;
if (I::GetInstanceType(obj) != I::kOddballType) return false;
return (I::GetOddballKind(obj) == I::kUndefinedOddballKind);
bool Value::QuickIsNull() const {
typedef internal::Object O;
typedef internal::Internals I;
- O* obj = *reinterpret_cast<O**>(const_cast<Value*>(this));
+ O* obj = *reinterpret_cast<O* const*>(this);
if (!I::HasHeapObjectTag(obj)) return false;
if (I::GetInstanceType(obj) != I::kOddballType) return false;
return (I::GetOddballKind(obj) == I::kNullOddballKind);
bool Value::QuickIsString() const {
typedef internal::Object O;
typedef internal::Internals I;
- O* obj = *reinterpret_cast<O**>(const_cast<Value*>(this));
+ O* obj = *reinterpret_cast<O* const*>(this);
if (!I::HasHeapObjectTag(obj)) return false;
return (I::GetInstanceType(obj) < I::kFirstNonstringType);
}
}
+Name* Name::Cast(v8::Value* value) {
+#ifdef V8_ENABLE_CHECKS
+ CheckCast(value);
+#endif
+ return static_cast<Name*>(value);
+}
+
+
Symbol* Symbol::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);
projects / platform / framework / web / crosswalk.git / blobdiff