v8 Namespace Reference

Debugger support for the V8 JavaScript engine. More...

Namespaces
	anonymous_namespace{api.cc}
	base
	internal
	platform

Classes
struct	OneByteMask
struct	OneByteMask< 4 >
struct	OneByteMask< 8 >
class	ContainsOnlyOneByteHelper
class	Utf8LengthHelper
class	Utf8WriterVisitor
class	VisitorAdapter
class	Consts
class	NeanderObject
class	NeanderArray
class	ApiFunction
class	RegisteredExtension
class	Utils
class	Handle
	An object reference managed by the v8 garbage collector. More...
class	ZombieProtector
class	OpenFDCloser
class	ExecArgs
class	ReadLineEditor
class	PerIsolateData
class	DumbLineEditor
struct	CounterAndKey
struct	DataAndPersistent
class	ShellArrayBufferAllocator
class	MockArrayBufferAllocator
class	Counter
class	CounterCollection
class	CounterMap
class	LineEditor
class	SourceGroup
class	BinaryResource
class	ShellOptions
class	Shell
class	TestWithIsolate
class	TestWithContext
class	Debug
class	Task
	A Task represents a unit of work. More...
class	Platform
	V8 Platform abstraction layer. More...
class	CpuProfileNode
	CpuProfileNode represents a node in a call graph. More...
class	CpuProfile
	CpuProfile contains a CPU profile in a form of top-down call tree (from main() down to functions that do all the work). More...
class	CpuProfiler
	Interface for controlling CPU profiling. More...
class	HeapGraphEdge
	HeapSnapshotEdge represents a directed connection between heap graph nodes: from retainers to retained nodes. More...
class	HeapGraphNode
	HeapGraphNode represents a node in a heap graph. More...
class	OutputStream
	An interface for exporting data from V8, using "push" model. More...
class	HeapSnapshot
	HeapSnapshots record the state of the JS heap at some moment. More...
class	ActivityControl
	An interface for reporting progress and controlling long-running activities. More...
class	HeapProfiler
	Interface for controlling heap profiling. More...
class	RetainedObjectInfo
	Interface for providing information about embedder's objects held by global handles. More...
struct	HeapStatsUpdate
	A struct for exporting HeapStats data from V8, using "push" model. More...
class	Testing
class	StdMapTraits
	A default trait implemenation for PersistentValueMap which uses std::map as a backing map. More...
class	DefaultPersistentValueMapTraits
	A default trait implementation for PersistentValueMap, which inherits a std:map backing map from StdMapTraits and holds non-weak persistent objects and has no special Dispose handling. More...
class	PersistentValueMap
	A map wrapper that allows using UniquePersistent as a mapped value. More...
class	StdPersistentValueMap
	A map that uses UniquePersistent as value and std::map as the backing implementation. More...
class	DefaultPersistentValueVectorTraits
class	PersistentValueVector
	A vector wrapper that safely stores UniquePersistent values. More...
class	Local
	A light-weight stack-allocated object handle. More...
class	Eternal
class	NonCopyablePersistentTraits
	Default traits for Persistent. More...
class	PersistentBase
	An object reference that is independent of any handle scope. More...
class	Persistent
	A PersistentBase which allows copy and assignment. More...
class	UniquePersistent
	A PersistentBase which has move semantics. More...
class	WeakCallbackObject
class	FunctionCallbackInfo
	The argument information given to function call callbacks. More...
class	PropertyCallbackInfo
	The information passed to a property callback about the context of the property access. More...
class	ReturnValue
class	UniqueId
	General purpose unique identifier. More...
class	WeakCallbackData
struct	CopyablePersistentTraits
	Helper class traits to allow copying and assignment of Persistent. More...
class	HandleScope
	A stack-allocated class that governs a number of local handles. More...
class	EscapableHandleScope
	A HandleScope which first allocates a handle in the current scope which will be later filled with the escape value. More...
struct	Maybe
	A simple Maybe type, representing an object which may or may not have a value. More...
class	Data
	The superclass of values and API object templates. More...
class	ScriptOrigin
	The origin, within a file, of a script. More...
class	UnboundScript
	A compiled JavaScript script, not yet tied to a Context. More...
class	Script
	A compiled JavaScript script, tied to a Context which was active when the script was compiled. More...
class	ScriptCompiler
	For compiling scripts. More...
class	Message
	An error message. More...
class	StackTrace
	Representation of a JavaScript stack trace. More...
class	StackFrame
	A single JavaScript stack frame. More...
class	JSON
	A JSON Parser. More...
class	Value
	The superclass of all JavaScript values and objects. More...
class	Primitive
	The superclass of primitive values. More...
class	Boolean
	A primitive boolean value (ECMA-262, 4.3.14). More...
class	Name
	A superclass for symbols and strings. More...
class	String
	A JavaScript string value (ECMA-262, 4.3.17). More...
class	Symbol
	A JavaScript symbol (ECMA-262 edition 6) More...
class	Private
	A private symbol. More...
class	Number
	A JavaScript number value (ECMA-262, 4.3.20) More...
class	Integer
	A JavaScript value representing a signed integer. More...
class	Int32
	A JavaScript value representing a 32-bit signed integer. More...
class	Uint32
	A JavaScript value representing a 32-bit unsigned integer. More...
class	Object
	A JavaScript object (ECMA-262, 4.3.3) More...
class	Array
	An instance of the built-in array constructor (ECMA-262, 15.4.2). More...
class	Function
	A JavaScript function object (ECMA-262, 15.3). More...
class	Promise
	An instance of the built-in Promise constructor (ES6 draft). More...
class	ArrayBuffer
	An instance of the built-in ArrayBuffer constructor (ES6 draft 15.13.5). More...
class	ArrayBufferView
	A base class for an instance of one of "views" over ArrayBuffer, including TypedArrays and DataView (ES6 draft 15.13). More...
class	TypedArray
	A base class for an instance of TypedArray series of constructors (ES6 draft 15.13.6). More...
class	Uint8Array
	An instance of Uint8Array constructor (ES6 draft 15.13.6). More...
class	Uint8ClampedArray
	An instance of Uint8ClampedArray constructor (ES6 draft 15.13.6). More...
class	Int8Array
	An instance of Int8Array constructor (ES6 draft 15.13.6). More...
class	Uint16Array
	An instance of Uint16Array constructor (ES6 draft 15.13.6). More...
class	Int16Array
	An instance of Int16Array constructor (ES6 draft 15.13.6). More...
class	Uint32Array
	An instance of Uint32Array constructor (ES6 draft 15.13.6). More...
class	Int32Array
	An instance of Int32Array constructor (ES6 draft 15.13.6). More...
class	Float32Array
	An instance of Float32Array constructor (ES6 draft 15.13.6). More...
class	Float64Array
	An instance of Float64Array constructor (ES6 draft 15.13.6). More...
class	DataView
	An instance of DataView constructor (ES6 draft 15.13.7). More...
class	Date
	An instance of the built-in Date constructor (ECMA-262, 15.9). More...
class	NumberObject
	A Number object (ECMA-262, 4.3.21). More...
class	BooleanObject
	A Boolean object (ECMA-262, 4.3.15). More...
class	StringObject
	A String object (ECMA-262, 4.3.18). More...
class	SymbolObject
	A Symbol object (ECMA-262 edition 6). More...
class	RegExp
	An instance of the built-in RegExp constructor (ECMA-262, 15.10). More...
class	External
	A JavaScript value that wraps a C++ void*. More...
class	Template
	The superclass of object and function templates. More...
class	FunctionTemplate
	A FunctionTemplate is used to create functions at runtime. More...
class	ObjectTemplate
	An ObjectTemplate is used to create objects at runtime. More...
class	Signature
	A Signature specifies which receivers and arguments are valid parameters to a function. More...
class	AccessorSignature
	An AccessorSignature specifies which receivers are valid parameters to an accessor callback. More...
class	DeclaredAccessorDescriptor
class	ObjectOperationDescriptor
class	RawOperationDescriptor
class	TypeSwitch
	A utility for determining the type of objects based on the template they were constructed from. More...
class	ExternalOneByteStringResourceImpl
class	Extension
	Ignore. More...
class	ResourceConstraints
	A set of constraints that specifies the limits of the runtime's memory use. More...
class	Exception
	Create new error objects by calling the corresponding error object constructor with the message. More...
class	HeapStatistics
	Collection of V8 heap information. More...
struct	JitCodeEvent
	A JIT code event is issued each time code is added, moved or removed. More...
class	Isolate
	Isolate represents an isolated instance of the V8 engine. More...
class	StartupData
class	StartupDataDecompressor
	A helper class for driving V8 startup data decompression. More...
class	ExternalResourceVisitor
	Interface for iterating through all external resources in the heap. More...
class	PersistentHandleVisitor
	Interface for iterating through all the persistent handles in the heap. More...
class	V8
	Container class for static utility functions. More...
class	TryCatch
	An external exception handler. More...
class	ExtensionConfiguration
	A container for extension names. More...
class	Context
	A sandboxed execution context with its own set of built-in objects and functions. More...
class	Unlocker
	Multiple threads in V8 are allowed, but only one thread at a time is allowed to use any given V8 isolate, see the comments in the Isolate class. More...
class	Locker
class	AlignOfHelper

Typedefs
typedef uint32_t	SnapshotObjectId
typedef uintptr_t	PersistentContainerValue
typedef void(*	AccessorGetterCallback) (Local< String > property, const PropertyCallbackInfo< Value > &info)
	Accessor[Getter|Setter] are used as callback functions when setting|getting a particular property. More...
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)
typedef void(*	FunctionCallback) (const FunctionCallbackInfo< Value > &info)
typedef void(*	NamedPropertyGetterCallback) (Local< String > property, const PropertyCallbackInfo< Value > &info)
	NamedProperty[Getter|Setter] are used as interceptors on object. More...
typedef void(*	NamedPropertySetterCallback) (Local< String > property, Local< Value > value, const PropertyCallbackInfo< Value > &info)
	Returns the value if the setter intercepts the request. More...
typedef void(*	NamedPropertyQueryCallback) (Local< String > property, const PropertyCallbackInfo< Integer > &info)
	Returns a non-empty handle if the interceptor intercepts the request. More...
typedef void(*	NamedPropertyDeleterCallback) (Local< String > property, const PropertyCallbackInfo< Boolean > &info)
	Returns a non-empty handle if the deleter intercepts the request. More...
typedef void(*	NamedPropertyEnumeratorCallback) (const PropertyCallbackInfo< Array > &info)
	Returns an array containing the names of the properties the named property getter intercepts. More...
typedef void(*	IndexedPropertyGetterCallback) (uint32_t index, const PropertyCallbackInfo< Value > &info)
	Returns the value of the property if the getter intercepts the request. More...
typedef void(*	IndexedPropertySetterCallback) (uint32_t index, Local< Value > value, const PropertyCallbackInfo< Value > &info)
	Returns the value if the setter intercepts the request. More...
typedef void(*	IndexedPropertyQueryCallback) (uint32_t index, const PropertyCallbackInfo< Integer > &info)
	Returns a non-empty handle if the interceptor intercepts the request. More...
typedef void(*	IndexedPropertyDeleterCallback) (uint32_t index, const PropertyCallbackInfo< Boolean > &info)
	Returns a non-empty handle if the deleter intercepts the request. More...
typedef void(*	IndexedPropertyEnumeratorCallback) (const PropertyCallbackInfo< Array > &info)
	Returns an array containing the indices of the properties the indexed property getter intercepts. More...
typedef bool(*	NamedSecurityCallback) (Local< Object > host, Local< Value > key, AccessType type, Local< Value > data)
	Returns true if cross-context access should be allowed to the named property with the given key on the host object. More...
typedef bool(*	IndexedSecurityCallback) (Local< Object > host, uint32_t index, AccessType type, Local< Value > data)
	Returns true if cross-context access should be allowed to the indexed property with the given index on the host object. More...
typedef void(*	FatalErrorCallback) (const char *location, const char *message)
typedef void(*	MessageCallback) (Handle< Message > message, Handle< Value > error)
typedef void(*	LogEventCallback) (const char *name, int event)
typedef int *(*	CounterLookupCallback) (const char *name)
typedef void *(*	CreateHistogramCallback) (const char *name, int min, int max, size_t buckets)
typedef void(*	AddHistogramSampleCallback) (void *histogram, int sample)
typedef void(*	MemoryAllocationCallback) (ObjectSpace space, AllocationAction action, int size)
typedef void(*	CallCompletedCallback) ()
typedef void(*	MicrotaskCallback) (void *data)
typedef void(*	FailedAccessCheckCallback) (Local< Object > target, AccessType type, Local< Value > data)
typedef bool(*	AllowCodeGenerationFromStringsCallback) (Local< Context > context)
	Callback to check if code generation from strings is allowed. More...
typedef void(*	GCPrologueCallback) (GCType type, GCCallbackFlags flags)
typedef void(*	GCEpilogueCallback) (GCType type, GCCallbackFlags flags)
typedef void(*	InterruptCallback) (Isolate *isolate, void *data)
typedef void(*	FunctionEntryHook) (uintptr_t function, uintptr_t return_addr_location)
	FunctionEntryHook is the type of the profile entry hook called at entry to any generated function when function-level profiling is enabled. More...
typedef void(*	JitCodeEventHandler) (const JitCodeEvent *event)
	Callback function passed to SetJitCodeEventHandler. More...
typedef bool(*	EntropySource) (unsigned char *buffer, size_t length)
	EntropySource is used as a callback function when v8 needs a source of entropy. More...
typedef uintptr_t(*	ReturnAddressLocationResolver) (uintptr_t return_addr_location)
	ReturnAddressLocationResolver is used as a callback function when v8 is resolving the location of a return address on the stack. More...

Enumerations
enum	CompressedStartupDataItems {   kSnapshot = 0 , kSnapshotContext , kLibraries , kExperimentalLibraries ,   kCompressedStartupDataCount }
enum	DebugEvent {   Break = 1 , Exception = 2 , NewFunction = 3 , BeforeCompile = 4 ,   AfterCompile = 5 , CompileError = 6 , PromiseEvent = 7 , AsyncTaskEvent = 8 ,   BreakForCommand = 9 }
enum	PersistentContainerCallbackType { kNotWeak , kWeak }
enum	PropertyAttribute { None = 0 , ReadOnly = 1 << 0 , DontEnum = 1 << 1 , DontDelete = 1 << 2 }
enum	ExternalArrayType {   kExternalInt8Array = 1 , kExternalUint8Array , kExternalInt16Array , kExternalUint16Array ,   kExternalInt32Array , kExternalUint32Array , kExternalFloat32Array , kExternalFloat64Array ,   kExternalUint8ClampedArray , kExternalByteArray = kExternalInt8Array , kExternalUnsignedByteArray = kExternalUint8Array , kExternalShortArray = kExternalInt16Array ,   kExternalUnsignedShortArray = kExternalUint16Array , kExternalIntArray = kExternalInt32Array , kExternalUnsignedIntArray = kExternalUint32Array , kExternalFloatArray = kExternalFloat32Array ,   kExternalDoubleArray = kExternalFloat64Array , kExternalPixelArray = kExternalUint8ClampedArray }
enum	AccessControl { DEFAULT = 0 , ALL_CAN_READ = 1 , ALL_CAN_WRITE = 1 << 1 , PROHIBITS_OVERWRITING = 1 << 2 }
	Access control specifications. More...
enum	AccessType {   ACCESS_GET , ACCESS_SET , ACCESS_HAS , ACCESS_DELETE ,   ACCESS_KEYS }
	Access type specification. More...
enum	DeclaredAccessorDescriptorDataType {   kDescriptorBoolType , kDescriptorInt8Type , kDescriptorUint8Type , kDescriptorInt16Type ,   kDescriptorUint16Type , kDescriptorInt32Type , kDescriptorUint32Type , kDescriptorFloatType ,   kDescriptorDoubleType }
enum	ObjectSpace {   kObjectSpaceNewSpace = 1 << 0 , kObjectSpaceOldPointerSpace = 1 << 1 , kObjectSpaceOldDataSpace = 1 << 2 , kObjectSpaceCodeSpace = 1 << 3 ,   kObjectSpaceMapSpace = 1 << 4 , kObjectSpaceLoSpace = 1 << 5 , kObjectSpaceAll }
enum	AllocationAction { kAllocationActionAllocate = 1 << 0 , kAllocationActionFree = 1 << 1 , kAllocationActionAll = kAllocationActionAllocate | kAllocationActionFree }
enum	GCType { kGCTypeScavenge = 1 << 0 , kGCTypeMarkSweepCompact = 1 << 1 , kGCTypeAll = kGCTypeScavenge | kGCTypeMarkSweepCompact }
	Applications can register callback functions which will be called before and after a garbage collection. More...
enum	GCCallbackFlags { kNoGCCallbackFlags = 0 , kGCCallbackFlagCompacted = 1 << 0 , kGCCallbackFlagConstructRetainedObjectInfos = 1 << 1 , kGCCallbackFlagForced = 1 << 2 }
enum	JitCodeEventOptions { kJitCodeEventDefault = 0 , kJitCodeEventEnumExisting = 1 }
	Option flags passed to the SetJitCodeEventHandler function. More...

Functions
static bool	IsExecutionTerminatingCheck (i::Isolate *isolate)
void	RegisterExtension (Extension *that)
void	SetResourceConstraints (i::Isolate *isolate, const ResourceConstraints &constraints)
static void *	DecodeSmiToAligned (i::Object *value, const char *location)
static i::Smi *	EncodeAlignedAsSmi (void *value, const char *location)
static i::Handle< i::FixedArray >	EmbedderDataFor (Context *context, int index, bool can_grow, const char *location)
static void	InitializeTemplate (i::Handle< i::TemplateInfo > that, int type)
static void	TemplateSet (i::Isolate *isolate, v8::Template *templ, int length, v8::Handle< v8::Data > *data)
static void	InitializeFunctionTemplate (i::Handle< i::FunctionTemplateInfo > info)
static Local< FunctionTemplate >	FunctionTemplateNew (i::Isolate *isolate, FunctionCallback callback, v8::Handle< Value > data, v8::Handle< Signature > signature, int length, bool do_not_cache)
template<typename Operation >
static Local< Operation >	NewDescriptor (Isolate *isolate, const i::DeclaredAccessorDescriptorData &data, Data *previous_descriptor)
template<typename T >
static Local< DeclaredAccessorDescriptor >	NewBitmaskCompare (Isolate *isolate, T bitmask, T compare_value, RawOperationDescriptor *operation)
static i::Handle< i::AccessorInfo >	SetAccessorInfoProperties (i::Handle< i::AccessorInfo > obj, v8::Handle< Name > name, v8::AccessControl settings, v8::PropertyAttribute attributes, v8::Handle< AccessorSignature > signature)
template<typename Getter , typename Setter >
static i::Handle< i::AccessorInfo >	MakeAccessorInfo (v8::Handle< Name > name, Getter getter, Setter setter, v8::Handle< Value > data, v8::AccessControl settings, v8::PropertyAttribute attributes, v8::Handle< AccessorSignature > signature)
static i::Handle< i::AccessorInfo >	MakeAccessorInfo (v8::Handle< Name > name, v8::Handle< v8::DeclaredAccessorDescriptor > descriptor, void *setter_ignored, void *data_ignored, v8::AccessControl settings, v8::PropertyAttribute attributes, v8::Handle< AccessorSignature > signature)
static i::Handle< i::FunctionTemplateInfo >	EnsureConstructor (i::Isolate *isolate, ObjectTemplate *object_template)
static void	AddPropertyToTemplate (i::Handle< i::TemplateInfo > info, i::Handle< i::AccessorInfo > obj)
static i::Handle< i::TemplateInfo >	GetTemplateInfo (i::Isolate *isolate, Template *template_obj)
static i::Handle< i::TemplateInfo >	GetTemplateInfo (i::Isolate *isolate, ObjectTemplate *object_template)
template<typename Getter , typename Setter , typename Data , typename Template >
static bool	TemplateSetAccessor (Template *template_obj, v8::Local< Name > name, Getter getter, Setter setter, Data data, AccessControl settings, PropertyAttribute attribute, v8::Local< AccessorSignature > signature)
static MUST_USE_RESULT i::MaybeHandle< i::Object >	CallV8HeapFunction (const char *name, i::Handle< i::Object > recv, int argc, i::Handle< i::Object > argv[])
static MUST_USE_RESULT i::MaybeHandle< i::Object >	CallV8HeapFunction (const char *name, i::Handle< i::Object > data)
static int	getIntProperty (const StackFrame *f, const char *propertyName, int defaultValue)
static Local< String >	getStringProperty (const StackFrame *f, const char *propertyName)
static bool	getBoolProperty (const StackFrame *f, const char *propertyName)
static bool	CheckConstructor (i::Isolate *isolate, i::Handle< i::JSObject > obj, const char *class_name)
template<typename Getter , typename Setter , typename Data >
static bool	ObjectSetAccessor (Object *obj, Handle< Name > name, Getter getter, Setter setter, Data data, AccessControl settings, PropertyAttribute attributes)
static Local< Value >	GetPropertyByLookup (i::LookupIterator *it)
static bool	Unaligned (const uint16_t *chars)
static const uint16_t *	Align (const uint16_t *chars)
static int	Utf8Length (i::String *str, i::Isolate *isolate)
static bool	RecursivelySerializeToUtf8 (i::String *current, Utf8WriterVisitor *writer, int recursion_budget)
template<typename CharType >
static int	WriteHelper (const String *string, CharType *buffer, int start, int length, int options)
static bool	InternalFieldOK (i::Handle< i::JSObject > obj, int index, const char *location)
static void *	ExternalValue (i::Object *obj)
static i::Handle< i::Context >	CreateEnvironment (i::Isolate *isolate, v8::ExtensionConfiguration *extensions, v8::Handle< ObjectTemplate > global_template, v8::Handle< Value > maybe_global_proxy)
static i::MaybeHandle< i::String >	NewExternalStringHandle (i::Isolate *isolate, v8::String::ExternalStringResource *resource)
static i::MaybeHandle< i::String >	NewExternalOneByteStringHandle (i::Isolate *isolate, v8::String::ExternalOneByteStringResource *resource)
static i::Handle< i::String >	RegExpFlagsToString (RegExp::Flags flags)
	REGEXP_FLAG_ASSERT_EQ (kNone, NONE)
	REGEXP_FLAG_ASSERT_EQ (kGlobal, GLOBAL)
	REGEXP_FLAG_ASSERT_EQ (kIgnoreCase, IGNORE_CASE)
	REGEXP_FLAG_ASSERT_EQ (kMultiline, MULTILINE)
static void	SetupArrayBufferView (i::Isolate *isolate, i::Handle< i::JSArrayBufferView > obj, i::Handle< i::JSArrayBuffer > buffer, size_t byte_offset, size_t byte_length)
template<typename ElementType , ExternalArrayType array_type, i::ElementsKind elements_kind>
i::Handle< i::JSTypedArray >	NewTypedArray (i::Isolate *isolate, Handle< ArrayBuffer > array_buffer, size_t byte_offset, size_t length)
static i::Handle< i::Symbol >	SymbolFor (i::Isolate *isolate, i::Handle< i::String > name, i::Handle< i::String > part)
static Local< Symbol >	GetWellKnownSymbol (Isolate *isolate, const char *name)
static i::HeapGraphEdge *	ToInternal (const HeapGraphEdge *edge)
static i::HeapEntry *	ToInternal (const HeapGraphNode *entry)
static i::HeapSnapshot *	ToInternal (const HeapSnapshot *snapshot)
static void	SetFlagsFromString (const char *flags)
template<typename T >
T	ToCData (v8::internal::Object *obj)
template<typename T >
v8::internal::Handle< v8::internal::Object >	FromCData (v8::internal::Isolate *isolate, T obj)
template<class T >
T *	ToApi (v8::internal::Handle< v8::internal::Object > obj)
template<class T >
v8::Local< T >	ToApiHandle (v8::internal::Handle< v8::internal::Object > obj)
void	PrintPrompt (bool is_running)
void	HandleDebugEvent (const Debug::EventDetails &event_details)
static int	LengthWithoutIncompleteUtf8 (char *buffer, int len)
static bool	WaitOnFD (int fd, int read_timeout, int total_timeout, const struct timeval &start_time)
static bool	TimeIsOut (const struct timeval &start_time, const int &total_time)
static bool	GetTimeouts (const v8::FunctionCallbackInfo< v8::Value > &args, int *read_timeout, int *total_timeout)
static void	ExecSubprocess (int *exec_error_fds, int *stdout_fds, const ExecArgs &exec_args)
static bool	ChildLaunchedOK (Isolate *isolate, int *exec_error_fds)
static Handle< Value >	GetStdout (Isolate *isolate, int child_fd, const struct timeval &start_time, int read_timeout, int total_timeout)
static bool	WaitForChild (Isolate *isolate, int pid, ZombieProtector &child_waiter, const struct timeval &start_time, int read_timeout, int total_timeout)
static bool	CheckItsADirectory (Isolate *isolate, char *directory)
static bool	mkdirp (Isolate *isolate, char *directory, mode_t mask)
static Handle< Value >	Throw (Isolate *isolate, const char *message)
bool	operator< (const CounterAndKey &lhs, const CounterAndKey &rhs)
static FILE *	FOpen (const char *path, const char *mode)
static char *	ReadChars (Isolate *isolate, const char *name, int *size_out)
static void	ReadBufferWeakCallback (const v8::WeakCallbackData< ArrayBuffer, DataAndPersistent > &data)
static void	DumpHeapConstants (i::Isolate *isolate)
template<class T >
Maybe< T >	maybe (T t)
Handle< Primitive >	Undefined (Isolate *isolate)
Handle< Primitive >	Null (Isolate *isolate)
Handle< Boolean >	True (Isolate *isolate)
Handle< Boolean >	False (Isolate *isolate)

Variables
static const uintptr_t	kOneByteMask = OneByteMask<sizeof(uintptr_t)>::value
static const uintptr_t	kAlignmentMask = sizeof(uintptr_t) - 1
static const int	kReadFD = 0
static const int	kWriteFD = 1
static ReadLineEditor	read_line_editor
const int	MB = 1024 * 1024
static const uintptr_t	kPersistentContainerNotFound = 0

Detailed Description

Debugger support for the V8 JavaScript engine.

The v8 JavaScript engine.

Support for Persistent containers.

Testing support for the V8 JavaScript engine.

Profiler support for the V8 JavaScript engine.

C++11 embedders can use STL containers with UniquePersistent values, but pre-C++11 does not support the required move semantic and hence may want these container classes.

Typedef Documentation

AccessorGetterCallback

typedef void(* v8::AccessorGetterCallback) (Local< String > property, const PropertyCallbackInfo< Value > &info)

Accessor[Getter|Setter] are used as callback functions when setting|getting a particular property.

See Object and ObjectTemplate's method SetAccessor.

Definition at line 2245 of file v8.h.

AccessorNameGetterCallback

typedef void(* v8::AccessorNameGetterCallback) (Local< Name > property, const PropertyCallbackInfo< Value > &info)

Definition at line 2248 of file v8.h.

AccessorNameSetterCallback

typedef void(* v8::AccessorNameSetterCallback) (Local< Name > property, Local< Value > value, const PropertyCallbackInfo< void > &info)

Definition at line 2257 of file v8.h.

AccessorSetterCallback

typedef void(* v8::AccessorSetterCallback) (Local< String > property, Local< Value > value, const PropertyCallbackInfo< void > &info)

Definition at line 2253 of file v8.h.

AddHistogramSampleCallback

typedef void(* v8::AddHistogramSampleCallback) (void *histogram, int sample)

Definition at line 4149 of file v8.h.

AllowCodeGenerationFromStringsCallback

typedef bool(* v8::AllowCodeGenerationFromStringsCallback) (Local< Context > context)

Callback to check if code generation from strings is allowed.

See Context::AllowCodeGenerationFromStrings.

Definition at line 4192 of file v8.h.

CallCompletedCallback

typedef void(* v8::CallCompletedCallback) ()

Definition at line 4176 of file v8.h.

CounterLookupCallback

typedef int*(* v8::CounterLookupCallback) (const char *name)

Definition at line 4142 of file v8.h.

CreateHistogramCallback

typedef void*(* v8::CreateHistogramCallback) (const char *name, int min, int max, size_t buckets)

Definition at line 4144 of file v8.h.

EntropySource

typedef bool(* v8::EntropySource) (unsigned char *buffer, size_t length)

EntropySource is used as a callback function when v8 needs a source of entropy.

Definition at line 4920 of file v8.h.

FailedAccessCheckCallback

typedef void(* v8::FailedAccessCheckCallback) (Local< Object > target, AccessType type, Local< Value > data)

Definition at line 4182 of file v8.h.

FatalErrorCallback

typedef void(* v8::FatalErrorCallback) (const char *location, const char *message)

Definition at line 4117 of file v8.h.

FunctionCallback

typedef void(* v8::FunctionCallback) (const FunctionCallbackInfo< Value > &info)

Definition at line 2717 of file v8.h.

FunctionEntryHook

typedef void(* v8::FunctionEntryHook) (uintptr_t function, uintptr_t return_addr_location)

FunctionEntryHook is the type of the profile entry hook called at entry to any generated function when function-level profiling is enabled.

Parameters

function	the address of the function that's being entered.
return_addr_location	points to a location on stack where the machine return address resides. This can be used to identify the caller of function, and/or modified to divert execution when function exits.

Note

the entry hook must not cause garbage collection.

Definition at line 4263 of file v8.h.

GCEpilogueCallback

typedef void(* v8::GCEpilogueCallback) (GCType type, GCCallbackFlags flags)

Definition at line 4217 of file v8.h.

GCPrologueCallback

typedef void(* v8::GCPrologueCallback) (GCType type, GCCallbackFlags flags)

Definition at line 4216 of file v8.h.

IndexedPropertyDeleterCallback

typedef void(* v8::IndexedPropertyDeleterCallback) (uint32_t index, const PropertyCallbackInfo< Boolean > &info)

Returns a non-empty handle if the deleter intercepts the request.

The return value is true if the property could be deleted and false otherwise.

Definition at line 3503 of file v8.h.

IndexedPropertyEnumeratorCallback

typedef void(* v8::IndexedPropertyEnumeratorCallback) (const PropertyCallbackInfo< Array > &info)

Returns an array containing the indices of the properties the indexed property getter intercepts.

Definition at line 3512 of file v8.h.

IndexedPropertyGetterCallback

typedef void(* v8::IndexedPropertyGetterCallback) (uint32_t index, const PropertyCallbackInfo< Value > &info)

Returns the value of the property if the getter intercepts the request.

Otherwise, returns an empty handle.

Definition at line 3474 of file v8.h.

IndexedPropertyQueryCallback

typedef void(* v8::IndexedPropertyQueryCallback) (uint32_t index, const PropertyCallbackInfo< Integer > &info)

Returns a non-empty handle if the interceptor intercepts the request.

The result is an integer encoding property attributes.

Definition at line 3493 of file v8.h.

IndexedPropertySetterCallback

typedef void(* v8::IndexedPropertySetterCallback) (uint32_t index, Local< Value > value, const PropertyCallbackInfo< Value > &info)

Returns the value if the setter intercepts the request.

Otherwise, returns an empty handle.

Definition at line 3483 of file v8.h.

IndexedSecurityCallback

typedef bool(* v8::IndexedSecurityCallback) (Local< Object > host, uint32_t index, AccessType type, Local< Value > data)

Returns true if cross-context access should be allowed to the indexed property with the given index on the host object.

Definition at line 3542 of file v8.h.

InterruptCallback

typedef void(* v8::InterruptCallback) (Isolate *isolate, void *data)

Definition at line 4219 of file v8.h.

JitCodeEventHandler

typedef void(* v8::JitCodeEventHandler) (const JitCodeEvent *event)

Callback function passed to SetJitCodeEventHandler.

Parameters

event

code add, move or removal event.

Definition at line 4345 of file v8.h.

LogEventCallback

typedef void(* v8::LogEventCallback) (const char *name, int event)

Definition at line 4124 of file v8.h.

MemoryAllocationCallback

typedef void(* v8::MemoryAllocationCallback) (ObjectSpace space, AllocationAction action, int size)

Definition at line 4171 of file v8.h.

MessageCallback

typedef void(* v8::MessageCallback) (Handle< Message > message, Handle< Value > error)

Definition at line 4120 of file v8.h.

MicrotaskCallback

typedef void(* v8::MicrotaskCallback) (void *data)

Definition at line 4179 of file v8.h.

NamedPropertyDeleterCallback

typedef void(* v8::NamedPropertyDeleterCallback) (Local< String > property, const PropertyCallbackInfo< Boolean > &info)

Returns a non-empty handle if the deleter intercepts the request.

The return value is true if the property could be deleted and false otherwise.

Definition at line 3457 of file v8.h.

NamedPropertyEnumeratorCallback

typedef void(* v8::NamedPropertyEnumeratorCallback) (const PropertyCallbackInfo< Array > &info)

Returns an array containing the names of the properties the named property getter intercepts.

Definition at line 3466 of file v8.h.

NamedPropertyGetterCallback

typedef void(* v8::NamedPropertyGetterCallback) (Local< String > property, const PropertyCallbackInfo< Value > &info)

NamedProperty[Getter|Setter] are used as interceptors on object.

See ObjectTemplate::SetNamedPropertyHandler.

Definition at line 3427 of file v8.h.

NamedPropertyQueryCallback

typedef void(* v8::NamedPropertyQueryCallback) (Local< String > property, const PropertyCallbackInfo< Integer > &info)

Returns a non-empty handle if the interceptor intercepts the request.

The result is an integer encoding property attributes (like v8::None, v8::DontEnum, etc.)

Definition at line 3447 of file v8.h.

NamedPropertySetterCallback

typedef void(* v8::NamedPropertySetterCallback) (Local< String > property, Local< Value > value, const PropertyCallbackInfo< Value > &info)

Returns the value if the setter intercepts the request.

Otherwise, returns an empty handle.

Definition at line 3436 of file v8.h.

NamedSecurityCallback

typedef bool(* v8::NamedSecurityCallback) (Local< Object > host, Local< Value > key, AccessType type, Local< Value > data)

Returns true if cross-context access should be allowed to the named property with the given key on the host object.

Definition at line 3532 of file v8.h.

PersistentContainerValue

typedef uintptr_t v8::PersistentContainerValue

Definition at line 21 of file v8-util.h.

ReturnAddressLocationResolver

typedef uintptr_t(* v8::ReturnAddressLocationResolver) (uintptr_t return_addr_location)

ReturnAddressLocationResolver is used as a callback function when v8 is resolving the location of a return address on the stack.

Profilers that change the return address on the stack can use this to resolve the stack location to whereever the profiler stashed the original return address.

Parameters

return_addr_location

points to a location on stack where a machine return address resides.

Returns

either return_addr_location, or else a pointer to the profiler's copy of the original return address.

Note

the resolver function must not cause garbage collection.

Definition at line 4936 of file v8.h.

SnapshotObjectId

typedef uint32_t v8::SnapshotObjectId

Definition at line 18 of file v8-profiler.h.

Enumeration Type Documentation

AccessControl

enum v8::AccessControl

Access control specifications.

Some accessors should be accessible across contexts. These accessors have an explicit access control parameter which specifies the kind of cross-context access that should be allowed.

TODO(dcarney): Remove PROHIBITS_OVERWRITING as it is now unused.

Enumerator
DEFAULT
ALL_CAN_READ
ALL_CAN_WRITE
PROHIBITS_OVERWRITING

Definition at line 2272 of file v8.h.

                   {
  DEFAULT               = 0,
  ALL_CAN_READ          = 1,
  ALL_CAN_WRITE         = 1 << 1,
  PROHIBITS_OVERWRITING = 1 << 2
};

AccessType

enum v8::AccessType

Access type specification.

Enumerator
ACCESS_GET
ACCESS_SET
ACCESS_HAS
ACCESS_DELETE
ACCESS_KEYS

Definition at line 3519 of file v8.h.

                {
  ACCESS_GET,
  ACCESS_SET,
  ACCESS_HAS,
  ACCESS_DELETE,
  ACCESS_KEYS
};

AllocationAction

enum v8::AllocationAction

Enumerator
kAllocationActionAllocate
kAllocationActionFree
kAllocationActionAll

Definition at line 4165 of file v8.h.

                        {
    kAllocationActionAllocate = 1 << 0,
    kAllocationActionFree = 1 << 1,
    kAllocationActionAll = kAllocationActionAllocate | kAllocationActionFree
  };

CompressedStartupDataItems

enum v8::CompressedStartupDataItems

Enumerator
kSnapshot
kSnapshotContext
kLibraries
kExperimentalLibraries
kCompressedStartupDataCount

Definition at line 255 of file api.cc.

                                {
  kSnapshot = 0,
  kSnapshotContext,
  kLibraries,
  kExperimentalLibraries,
  kCompressedStartupDataCount
};

DebugEvent

enum v8::DebugEvent

Enumerator
Break
Exception
NewFunction
BeforeCompile
AfterCompile
CompileError
PromiseEvent
AsyncTaskEvent
BreakForCommand

Definition at line 16 of file v8-debug.h.

                {
  Break = 1,
  Exception = 2,
  NewFunction = 3,
  BeforeCompile = 4,
  AfterCompile  = 5,
  CompileError = 6,
  PromiseEvent = 7,
  AsyncTaskEvent = 8,
  BreakForCommand = 9
};

DeclaredAccessorDescriptorDataType

enum v8::DeclaredAccessorDescriptorDataType

Enumerator
kDescriptorBoolType
kDescriptorInt8Type
kDescriptorUint8Type
kDescriptorInt16Type
kDescriptorUint16Type
kDescriptorInt32Type
kDescriptorUint32Type
kDescriptorFloatType
kDescriptorDoubleType

Definition at line 3937 of file v8.h.

                                        {
    kDescriptorBoolType,
    kDescriptorInt8Type, kDescriptorUint8Type,
    kDescriptorInt16Type, kDescriptorUint16Type,
    kDescriptorInt32Type, kDescriptorUint32Type,
    kDescriptorFloatType, kDescriptorDoubleType
};

ExternalArrayType

enum v8::ExternalArrayType

Enumerator
kExternalInt8Array
kExternalUint8Array
kExternalInt16Array
kExternalUint16Array
kExternalInt32Array
kExternalUint32Array
kExternalFloat32Array
kExternalFloat64Array
kExternalUint8ClampedArray
kExternalByteArray
kExternalUnsignedByteArray
kExternalShortArray
kExternalUnsignedShortArray
kExternalIntArray
kExternalUnsignedIntArray
kExternalFloatArray
kExternalDoubleArray
kExternalPixelArray

Definition at line 2217 of file v8.h.

                       {
  kExternalInt8Array = 1,
  kExternalUint8Array,
  kExternalInt16Array,
  kExternalUint16Array,
  kExternalInt32Array,
  kExternalUint32Array,
  kExternalFloat32Array,
  kExternalFloat64Array,
  kExternalUint8ClampedArray,
 
  // Legacy constant names
  kExternalByteArray = kExternalInt8Array,
  kExternalUnsignedByteArray = kExternalUint8Array,
  kExternalShortArray = kExternalInt16Array,
  kExternalUnsignedShortArray = kExternalUint16Array,
  kExternalIntArray = kExternalInt32Array,
  kExternalUnsignedIntArray = kExternalUint32Array,
  kExternalFloatArray = kExternalFloat32Array,
  kExternalDoubleArray = kExternalFloat64Array,
  kExternalPixelArray = kExternalUint8ClampedArray
};

GCCallbackFlags

enum v8::GCCallbackFlags

Enumerator
kNoGCCallbackFlags
kGCCallbackFlagCompacted
kGCCallbackFlagConstructRetainedObjectInfos
kGCCallbackFlagForced

Definition at line 4209 of file v8.h.

                     {
  kNoGCCallbackFlags = 0,
  kGCCallbackFlagCompacted = 1 << 0,
  kGCCallbackFlagConstructRetainedObjectInfos = 1 << 1,
  kGCCallbackFlagForced = 1 << 2
};

GCType

enum v8::GCType

Applications can register callback functions which will be called before and after a garbage collection.

Allocations are not allowed in the callback functions, you therefore cannot manipulate objects (set or delete properties for example) since it is possible such operations will result in the allocation of objects.

Enumerator
kGCTypeScavenge
kGCTypeMarkSweepCompact
kGCTypeAll

Definition at line 4203 of file v8.h.

            {
  kGCTypeScavenge = 1 << 0,
  kGCTypeMarkSweepCompact = 1 << 1,
  kGCTypeAll = kGCTypeScavenge | kGCTypeMarkSweepCompact
};

JitCodeEventOptions

enum v8::JitCodeEventOptions

Option flags passed to the SetJitCodeEventHandler function.

Enumerator
kJitCodeEventDefault
kJitCodeEventEnumExisting

Definition at line 4333 of file v8.h.

                         {
  kJitCodeEventDefault = 0,
  // Generate callbacks for already existent code.
  kJitCodeEventEnumExisting = 1
};

ObjectSpace

enum v8::ObjectSpace

Enumerator
kObjectSpaceNewSpace
kObjectSpaceOldPointerSpace
kObjectSpaceOldDataSpace
kObjectSpaceCodeSpace
kObjectSpaceMapSpace
kObjectSpaceLoSpace
kObjectSpaceAll

Definition at line 4152 of file v8.h.

                   {
    kObjectSpaceNewSpace = 1 << 0,
    kObjectSpaceOldPointerSpace = 1 << 1,
    kObjectSpaceOldDataSpace = 1 << 2,
    kObjectSpaceCodeSpace = 1 << 3,
    kObjectSpaceMapSpace = 1 << 4,
    kObjectSpaceLoSpace = 1 << 5,
 
    kObjectSpaceAll = kObjectSpaceNewSpace | kObjectSpaceOldPointerSpace |
      kObjectSpaceOldDataSpace | kObjectSpaceCodeSpace | kObjectSpaceMapSpace |
      kObjectSpaceLoSpace
  };

PersistentContainerCallbackType

enum v8::PersistentContainerCallbackType

Enumerator
kNotWeak
kWeak

Definition at line 23 of file v8-util.h.

                                     {
  kNotWeak,
  kWeak
};

PropertyAttribute

enum v8::PropertyAttribute

Enumerator
None
ReadOnly
DontEnum
DontDelete

Definition at line 2210 of file v8.h.

                       {
  None       = 0,
  ReadOnly   = 1 << 0,
  DontEnum   = 1 << 1,
  DontDelete = 1 << 2
};

Function Documentation

AddPropertyToTemplate()

static void v8::AddPropertyToTemplate ( i::Handle< i::TemplateInfo >  info, i::Handle< i::AccessorInfo >  obj  )

inlinestatic

Definition at line 1285 of file api.cc.

                                {
  i::Isolate* isolate = info->GetIsolate();
  i::Handle<i::Object> list(info->property_accessors(), isolate);
  if (list->IsUndefined()) {
    list = NeanderArray(isolate).value();
    info->set_property_accessors(*list);
  }
  NeanderArray array(list);
  array.add(obj);
}

References v8::NeanderArray::add(), and v8::NeanderArray::value().

Referenced by TemplateSetAccessor().

Here is the call graph for this function:

Here is the caller graph for this function:

Align()

static const uint16_t* v8::Align ( const uint16_t *  chars )

inlinestatic

Definition at line 4266 of file api.cc.

                                                           {
  return reinterpret_cast<uint16_t*>(
      reinterpret_cast<uintptr_t>(chars) & ~kAlignmentMask);
}

References kAlignmentMask.

Referenced by v8::ContainsOnlyOneByteHelper::VisitTwoByteString().

Here is the caller graph for this function:

CallV8HeapFunction() [1/2]

static MUST_USE_RESULT i::MaybeHandle<i::Object> v8::CallV8HeapFunction ( const char *  name, i::Handle< i::Object >  data  )

static

Definition at line 2126 of file api.cc.

                           {
  i::Handle<i::Object> argv[] = { data };
  return CallV8HeapFunction(name,
                            i::Isolate::Current()->js_builtins_object(),
                            arraysize(argv),
                            argv);
}

References arraysize, CallV8HeapFunction(), and name.

Here is the call graph for this function:

CallV8HeapFunction() [2/2]

static MUST_USE_RESULT i::MaybeHandle<i::Object> v8::CallV8HeapFunction ( const char *  name, i::Handle< i::Object >  recv, int  argc, i::Handle< i::Object >  argv[]  )

static

Definition at line 2112 of file api.cc.

                             {
  i::Isolate* isolate = i::Isolate::Current();
  i::Handle<i::Object> object_fun =
      i::Object::GetProperty(
          isolate, isolate->js_builtins_object(), name).ToHandleChecked();
  i::Handle<i::JSFunction> fun = i::Handle<i::JSFunction>::cast(object_fun);
  return i::Execution::Call(isolate, fun, recv, argc, argv);
}

References v8::internal::Handle< T >::cast(), v8::internal::Object::GetProperty(), v8::internal::Isolate::js_builtins_object(), and name.

Referenced by CallV8HeapFunction(), v8::Value::Equals(), v8::Message::GetEndColumn(), v8::Message::GetLineNumber(), v8::Object::GetOwnPropertyDescriptor(), v8::Message::GetSourceLine(), and v8::Message::GetStartColumn().

Here is the call graph for this function:

Here is the caller graph for this function:

CheckConstructor()

static bool v8::CheckConstructor ( i::Isolate *  isolate, i::Handle< i::JSObject >  obj, const char *  class_name  )

static

Definition at line 2534 of file api.cc.

                                                     {
  i::Handle<i::Object> constr(obj->map()->constructor(), isolate);
  if (!constr->IsJSFunction()) return false;
  i::Handle<i::JSFunction> func = i::Handle<i::JSFunction>::cast(constr);
  return func->shared()->native() && constr.is_identical_to(
      i::Object::GetProperty(isolate,
                             isolate->js_builtins_object(),
                             class_name).ToHandleChecked());
}

References v8::internal::Handle< T >::cast(), v8::internal::Object::GetProperty(), and v8::internal::Isolate::js_builtins_object().

Referenced by v8::Value::IsNativeError().

Here is the call graph for this function:

Here is the caller graph for this function:

CheckItsADirectory()

static bool v8::CheckItsADirectory ( Isolate *  isolate, char *  directory  )

static

Definition at line 574 of file d8-posix.cc.

                                                                  {
  struct stat stat_buf;
  int stat_result = stat(directory, &stat_buf);
  if (stat_result != 0) {
    isolate->ThrowException(String::NewFromUtf8(isolate, strerror(errno)));
    return false;
  }
  if ((stat_buf.st_mode & S_IFDIR) != 0) return true;
  isolate->ThrowException(String::NewFromUtf8(isolate, strerror(EEXIST)));
  return false;
}

References v8::String::NewFromUtf8(), and v8::Isolate::ThrowException().

Referenced by mkdirp().

Here is the call graph for this function:

Here is the caller graph for this function:

ChildLaunchedOK()

static bool v8::ChildLaunchedOK ( Isolate *  isolate, int *  exec_error_fds  )

static

Definition at line 277 of file d8-posix.cc.

                                                                   {
  int bytes_read;
  int err;
  do {
    bytes_read = read(exec_error_fds[kReadFD], &err, sizeof(err));
  } while (bytes_read == -1 && errno == EINTR);
  if (bytes_read != 0) {
    isolate->ThrowException(String::NewFromUtf8(isolate, strerror(err)));
    return false;
  }
  return true;
}

References kReadFD, v8::String::NewFromUtf8(), and v8::Isolate::ThrowException().

Referenced by v8::Shell::System().

Here is the call graph for this function:

Here is the caller graph for this function:

CreateEnvironment()

static i::Handle<i::Context> v8::CreateEnvironment ( i::Isolate *  isolate, v8::ExtensionConfiguration *  extensions, v8::Handle< ObjectTemplate >  global_template, v8::Handle< Value >  maybe_global_proxy  )

static

Definition at line 5151 of file api.cc.

                                        {
  i::Handle<i::Context> env;
 
  // Enter V8 via an ENTER_V8 scope.
  {
    ENTER_V8(isolate);
    v8::Handle<ObjectTemplate> proxy_template = global_template;
    i::Handle<i::FunctionTemplateInfo> proxy_constructor;
    i::Handle<i::FunctionTemplateInfo> global_constructor;
 
    if (!global_template.IsEmpty()) {
      // Make sure that the global_template has a constructor.
      global_constructor = EnsureConstructor(isolate, *global_template);
 
      // Create a fresh template for the global proxy object.
      proxy_template = ObjectTemplate::New(
          reinterpret_cast<v8::Isolate*>(isolate));
      proxy_constructor = EnsureConstructor(isolate, *proxy_template);
 
      // Set the global template to be the prototype template of
      // global proxy template.
      proxy_constructor->set_prototype_template(
          *Utils::OpenHandle(*global_template));
 
      // Migrate security handlers from global_template to
      // proxy_template.  Temporarily removing access check
      // information from the global template.
      if (!global_constructor->access_check_info()->IsUndefined()) {
        proxy_constructor->set_access_check_info(
            global_constructor->access_check_info());
        proxy_constructor->set_needs_access_check(
            global_constructor->needs_access_check());
        global_constructor->set_needs_access_check(false);
        global_constructor->set_access_check_info(
            isolate->heap()->undefined_value());
      }
    }
 
    i::Handle<i::Object> proxy = Utils::OpenHandle(*maybe_global_proxy, true);
    i::MaybeHandle<i::JSGlobalProxy> maybe_proxy;
    if (!proxy.is_null()) {
      maybe_proxy = i::Handle<i::JSGlobalProxy>::cast(proxy);
    }
    // Create the environment.
    env = isolate->bootstrapper()->CreateEnvironment(
        maybe_proxy, proxy_template, extensions);
 
    // Restore the access check info on the global template.
    if (!global_template.IsEmpty()) {
      DCHECK(!global_constructor.is_null());
      DCHECK(!proxy_constructor.is_null());
      global_constructor->set_access_check_info(
          proxy_constructor->access_check_info());
      global_constructor->set_needs_access_check(
          proxy_constructor->needs_access_check());
    }
  }
  // Leave V8.
 
  return env;
}

References v8::internal::Isolate::bootstrapper(), v8::internal::Handle< T >::cast(), DCHECK, EnsureConstructor(), ENTER_V8, v8::internal::Isolate::heap(), v8::internal::Handle< T >::is_null(), v8::Handle< T >::IsEmpty(), v8::ObjectTemplate::New(), and v8::Utils::OpenHandle().

Referenced by v8::Context::New().

Here is the call graph for this function:

Here is the caller graph for this function:

DecodeSmiToAligned()

static void* v8::DecodeSmiToAligned ( i::Object *  value, const char *  location  )

static

Definition at line 638 of file api.cc.

                                                                      {
  Utils::ApiCheck(value->IsSmi(), location, "Not a Smi");
  return reinterpret_cast<void*>(value);
}

References v8::Utils::ApiCheck().

Referenced by v8::Context::SlowGetAlignedPointerFromEmbedderData(), and v8::Object::SlowGetAlignedPointerFromInternalField().

Here is the call graph for this function:

Here is the caller graph for this function:

DumpHeapConstants()

static void v8::DumpHeapConstants ( i::Isolate *  isolate )

static

Definition at line 1469 of file d8.cc.

                                                 {
  i::Heap* heap = isolate->heap();
 
  // Dump the INSTANCE_TYPES table to the console.
  printf("# List of known V8 instance types.\n");
#define DUMP_TYPE(T) printf("  %d: \"%s\",\n", i::T, #T);
  printf("INSTANCE_TYPES = {\n");
  INSTANCE_TYPE_LIST(DUMP_TYPE)
  printf("}\n");
#undef DUMP_TYPE
 
  // Dump the KNOWN_MAP table to the console.
  printf("\n# List of known V8 maps.\n");
#define ROOT_LIST_CASE(type, name, camel_name) \
  if (n == NULL && o == heap->name()) n = #camel_name;
#define STRUCT_LIST_CASE(upper_name, camel_name, name) \
  if (n == NULL && o == heap->name##_map()) n = #camel_name "Map";
  i::HeapObjectIterator it(heap->map_space());
  printf("KNOWN_MAPS = {\n");
  for (i::Object* o = it.Next(); o != NULL; o = it.Next()) {
    i::Map* m = i::Map::cast(o);
    const char* n = NULL;
    intptr_t p = reinterpret_cast<intptr_t>(m) & 0xfffff;
    int t = m->instance_type();
    ROOT_LIST(ROOT_LIST_CASE)
    STRUCT_LIST(STRUCT_LIST_CASE)
    if (n == NULL) continue;
    printf("  0x%05" V8PRIxPTR ": (%d, \"%s\"),\n", p, t, n);
  }
  printf("}\n");
#undef STRUCT_LIST_CASE
#undef ROOT_LIST_CASE
 
  // Dump the KNOWN_OBJECTS table to the console.
  printf("\n# List of known V8 objects.\n");
#define ROOT_LIST_CASE(type, name, camel_name) \
  if (n == NULL && o == heap->name()) n = #camel_name;
  i::OldSpaces spit(heap);
  printf("KNOWN_OBJECTS = {\n");
  for (i::PagedSpace* s = spit.next(); s != NULL; s = spit.next()) {
    i::HeapObjectIterator it(s);
    const char* sname = AllocationSpaceName(s->identity());
    for (i::Object* o = it.Next(); o != NULL; o = it.Next()) {
      const char* n = NULL;
      intptr_t p = reinterpret_cast<intptr_t>(o) & 0xfffff;
      ROOT_LIST(ROOT_LIST_CASE)
      if (n == NULL) continue;
      printf("  (\"%s\", 0x%05" V8PRIxPTR "): \"%s\",\n", sname, p, n);
    }
  }
  printf("}\n");
#undef ROOT_LIST_CASE
}

References v8::internal::AllocationSpaceName(), DUMP_TYPE, v8::internal::Isolate::heap(), v8::internal::Map::instance_type(), INSTANCE_TYPE_LIST, v8::internal::Heap::map_space(), v8::internal::HeapObjectIterator::Next(), NULL, ROOT_LIST, ROOT_LIST_CASE, STRUCT_LIST, STRUCT_LIST_CASE, and V8PRIxPTR.

Referenced by v8::Shell::Main().

Here is the call graph for this function:

Here is the caller graph for this function:

EmbedderDataFor()

static i::Handle<i::FixedArray> v8::EmbedderDataFor ( Context *  context, int  index, bool  can_grow, const char *  location  )

static

Definition at line 651 of file api.cc.

                                                                      {
  i::Handle<i::Context> env = Utils::OpenHandle(context);
  bool ok =
      Utils::ApiCheck(env->IsNativeContext(),
                      location,
                      "Not a native context") &&
      Utils::ApiCheck(index >= 0, location, "Negative index");
  if (!ok) return i::Handle<i::FixedArray>();
  i::Handle<i::FixedArray> data(env->embedder_data());
  if (index < data->length()) return data;
  if (!Utils::ApiCheck(can_grow, location, "Index too large")) {
    return i::Handle<i::FixedArray>();
  }
  int new_size = i::Max(index, data->length() << 1) + 1;
  data = i::FixedArray::CopySize(data, new_size);
  env->set_embedder_data(*data);
  return data;
}

References v8::Utils::ApiCheck(), v8::internal::FixedArray::CopySize(), v8::internal::compiler::Max(), and v8::Utils::OpenHandle().

Referenced by v8::Context::SetAlignedPointerInEmbedderData(), v8::Context::SetEmbedderData(), v8::Context::SlowGetAlignedPointerFromEmbedderData(), and v8::Context::SlowGetEmbedderData().

Here is the call graph for this function:

Here is the caller graph for this function:

EncodeAlignedAsSmi()

static i::Smi* v8::EncodeAlignedAsSmi ( void *  value, const char *  location  )

static

Definition at line 644 of file api.cc.

                                                                   {
  i::Smi* smi = reinterpret_cast<i::Smi*>(value);
  Utils::ApiCheck(smi->IsSmi(), location, "Pointer is not aligned");
  return smi;
}

References v8::Utils::ApiCheck().

Referenced by v8::Context::SetAlignedPointerInEmbedderData(), and v8::Object::SetAlignedPointerInInternalField().

Here is the call graph for this function:

Here is the caller graph for this function:

EnsureConstructor()

static i::Handle<i::FunctionTemplateInfo> v8::EnsureConstructor ( i::Isolate *  isolate, ObjectTemplate *  object_template  )

static

Definition at line 1268 of file api.cc.

                                     {
  i::Object* obj = Utils::OpenHandle(object_template)->constructor();
  if (!obj ->IsUndefined()) {
    i::FunctionTemplateInfo* info = i::FunctionTemplateInfo::cast(obj);
    return i::Handle<i::FunctionTemplateInfo>(info, isolate);
  }
  Local<FunctionTemplate> templ =
      FunctionTemplate::New(reinterpret_cast<Isolate*>(isolate));
  i::Handle<i::FunctionTemplateInfo> constructor = Utils::OpenHandle(*templ);
  constructor->set_instance_template(*Utils::OpenHandle(object_template));
  Utils::OpenHandle(object_template)->set_constructor(*constructor);
  return constructor;
}

References v8::FunctionTemplate::New(), and v8::Utils::OpenHandle().

Referenced by CreateEnvironment(), GetTemplateInfo(), v8::ObjectTemplate::MarkAsUndetectable(), v8::ObjectTemplate::SetAccessCheckCallbacks(), v8::ObjectTemplate::SetCallAsFunctionHandler(), v8::ObjectTemplate::SetIndexedPropertyHandler(), v8::ObjectTemplate::SetInternalFieldCount(), and v8::ObjectTemplate::SetNamedPropertyHandler().

Here is the call graph for this function:

Here is the caller graph for this function:

ExecSubprocess()

static void v8::ExecSubprocess ( int *  exec_error_fds, int *  stdout_fds, const ExecArgs &  exec_args  )

static

Definition at line 254 of file d8-posix.cc.

                                                      {
  close(exec_error_fds[kReadFD]);  // Don't need this in the child.
  close(stdout_fds[kReadFD]);      // Don't need this in the child.
  close(1);                        // Close stdout.
  dup2(stdout_fds[kWriteFD], 1);   // Dup pipe fd to stdout.
  close(stdout_fds[kWriteFD]);     // Don't need the original fd now.
  fcntl(exec_error_fds[kWriteFD], F_SETFD, FD_CLOEXEC);
  execvp(exec_args.arg0(), exec_args.arg_array());
  // Only get here if the exec failed.  Write errno to the parent to tell
  // them it went wrong.  If it went well the pipe is closed.
  int err = errno;
  int bytes_written;
  do {
    bytes_written = write(exec_error_fds[kWriteFD], &err, sizeof(err));
  } while (bytes_written == -1 && errno == EINTR);
  // Return (and exit child process).
}

References v8::ExecArgs::arg0(), v8::ExecArgs::arg_array(), kReadFD, and kWriteFD.

Referenced by v8::Shell::System().

Here is the call graph for this function:

Here is the caller graph for this function:

ExternalValue()

static void* v8::ExternalValue ( i::Object *  obj )

static

Definition at line 5037 of file api.cc.

                                         {
  // Obscure semantics for undefined, but somehow checked in our unit tests...
  if (obj->IsUndefined()) return NULL;
  i::Object* foreign = i::JSObject::cast(obj)->GetInternalField(0);
  return i::Foreign::cast(foreign)->foreign_address();
}

References NULL.

Referenced by v8::External::Value().

Here is the caller graph for this function:

False()

Handle< Boolean > v8::False ( Isolate *  isolate )

inline

Definition at line 6863 of file v8.h.

                                        {
  typedef internal::Object* S;
  typedef internal::Internals I;
  I::CheckInitialized(isolate);
  S* slot = I::GetRoot(isolate, I::kFalseValueRootIndex);
  return Handle<Boolean>(reinterpret_cast<Boolean*>(slot));
}

Referenced by v8::Boolean::New().

Here is the caller graph for this function:

FOpen()

static FILE* v8::FOpen ( const char *  path, const char *  mode  )

static

Definition at line 1056 of file d8.cc.

                                                       {
#if defined(_MSC_VER) && (defined(_WIN32) || defined(_WIN64))
  FILE* result;
  if (fopen_s(&result, path, mode) == 0) {
    return result;
  } else {
    return NULL;
  }
#else
  FILE* file = fopen(path, mode);
  if (file == NULL) return NULL;
  struct stat file_stat;
  if (fstat(fileno(file), &file_stat) != 0) return NULL;
  bool is_regular_file = ((file_stat.st_mode & S_IFREG) != 0);
  if (is_regular_file) return file;
  fclose(file);
  return NULL;
#endif
}

References file(), mode(), and NULL.

Referenced by ReadChars().

Here is the call graph for this function:

Here is the caller graph for this function:

FromCData()

template<typename T >

v8::internal::Handle<v8::internal::Object> v8::FromCData ( v8::internal::Isolate *  isolate, T  obj  )

inline

Definition at line 104 of file api.h.

                                       {
  STATIC_ASSERT(sizeof(T) == sizeof(v8::internal::Address));
  return isolate->factory()->NewForeign(
      reinterpret_cast<v8::internal::Address>(reinterpret_cast<intptr_t>(obj)));
}

References v8::internal::Isolate::factory(), STATIC_ASSERT, and T.

Referenced by v8::internal::Accessors::MakeAccessor(), and v8::internal::Accessors::MakeModuleExport().

Here is the call graph for this function:

Here is the caller graph for this function:

FunctionTemplateNew()

static Local<FunctionTemplate> v8::FunctionTemplateNew ( i::Isolate *  isolate, FunctionCallback  callback, v8::Handle< Value >  data, v8::Handle< Signature >  signature, int  length, bool  do_not_cache  )

static

Definition at line 871 of file api.cc.

                       {
  i::Handle<i::Struct> struct_obj =
      isolate->factory()->NewStruct(i::FUNCTION_TEMPLATE_INFO_TYPE);
  i::Handle<i::FunctionTemplateInfo> obj =
      i::Handle<i::FunctionTemplateInfo>::cast(struct_obj);
  InitializeFunctionTemplate(obj);
  obj->set_do_not_cache(do_not_cache);
  int next_serial_number = 0;
  if (!do_not_cache) {
    next_serial_number = isolate->next_serial_number() + 1;
    isolate->set_next_serial_number(next_serial_number);
  }
  obj->set_serial_number(i::Smi::FromInt(next_serial_number));
  if (callback != 0) {
    if (data.IsEmpty()) {
      data = v8::Undefined(reinterpret_cast<v8::Isolate*>(isolate));
    }
    Utils::ToLocal(obj)->SetCallHandler(callback, data);
  }
  obj->set_length(length);
  obj->set_undetectable(false);
  obj->set_needs_access_check(false);
  if (!signature.IsEmpty())
    obj->set_signature(*Utils::OpenHandle(*signature));
  return Utils::ToLocal(obj);
}

References v8::internal::Handle< T >::cast(), v8::internal::do_not_cache, v8::internal::Isolate::factory(), v8::internal::Smi::FromInt(), v8::internal::FUNCTION_TEMPLATE_INFO_TYPE, InitializeFunctionTemplate(), v8::Handle< T >::IsEmpty(), v8::Utils::OpenHandle(), v8::Utils::ToLocal(), and Undefined().

Referenced by v8::Function::New(), and v8::FunctionTemplate::New().

Here is the call graph for this function:

Here is the caller graph for this function:

getBoolProperty()

static bool v8::getBoolProperty ( const StackFrame *  f, const char *  propertyName  )

static

Definition at line 2345 of file api.cc.

                                                                           {
  i::Isolate* isolate = Utils::OpenHandle(f)->GetIsolate();
  ENTER_V8(isolate);
  i::HandleScope scope(isolate);
  i::Handle<i::JSObject> self = Utils::OpenHandle(f);
  i::Handle<i::Object> obj =
      i::Object::GetProperty(isolate, self, propertyName).ToHandleChecked();
  return obj->IsTrue();
}

References ENTER_V8, v8::internal::Object::GetProperty(), and v8::Utils::OpenHandle().

Referenced by v8::StackFrame::IsConstructor(), and v8::StackFrame::IsEval().

Here is the call graph for this function:

Here is the caller graph for this function:

getIntProperty()

static int v8::getIntProperty ( const StackFrame *  f, const char *  propertyName, int  defaultValue  )

static

Definition at line 2289 of file api.cc.

                                            {
  i::Isolate* isolate = Utils::OpenHandle(f)->GetIsolate();
  ENTER_V8(isolate);
  i::HandleScope scope(isolate);
  i::Handle<i::JSObject> self = Utils::OpenHandle(f);
  i::Handle<i::Object> obj =
      i::Object::GetProperty(isolate, self, propertyName).ToHandleChecked();
  return obj->IsSmi() ? i::Smi::cast(*obj)->value() : defaultValue;
}

References ENTER_V8, v8::internal::Object::GetProperty(), and v8::Utils::OpenHandle().

Referenced by v8::StackFrame::GetColumn(), v8::StackFrame::GetLineNumber(), and v8::StackFrame::GetScriptId().

Here is the call graph for this function:

Here is the caller graph for this function:

GetPropertyByLookup()

static Local<Value> v8::GetPropertyByLookup ( i::LookupIterator *  it )

static

Definition at line 3665 of file api.cc.

                                                             {
  // If the property being looked up is a callback, it can throw an exception.
  EXCEPTION_PREAMBLE(it->isolate());
  i::Handle<i::Object> result;
  has_pending_exception = !i::Object::GetProperty(it).ToHandle(&result);
  EXCEPTION_BAILOUT_CHECK(it->isolate(), Local<Value>());
 
  if (it->IsFound()) return Utils::ToLocal(result);
  return Local<Value>();
}

References EXCEPTION_BAILOUT_CHECK, EXCEPTION_PREAMBLE, v8::internal::Object::GetProperty(), and v8::Utils::ToLocal().

Referenced by v8::Object::GetRealNamedProperty(), and v8::Object::GetRealNamedPropertyInPrototypeChain().

Here is the call graph for this function:

Here is the caller graph for this function:

GetStdout()

static Handle<Value> v8::GetStdout ( Isolate *  isolate, int  child_fd, const struct timeval &  start_time, int  read_timeout, int  total_timeout  )

static

Definition at line 293 of file d8-posix.cc.

                                                  {
  Handle<String> accumulator = String::Empty(isolate);
 
  int fullness = 0;
  static const int kStdoutReadBufferSize = 4096;
  char buffer[kStdoutReadBufferSize];
 
  if (fcntl(child_fd, F_SETFL, O_NONBLOCK) != 0) {
    return isolate->ThrowException(
        String::NewFromUtf8(isolate, strerror(errno)));
  }
 
  int bytes_read;
  do {
    bytes_read = read(child_fd,
                      buffer + fullness,
                      kStdoutReadBufferSize - fullness);
    if (bytes_read == -1) {
      if (errno == EAGAIN) {
        if (!WaitOnFD(child_fd,
                      read_timeout,
                      total_timeout,
                      start_time) ||
            (TimeIsOut(start_time, total_timeout))) {
          return isolate->ThrowException(
              String::NewFromUtf8(isolate, "Timed out waiting for output"));
        }
        continue;
      } else if (errno == EINTR) {
        continue;
      } else {
        break;
      }
    }
    if (bytes_read + fullness > 0) {
      int length = bytes_read == 0 ?
                   bytes_read + fullness :
                   LengthWithoutIncompleteUtf8(buffer, bytes_read + fullness);
      Handle<String> addition =
          String::NewFromUtf8(isolate, buffer, String::kNormalString, length);
      accumulator = String::Concat(accumulator, addition);
      fullness = bytes_read + fullness - length;
      memcpy(buffer, buffer + length, fullness);
    }
  } while (bytes_read != 0);
  return accumulator;
}

References v8::String::Concat(), v8::String::Empty(), v8::String::kNormalString, LengthWithoutIncompleteUtf8(), v8::String::NewFromUtf8(), v8::Isolate::ThrowException(), TimeIsOut(), and WaitOnFD().

Referenced by v8::Shell::System().

Here is the call graph for this function:

Here is the caller graph for this function:

getStringProperty()

static Local<String> v8::getStringProperty ( const StackFrame *  f, const char *  propertyName  )

static

Definition at line 2316 of file api.cc.

                                                                 {
  i::Isolate* isolate = Utils::OpenHandle(f)->GetIsolate();
  ENTER_V8(isolate);
  EscapableHandleScope scope(reinterpret_cast<Isolate*>(isolate));
  i::Handle<i::JSObject> self = Utils::OpenHandle(f);
  i::Handle<i::Object> obj =
      i::Object::GetProperty(isolate, self, propertyName).ToHandleChecked();
  return obj->IsString()
             ? scope.Escape(Local<String>::Cast(Utils::ToLocal(obj)))
             : Local<String>();
}

References ENTER_V8, v8::EscapableHandleScope::Escape(), v8::internal::Object::GetProperty(), v8::Utils::OpenHandle(), and v8::Utils::ToLocal().

Referenced by v8::StackFrame::GetFunctionName(), v8::StackFrame::GetScriptName(), and v8::StackFrame::GetScriptNameOrSourceURL().

Here is the call graph for this function:

Here is the caller graph for this function:

GetTemplateInfo() [1/2]

static i::Handle<i::TemplateInfo> v8::GetTemplateInfo ( i::Isolate *  isolate, ObjectTemplate *  object_template  )

inlinestatic

Definition at line 1307 of file api.cc.

                                     {
  EnsureConstructor(isolate, object_template);
  return Utils::OpenHandle(object_template);
}

References EnsureConstructor(), and v8::Utils::OpenHandle().

Here is the call graph for this function:

GetTemplateInfo() [2/2]

static i::Handle<i::TemplateInfo> v8::GetTemplateInfo ( i::Isolate *  isolate, Template *  template_obj  )

inlinestatic

Definition at line 1299 of file api.cc.

                            {
  return Utils::OpenHandle(template_obj);
}

References v8::Utils::OpenHandle().

Referenced by TemplateSetAccessor().

Here is the call graph for this function:

Here is the caller graph for this function:

GetTimeouts()

static bool v8::GetTimeouts ( const v8::FunctionCallbackInfo< v8::Value > &  args, int *  read_timeout, int *  total_timeout  )

static

Definition at line 222 of file d8-posix.cc.

                                            {
  if (args.Length() > 3) {
    if (args[3]->IsNumber()) {
      *total_timeout = args[3]->Int32Value();
    } else {
      args.GetIsolate()->ThrowException(String::NewFromUtf8(
          args.GetIsolate(), "system: Argument 4 must be a number"));
      return false;
    }
  }
  if (args.Length() > 2) {
    if (args[2]->IsNumber()) {
      *read_timeout = args[2]->Int32Value();
    } else {
      args.GetIsolate()->ThrowException(String::NewFromUtf8(
          args.GetIsolate(), "system: Argument 3 must be a number"));
      return false;
    }
  }
  return true;
}

References v8::FunctionCallbackInfo< T >::GetIsolate(), v8::FunctionCallbackInfo< T >::Length(), v8::String::NewFromUtf8(), and v8::Isolate::ThrowException().

Referenced by v8::Shell::System().

Here is the call graph for this function:

Here is the caller graph for this function:

GetWellKnownSymbol()

static Local<Symbol> v8::GetWellKnownSymbol ( Isolate *  isolate, const char *  name  )

static

Definition at line 6217 of file api.cc.

                                                                            {
  i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
  i::Handle<i::String> i_name =
      Utils::OpenHandle(*String::NewFromUtf8(isolate, name));
  i::Handle<i::String> part = i_isolate->factory()->for_intern_string();
  return Utils::ToLocal(SymbolFor(i_isolate, i_name, part));
}

References v8::internal::Isolate::factory(), name, v8::String::NewFromUtf8(), v8::Utils::OpenHandle(), SymbolFor(), and v8::Utils::ToLocal().

Referenced by v8::Symbol::GetIterator(), and v8::Symbol::GetUnscopables().

Here is the call graph for this function:

Here is the caller graph for this function:

HandleDebugEvent()

void v8::HandleDebugEvent

(

const Debug::EventDetails &

event_details

)

Definition at line 17 of file d8-debug.cc.

                                                              {
  // TODO(svenpanne) There should be a way to retrieve this in the callback.
  Isolate* isolate = Isolate::GetCurrent();
  HandleScope scope(isolate);
 
  DebugEvent event = event_details.GetEvent();
  // Check for handled event.
  if (event != Break && event != Exception && event != AfterCompile) {
    return;
  }
 
  TryCatch try_catch;
 
  // Get the toJSONProtocol function on the event and get the JSON format.
  Local<String> to_json_fun_name =
      String::NewFromUtf8(isolate, "toJSONProtocol");
  Handle<Object> event_data = event_details.GetEventData();
  Local<Function> to_json_fun =
      Local<Function>::Cast(event_data->Get(to_json_fun_name));
  Local<Value> event_json = to_json_fun->Call(event_data, 0, NULL);
  if (try_catch.HasCaught()) {
    Shell::ReportException(isolate, &try_catch);
    return;
  }
 
  // Print the event details.
  Handle<Object> details =
      Shell::DebugMessageDetails(isolate, Handle<String>::Cast(event_json));
  if (try_catch.HasCaught()) {
    Shell::ReportException(isolate, &try_catch);
    return;
  }
  String::Utf8Value str(details->Get(String::NewFromUtf8(isolate, "text")));
  if (str.length() == 0) {
    // Empty string is used to signal not to process this event.
    return;
  }
  printf("%s\n", *str);
 
  // Get the debug command processor.
  Local<String> fun_name =
      String::NewFromUtf8(isolate, "debugCommandProcessor");
  Handle<Object> exec_state = event_details.GetExecutionState();
  Local<Function> fun = Local<Function>::Cast(exec_state->Get(fun_name));
  Local<Object> cmd_processor =
      Local<Object>::Cast(fun->Call(exec_state, 0, NULL));
  if (try_catch.HasCaught()) {
    Shell::ReportException(isolate, &try_catch);
    return;
  }
 
  static const int kBufferSize = 256;
  bool running = false;
  while (!running) {
    char command[kBufferSize];
    PrintPrompt(running);
    char* str = fgets(command, kBufferSize, stdin);
    if (str == NULL) break;
 
    // Ignore empty commands.
    if (strlen(command) == 0) continue;
 
    TryCatch try_catch;
 
    // Convert the debugger command to a JSON debugger request.
    Handle<Value> request = Shell::DebugCommandToJSONRequest(
        isolate, String::NewFromUtf8(isolate, command));
    if (try_catch.HasCaught()) {
      Shell::ReportException(isolate, &try_catch);
      continue;
    }
 
    // If undefined is returned the command was handled internally and there is
    // no JSON to send.
    if (request->IsUndefined()) {
      continue;
    }
 
    Handle<String> fun_name;
    Handle<Function> fun;
    // All the functions used below take one argument.
    static const int kArgc = 1;
    Handle<Value> args[kArgc];
 
    // Invoke the JavaScript to convert the debug command line to a JSON
    // request, invoke the JSON request and convert the JSON respose to a text
    // representation.
    fun_name = String::NewFromUtf8(isolate, "processDebugRequest");
    fun = Handle<Function>::Cast(cmd_processor->Get(fun_name));
    args[0] = request;
    Handle<Value> response_val = fun->Call(cmd_processor, kArgc, args);
    if (try_catch.HasCaught()) {
      Shell::ReportException(isolate, &try_catch);
      continue;
    }
    Handle<String> response = Handle<String>::Cast(response_val);
 
    // Convert the debugger response into text details and the running state.
    Handle<Object> response_details =
        Shell::DebugMessageDetails(isolate, response);
    if (try_catch.HasCaught()) {
      Shell::ReportException(isolate, &try_catch);
      continue;
    }
    String::Utf8Value text_str(
        response_details->Get(String::NewFromUtf8(isolate, "text")));
    if (text_str.length() > 0) {
      printf("%s\n", *text_str);
    }
    running = response_details->Get(String::NewFromUtf8(isolate, "running"))
                  ->ToBoolean()
                  ->Value();
  }
}

References AfterCompile, Break, v8::Handle< T >::Cast(), v8::Local< T >::Cast(), v8::Shell::DebugCommandToJSONRequest(), v8::Shell::DebugMessageDetails(), v8::Isolate::GetCurrent(), v8::Debug::EventDetails::GetEvent(), v8::Debug::EventDetails::GetEventData(), v8::Debug::EventDetails::GetExecutionState(), v8::TryCatch::HasCaught(), v8::base::anonymous_namespace{semaphore-unittest.cc}::kBufferSize, v8::String::Utf8Value::length(), v8::String::NewFromUtf8(), NULL, PrintPrompt(), and v8::Shell::ReportException().

Referenced by v8::Shell::InstallUtilityScript().

Here is the call graph for this function:

Here is the caller graph for this function:

InitializeFunctionTemplate()

static void v8::InitializeFunctionTemplate ( i::Handle< i::FunctionTemplateInfo >  info )

static

Definition at line 843 of file api.cc.

                                         {
  info->set_tag(i::Smi::FromInt(Consts::FUNCTION_TEMPLATE));
  info->set_flag(0);
}

References v8::internal::Smi::FromInt(), and v8::Consts::FUNCTION_TEMPLATE.

Referenced by FunctionTemplateNew().

Here is the call graph for this function:

Here is the caller graph for this function:

InitializeTemplate()

static void v8::InitializeTemplate ( i::Handle< i::TemplateInfo >  that, int  type  )

static

Definition at line 777 of file api.cc.

                                                                      {
  that->set_tag(i::Smi::FromInt(type));
}

References v8::internal::Smi::FromInt().

Referenced by v8::ObjectTemplate::New().

Here is the call graph for this function:

Here is the caller graph for this function:

InternalFieldOK()

static bool v8::InternalFieldOK ( i::Handle< i::JSObject >  obj, int  index, const char *  location  )

static

Definition at line 4992 of file api.cc.

                                                  {
  return Utils::ApiCheck(index < obj->GetInternalFieldCount(),
                         location,
                         "Internal field out of bounds");
}

References v8::Utils::ApiCheck().

Referenced by v8::Object::SetAlignedPointerInInternalField(), v8::Object::SetInternalField(), v8::Object::SlowGetAlignedPointerFromInternalField(), and v8::Object::SlowGetInternalField().

Here is the call graph for this function:

Here is the caller graph for this function:

IsExecutionTerminatingCheck()

static bool v8::IsExecutionTerminatingCheck ( i::Isolate *  isolate )

inlinestatic

Definition at line 195 of file api.cc.

                                                                  {
  if (!isolate->IsInitialized()) return false;
  if (isolate->has_scheduled_exception()) {
    return isolate->scheduled_exception() ==
        isolate->heap()->termination_exception();
  }
  return false;
}

References v8::internal::Isolate::has_scheduled_exception(), v8::internal::Isolate::heap(), v8::internal::Isolate::IsInitialized(), and v8::internal::Isolate::scheduled_exception().

Referenced by v8::V8::IsExecutionTerminating().

Here is the call graph for this function:

Here is the caller graph for this function:

LengthWithoutIncompleteUtf8()

static int v8::LengthWithoutIncompleteUtf8 ( char *  buffer, int  len  )

static

Definition at line 29 of file d8-posix.cc.

                                                              {
  int answer = len;
  // 1-byte encoding.
  static const int kUtf8SingleByteMask = 0x80;
  static const int kUtf8SingleByteValue = 0x00;
  // 2-byte encoding.
  static const int kUtf8TwoByteMask = 0xe0;
  static const int kUtf8TwoByteValue = 0xc0;
  // 3-byte encoding.
  static const int kUtf8ThreeByteMask = 0xf0;
  static const int kUtf8ThreeByteValue = 0xe0;
  // 4-byte encoding.
  static const int kUtf8FourByteMask = 0xf8;
  static const int kUtf8FourByteValue = 0xf0;
  // Subsequent bytes of a multi-byte encoding.
  static const int kMultiByteMask = 0xc0;
  static const int kMultiByteValue = 0x80;
  int multi_byte_bytes_seen = 0;
  while (answer > 0) {
    int c = buffer[answer - 1];
    // Ends in valid single-byte sequence?
    if ((c & kUtf8SingleByteMask) == kUtf8SingleByteValue) return answer;
    // Ends in one or more subsequent bytes of a multi-byte value?
    if ((c & kMultiByteMask) == kMultiByteValue) {
      multi_byte_bytes_seen++;
      answer--;
    } else {
      if ((c & kUtf8TwoByteMask) == kUtf8TwoByteValue) {
        if (multi_byte_bytes_seen >= 1) {
          return answer + 2;
        }
        return answer - 1;
      } else if ((c & kUtf8ThreeByteMask) == kUtf8ThreeByteValue) {
        if (multi_byte_bytes_seen >= 2) {
          return answer + 3;
        }
        return answer - 1;
      } else if ((c & kUtf8FourByteMask) == kUtf8FourByteValue) {
        if (multi_byte_bytes_seen >= 3) {
          return answer + 4;
        }
        return answer - 1;
      } else {
        return answer;  // Malformed UTF-8.
      }
    }
  }
  return 0;
}

Referenced by GetStdout().

Here is the caller graph for this function:

MakeAccessorInfo() [1/2]

template<typename Getter , typename Setter >

static i::Handle<i::AccessorInfo> v8::MakeAccessorInfo ( v8::Handle< Name >  name, Getter  getter, Setter  setter, v8::Handle< Value >  data, v8::AccessControl  settings, v8::PropertyAttribute  attributes, v8::Handle< AccessorSignature >  signature  )

static

Definition at line 1143 of file api.cc.

                                           {
  i::Isolate* isolate = Utils::OpenHandle(*name)->GetIsolate();
  i::Handle<i::ExecutableAccessorInfo> obj =
      isolate->factory()->NewExecutableAccessorInfo();
  SET_FIELD_WRAPPED(obj, set_getter, getter);
  SET_FIELD_WRAPPED(obj, set_setter, setter);
  if (data.IsEmpty()) {
    data = v8::Undefined(reinterpret_cast<v8::Isolate*>(isolate));
  }
  obj->set_data(*Utils::OpenHandle(*data));
  return SetAccessorInfoProperties(obj, name, settings, attributes, signature);
}

References v8::internal::Isolate::factory(), v8::Handle< T >::IsEmpty(), name, v8::Utils::OpenHandle(), SET_FIELD_WRAPPED, SetAccessorInfoProperties(), and Undefined().

Referenced by ObjectSetAccessor(), and TemplateSetAccessor().

Here is the call graph for this function:

Here is the caller graph for this function:

MakeAccessorInfo() [2/2]

static i::Handle<i::AccessorInfo> v8::MakeAccessorInfo ( v8::Handle< Name >  name, v8::Handle< v8::DeclaredAccessorDescriptor >  descriptor, void *  setter_ignored, void *  data_ignored, v8::AccessControl  settings, v8::PropertyAttribute  attributes, v8::Handle< AccessorSignature >  signature  )

static

Definition at line 1164 of file api.cc.

                                           {
  i::Isolate* isolate = Utils::OpenHandle(*name)->GetIsolate();
  if (descriptor.IsEmpty()) return i::Handle<i::DeclaredAccessorInfo>();
  i::Handle<i::DeclaredAccessorInfo> obj =
      isolate->factory()->NewDeclaredAccessorInfo();
  obj->set_descriptor(*Utils::OpenHandle(*descriptor));
  return SetAccessorInfoProperties(obj, name, settings, attributes, signature);
}

References v8::internal::Isolate::factory(), v8::Handle< T >::IsEmpty(), name, v8::Utils::OpenHandle(), and SetAccessorInfoProperties().

Here is the call graph for this function:

maybe()

template<class T >

Maybe<T> v8::maybe ( T  t )

inline

Definition at line 902 of file v8.h.

                           {
  return Maybe<T>(t);
}

Referenced by v8::internal::JSObject::AddProperty(), v8::internal::DeclareGlobals(), v8::internal::JSObject::DefineAccessor(), v8::internal::JSObject::DeleteElement(), v8::internal::MemoryChunk::FromAnyPointerAddress(), v8::internal::JSObject::GetElementAttributeWithInterceptor(), v8::internal::JSObject::GetElementAttributeWithoutInterceptor(), v8::internal::JSObject::GetElementAttributeWithReceiver(), v8::internal::GetOldValue(), v8::internal::GetOwnProperty(), v8::internal::JSReceiver::GetPropertyAttributes(), v8::internal::JSObject::GetPropertyAttributesWithFailedAccessCheck(), v8::internal::JSProxy::GetPropertyAttributesWithHandler(), v8::internal::JSObject::GetPropertyAttributesWithInterceptor(), v8::Object::Has(), v8::internal::JSReceiver::HasElement(), v8::internal::JSObject::HasHiddenProperties(), v8::internal::Runtime::HasObjectProperty(), v8::internal::JSReceiver::HasOwnElement(), v8::internal::JSReceiver::HasOwnProperty(), v8::Object::HasOwnProperty(), v8::internal::HasOwnPropertyImplementation(), v8::internal::JSReceiver::HasProperty(), v8::internal::JSProxy::HasPropertyWithHandler(), v8::internal::JSObject::HasRealElementProperty(), v8::Object::HasRealIndexedProperty(), v8::internal::JSObject::HasRealNamedCallbackProperty(), v8::Object::HasRealNamedCallbackProperty(), v8::internal::JSObject::HasRealNamedProperty(), v8::Object::HasRealNamedProperty(), v8::internal::IterateElements(), v8::internal::LoadLookupSlotHelper(), v8::internal::Context::Lookup(), v8::internal::MaterializeArgumentsObject(), v8::internal::ModuleGetExport(), v8::internal::ModuleSetExport(), v8::internal::RUNTIME_FUNCTION(), v8::internal::SetClosureVariableValue(), v8::internal::JSObject::SetElement(), v8::internal::SetLocalVariableValue(), v8::internal::anonymous_namespace{i18n.cc}::SetResolvedNumberSettings(), v8::TryCatch::StackTrace(), v8::internal::JSObjectWalkVisitor< ContextObject >::StructureWalk(), v8::internal::BreakIterator::UnpackBreakIterator(), v8::internal::Collator::UnpackCollator(), v8::internal::DateFormat::UnpackDateFormat(), v8::internal::NumberFormat::UnpackNumberFormat(), and v8::internal::UnscopableLookup().

Here is the caller graph for this function:

mkdirp()

static bool v8::mkdirp ( Isolate *  isolate, char *  directory, mode_t  mask  )

static

Definition at line 589 of file d8-posix.cc.

                                                                   {
  int result = mkdir(directory, mask);
  if (result == 0) return true;
  if (errno == EEXIST) {
    return CheckItsADirectory(isolate, directory);
  } else if (errno == ENOENT) {  // Intermediate path element is missing.
    char* last_slash = strrchr(directory, '/');
    if (last_slash == NULL) {
      isolate->ThrowException(String::NewFromUtf8(isolate, strerror(errno)));
      return false;
    }
    *last_slash = 0;
    if (!mkdirp(isolate, directory, mask)) return false;
    *last_slash = '/';
    result = mkdir(directory, mask);
    if (result == 0) return true;
    if (errno == EEXIST) {
      return CheckItsADirectory(isolate, directory);
    }
    isolate->ThrowException(String::NewFromUtf8(isolate, strerror(errno)));
    return false;
  } else {
    isolate->ThrowException(String::NewFromUtf8(isolate, strerror(errno)));
    return false;
  }
}

References CheckItsADirectory(), v8::String::NewFromUtf8(), NULL, and v8::Isolate::ThrowException().

Referenced by v8::Shell::MakeDirectory().

Here is the call graph for this function:

Here is the caller graph for this function:

NewBitmaskCompare()

template<typename T >

static Local<DeclaredAccessorDescriptor> v8::NewBitmaskCompare ( Isolate *  isolate, T  bitmask, T  compare_value, RawOperationDescriptor *  operation  )

static

Definition at line 1026 of file api.cc.

                                       {
  i::DeclaredAccessorDescriptorData data;
  data.type = i::kDescriptorBitmaskCompare;
  data.bitmask_compare_descriptor.bitmask = bitmask;
  data.bitmask_compare_descriptor.compare_value = compare_value;
  data.bitmask_compare_descriptor.size = sizeof(T);
  return NewDescriptor<DeclaredAccessorDescriptor>(isolate, data, operation);
}

References v8::internal::BitmaskCompareDescriptor::bitmask, v8::internal::DeclaredAccessorDescriptorData::bitmask_compare_descriptor, v8::internal::BitmaskCompareDescriptor::compare_value, v8::internal::kDescriptorBitmaskCompare, v8::internal::BitmaskCompareDescriptor::size, T, and v8::internal::DeclaredAccessorDescriptorData::type.

Referenced by v8::RawOperationDescriptor::NewBitmaskCompare16(), v8::RawOperationDescriptor::NewBitmaskCompare32(), and v8::RawOperationDescriptor::NewBitmaskCompare8().

Here is the caller graph for this function:

NewDescriptor()

template<typename Operation >

static Local<Operation> v8::NewDescriptor ( Isolate *  isolate, const i::DeclaredAccessorDescriptorData &  data, Data *  previous_descriptor  )

static

Definition at line 949 of file api.cc.

                               {
  i::Isolate* internal_isolate = reinterpret_cast<i::Isolate*>(isolate);
  i::Handle<i::DeclaredAccessorDescriptor> previous =
      i::Handle<i::DeclaredAccessorDescriptor>();
  if (previous_descriptor != NULL) {
    previous = Utils::OpenHandle(
        static_cast<DeclaredAccessorDescriptor*>(previous_descriptor));
  }
  i::Handle<i::DeclaredAccessorDescriptor> descriptor =
      i::DeclaredAccessorDescriptor::Create(internal_isolate, data, previous);
  return Utils::Convert<i::DeclaredAccessorDescriptor, Operation>(descriptor);
}

References v8::internal::DeclaredAccessorDescriptor::Create(), NULL, and v8::Utils::OpenHandle().

Here is the call graph for this function:

NewExternalOneByteStringHandle()

static i::MaybeHandle<i::String> v8::NewExternalOneByteStringHandle ( i::Isolate *  isolate, v8::String::ExternalOneByteStringResource *  resource  )

static

Definition at line 5505 of file api.cc.

                                                                        {
  return isolate->factory()->NewExternalStringFromOneByte(resource);
}

References v8::internal::Isolate::factory().

Referenced by v8::String::NewExternal().

Here is the call graph for this function:

Here is the caller graph for this function:

NewExternalStringHandle()

static i::MaybeHandle<i::String> v8::NewExternalStringHandle ( i::Isolate *  isolate, v8::String::ExternalStringResource *  resource  )

static

Definition at line 5499 of file api.cc.

                                                                 {
  return isolate->factory()->NewExternalStringFromTwoByte(resource);
}

References v8::internal::Isolate::factory().

Referenced by v8::String::NewExternal().

Here is the call graph for this function:

Here is the caller graph for this function:

NewTypedArray()

template<typename ElementType , ExternalArrayType array_type, i::ElementsKind elements_kind>

i::Handle<i::JSTypedArray> v8::NewTypedArray	(	i::Isolate *	isolate,
		Handle< ArrayBuffer >	array_buffer,
		size_t	byte_offset,
		size_t	length
	)

Definition at line 6106 of file api.cc.

                                                                         {
  i::Handle<i::JSTypedArray> obj =
      isolate->factory()->NewJSTypedArray(array_type);
  i::Handle<i::JSArrayBuffer> buffer = Utils::OpenHandle(*array_buffer);
 
  DCHECK(byte_offset % sizeof(ElementType) == 0);
 
  CHECK(length <= (std::numeric_limits<size_t>::max() / sizeof(ElementType)));
  CHECK(length <= static_cast<size_t>(i::Smi::kMaxValue));
  size_t byte_length = length * sizeof(ElementType);
  SetupArrayBufferView(
      isolate, obj, buffer, byte_offset, byte_length);
 
  i::Handle<i::Object> length_object =
      isolate->factory()->NewNumberFromSize(length);
  obj->set_length(*length_object);
 
  i::Handle<i::ExternalArray> elements =
      isolate->factory()->NewExternalArray(
          static_cast<int>(length), array_type,
          static_cast<uint8_t*>(buffer->backing_store()) + byte_offset);
  i::Handle<i::Map> map =
      i::JSObject::GetElementsTransitionMap(obj, elements_kind);
  i::JSObject::SetMapAndElements(obj, map, elements);
  return obj;
}

References CHECK, DCHECK, v8::internal::Isolate::factory(), v8::internal::JSObject::GetElementsTransitionMap(), v8::internal::Smi::kMaxValue, map, v8::Utils::OpenHandle(), v8::internal::JSObject::SetMapAndElements(), and SetupArrayBufferView().

Here is the call graph for this function:

Null()

Handle< Primitive > v8::Null ( Isolate *  isolate )

inline

Definition at line 6845 of file v8.h.

                                         {
  typedef internal::Object* S;
  typedef internal::Internals I;
  I::CheckInitialized(isolate);
  S* slot = I::GetRoot(isolate, I::kNullValueRootIndex);
  return Handle<Primitive>(reinterpret_cast<Primitive*>(slot));
}

Referenced by v8::internal::HGraphBuilder::BuildCompareNil(), v8::internal::CompareNilICStub::GetInputType(), and v8::internal::CompareNilICStub::GetType().

Here is the caller graph for this function:

ObjectSetAccessor()

template<typename Getter , typename Setter , typename Data >

static bool v8::ObjectSetAccessor ( Object *  obj, Handle< Name >  name, Getter  getter, Setter  setter, Data  data, AccessControl  settings, PropertyAttribute  attributes  )

inlinestatic

Definition at line 3514 of file api.cc.

                                                                   {
  i::Isolate* isolate = Utils::OpenHandle(obj)->GetIsolate();
  ON_BAILOUT(isolate, "v8::Object::SetAccessor()", return false);
  ENTER_V8(isolate);
  i::HandleScope scope(isolate);
  v8::Handle<AccessorSignature> signature;
  i::Handle<i::AccessorInfo> info = MakeAccessorInfo(
      name, getter, setter, data, settings, attributes, signature);
  if (info.is_null()) return false;
  bool fast = Utils::OpenHandle(obj)->HasFastProperties();
  i::Handle<i::Object> result;
  ASSIGN_RETURN_ON_EXCEPTION_VALUE(
      isolate, result,
      i::JSObject::SetAccessor(Utils::OpenHandle(obj), info),
      false);
  if (result->IsUndefined()) return false;
  if (fast) i::JSObject::MigrateSlowToFast(Utils::OpenHandle(obj), 0);
  return true;
}

References ASSIGN_RETURN_ON_EXCEPTION_VALUE, ENTER_V8, v8::internal::Handle< T >::is_null(), MakeAccessorInfo(), v8::internal::JSObject::MigrateSlowToFast(), name, ON_BAILOUT, v8::Utils::OpenHandle(), and v8::internal::JSObject::SetAccessor().

Referenced by v8::Object::SetAccessor(), and v8::Object::SetDeclaredAccessor().

Here is the call graph for this function:

Here is the caller graph for this function:

operator<()

bool v8::operator< ( const CounterAndKey &  lhs, const CounterAndKey &  rhs  )

inline

Definition at line 1007 of file d8.cc.

                                                                          {
  return strcmp(lhs.key, rhs.key) < 0;
}

References v8::CounterAndKey::key.

PrintPrompt()

void v8::PrintPrompt

(

bool

is_running

)

Definition at line 10 of file d8-debug.cc.

                                  {
  const char* prompt = is_running? "> " : "dbg> ";
  printf("%s", prompt);
  fflush(stdout);
}

Referenced by HandleDebugEvent().

Here is the caller graph for this function:

ReadBufferWeakCallback()

static void v8::ReadBufferWeakCallback ( const v8::WeakCallbackData< ArrayBuffer, DataAndPersistent > &  data )

static

Definition at line 1103 of file d8.cc.

                                                                    {
  size_t byte_length = data.GetValue()->ByteLength();
  data.GetIsolate()->AdjustAmountOfExternalAllocatedMemory(
      -static_cast<intptr_t>(byte_length));
 
  delete[] data.GetParameter()->data;
  data.GetParameter()->handle.Reset();
  delete data.GetParameter();
}

References v8::Isolate::AdjustAmountOfExternalAllocatedMemory(), v8::WeakCallbackData< T, P >::GetIsolate(), v8::WeakCallbackData< T, P >::GetParameter(), and v8::WeakCallbackData< T, P >::GetValue().

Referenced by v8::Shell::ReadBuffer().

Here is the call graph for this function:

Here is the caller graph for this function:

ReadChars()

static char* v8::ReadChars ( Isolate *  isolate, const char *  name, int *  size_out  )

static

Definition at line 1077 of file d8.cc.

                                                                          {
  FILE* file = FOpen(name, "rb");
  if (file == NULL) return NULL;
 
  fseek(file, 0, SEEK_END);
  int size = ftell(file);
  rewind(file);
 
  char* chars = new char[size + 1];
  chars[size] = '\0';
  for (int i = 0; i < size;) {
    int read = static_cast<int>(fread(&chars[i], 1, size - i, file));
    i += read;
  }
  fclose(file);
  *size_out = size;
  return chars;
}

References file(), FOpen(), name, NULL, and size.

Referenced by v8::Shell::ReadBuffer(), v8::SourceGroup::ReadFile(), and v8::Shell::ReadFile().

Here is the call graph for this function:

Here is the caller graph for this function:

RecursivelySerializeToUtf8()

static bool v8::RecursivelySerializeToUtf8 ( i::String *  current, Utf8WriterVisitor *  writer, int  recursion_budget  )

static

Definition at line 4752 of file api.cc.

                                                             {
  while (!writer->IsDone()) {
    i::ConsString* cons_string = i::String::VisitFlat(writer, current);
    if (cons_string == NULL) return true;  // Leaf node.
    if (recursion_budget <= 0) return false;
    // Must write the left branch first.
    i::String* first = cons_string->first();
    bool success = RecursivelySerializeToUtf8(first,
                                              writer,
                                              recursion_budget - 1);
    if (!success) return false;
    // Inline tail recurse for right branch.
    current = cons_string->second();
  }
  return true;
}

References v8::internal::ConsString::first(), v8::Utf8WriterVisitor::IsDone(), NULL, v8::internal::ConsString::second(), and v8::internal::String::VisitFlat().

Referenced by v8::String::WriteUtf8().

Here is the call graph for this function:

Here is the caller graph for this function:

REGEXP_FLAG_ASSERT_EQ() [1/4]

v8::REGEXP_FLAG_ASSERT_EQ	(	kGlobal	,
		GLOBAL
	)

REGEXP_FLAG_ASSERT_EQ() [2/4]

v8::REGEXP_FLAG_ASSERT_EQ	(	kIgnoreCase	,
		IGNORE_CASE
	)

REGEXP_FLAG_ASSERT_EQ() [3/4]

v8::REGEXP_FLAG_ASSERT_EQ	(	kMultiline	,
		MULTILINE
	)

REGEXP_FLAG_ASSERT_EQ() [4/4]

v8::REGEXP_FLAG_ASSERT_EQ	(	kNone	,
		NONE
	)

RegExpFlagsToString()

static i::Handle<i::String> v8::RegExpFlagsToString ( RegExp::Flags  flags )

static

Definition at line 5755 of file api.cc.

                                                               {
  i::Isolate* isolate = i::Isolate::Current();
  uint8_t flags_buf[3];
  int num_flags = 0;
  if ((flags & RegExp::kGlobal) != 0) flags_buf[num_flags++] = 'g';
  if ((flags & RegExp::kMultiline) != 0) flags_buf[num_flags++] = 'm';
  if ((flags & RegExp::kIgnoreCase) != 0) flags_buf[num_flags++] = 'i';
  DCHECK(num_flags <= static_cast<int>(arraysize(flags_buf)));
  return isolate->factory()->InternalizeOneByteString(
      i::Vector<const uint8_t>(flags_buf, num_flags));
}

References arraysize, DCHECK, v8::internal::Isolate::factory(), v8::internal::anonymous_namespace{flags.cc}::flags, v8::RegExp::kGlobal, v8::RegExp::kIgnoreCase, v8::RegExp::kMultiline, and v8::internal::anonymous_namespace{flags.cc}::num_flags.

Referenced by v8::RegExp::New().

Here is the call graph for this function:

Here is the caller graph for this function:

RegisterExtension()

void v8::RegisterExtension

(

Extension *

that

)

Definition at line 398 of file api.cc.

                                        {
  RegisteredExtension* extension = new RegisteredExtension(that);
  RegisteredExtension::Register(extension);
}

References v8::RegisteredExtension::Register().

Here is the call graph for this function:

SetAccessorInfoProperties()

static i::Handle<i::AccessorInfo> v8::SetAccessorInfoProperties ( i::Handle< i::AccessorInfo >  obj, v8::Handle< Name >  name, v8::AccessControl  settings, v8::PropertyAttribute  attributes, v8::Handle< AccessorSignature >  signature  )

static

Definition at line 1125 of file api.cc.

                                           {
  obj->set_name(*Utils::OpenHandle(*name));
  if (settings & ALL_CAN_READ) obj->set_all_can_read(true);
  if (settings & ALL_CAN_WRITE) obj->set_all_can_write(true);
  obj->set_property_attributes(static_cast<PropertyAttributes>(attributes));
  if (!signature.IsEmpty()) {
    obj->set_expected_receiver_type(*Utils::OpenHandle(*signature));
  }
  return obj;
}

References ALL_CAN_READ, ALL_CAN_WRITE, v8::Handle< T >::IsEmpty(), name, and v8::Utils::OpenHandle().

Referenced by MakeAccessorInfo().

Here is the call graph for this function:

Here is the caller graph for this function:

SetFlagsFromString()

void v8::SetFlagsFromString ( const char *  flags )

static

Definition at line 7473 of file api.cc.

                                                  {
  V8::SetFlagsFromString(flags, i::StrLength(flags));
}

References v8::internal::anonymous_namespace{flags.cc}::flags, v8::V8::SetFlagsFromString(), and v8::internal::StrLength().

Referenced by v8::Shell::Main(), v8::Testing::PrepareStressRun(), and v8::Shell::SetOptions().

Here is the call graph for this function:

Here is the caller graph for this function:

SetResourceConstraints()

void v8::SetResourceConstraints	(	i::Isolate *	isolate,
		const ResourceConstraints &	constraints
	)

Definition at line 474 of file api.cc.

                                                                    {
  int semi_space_size = constraints.max_semi_space_size();
  int old_space_size = constraints.max_old_space_size();
  int max_executable_size = constraints.max_executable_size();
  size_t code_range_size = constraints.code_range_size();
  if (semi_space_size != 0 || old_space_size != 0 ||
      max_executable_size != 0 || code_range_size != 0) {
    isolate->heap()->ConfigureHeap(semi_space_size, old_space_size,
                                   max_executable_size, code_range_size);
  }
  if (constraints.stack_limit() != NULL) {
    uintptr_t limit = reinterpret_cast<uintptr_t>(constraints.stack_limit());
    isolate->stack_guard()->SetStackLimit(limit);
  }
 
  isolate->set_max_available_threads(constraints.max_available_threads());
}

References v8::ResourceConstraints::code_range_size(), v8::internal::Heap::ConfigureHeap(), v8::internal::Isolate::heap(), v8::ResourceConstraints::max_available_threads(), v8::ResourceConstraints::max_executable_size(), v8::ResourceConstraints::max_old_space_size(), v8::ResourceConstraints::max_semi_space_size(), NULL, v8::internal::Isolate::stack_guard(), and v8::ResourceConstraints::stack_limit().

Referenced by v8::Isolate::New().

Here is the call graph for this function:

Here is the caller graph for this function:

SetupArrayBufferView()

static void v8::SetupArrayBufferView ( i::Isolate *  isolate, i::Handle< i::JSArrayBufferView >  obj, i::Handle< i::JSArrayBuffer >  buffer, size_t  byte_offset, size_t  byte_length  )

inlinestatic

Definition at line 6080 of file api.cc.

                        {
  DCHECK(byte_offset + byte_length <=
         static_cast<size_t>(buffer->byte_length()->Number()));
 
  obj->set_buffer(*buffer);
 
  obj->set_weak_next(buffer->weak_first_view());
  buffer->set_weak_first_view(*obj);
 
  i::Handle<i::Object> byte_offset_object =
      isolate->factory()->NewNumberFromSize(byte_offset);
  obj->set_byte_offset(*byte_offset_object);
 
  i::Handle<i::Object> byte_length_object =
      isolate->factory()->NewNumberFromSize(byte_length);
  obj->set_byte_length(*byte_length_object);
}

References DCHECK, and v8::internal::Isolate::factory().

Referenced by v8::DataView::New(), and NewTypedArray().

Here is the call graph for this function:

Here is the caller graph for this function:

SymbolFor()

static i::Handle<i::Symbol> v8::SymbolFor ( i::Isolate *  isolate, i::Handle< i::String >  name, i::Handle< i::String >  part  )

static

Definition at line 6182 of file api.cc.

                                                             {
  i::Handle<i::JSObject> registry = isolate->GetSymbolRegistry();
  i::Handle<i::JSObject> symbols =
      i::Handle<i::JSObject>::cast(
          i::Object::GetPropertyOrElement(registry, part).ToHandleChecked());
  i::Handle<i::Object> symbol =
      i::Object::GetPropertyOrElement(symbols, name).ToHandleChecked();
  if (!symbol->IsSymbol()) {
    DCHECK(symbol->IsUndefined());
    symbol = isolate->factory()->NewSymbol();
    i::Handle<i::Symbol>::cast(symbol)->set_name(*name);
    i::JSObject::SetProperty(symbols, name, symbol, i::STRICT).Assert();
  }
  return i::Handle<i::Symbol>::cast(symbol);
}

References v8::internal::Handle< T >::cast(), DCHECK, v8::internal::Isolate::factory(), v8::internal::Object::GetPropertyOrElement(), v8::internal::Isolate::GetSymbolRegistry(), name, v8::internal::Object::SetProperty(), and v8::internal::STRICT.

Referenced by v8::Symbol::For(), v8::Symbol::ForApi(), and GetWellKnownSymbol().

Here is the call graph for this function:

Here is the caller graph for this function:

TemplateSet()

static void v8::TemplateSet ( i::Isolate *  isolate, v8::Template *  templ, int  length, v8::Handle< v8::Data > *  data  )

static

Definition at line 782 of file api.cc.

                                                {
  i::Handle<i::Object> list(Utils::OpenHandle(templ)->property_list(), isolate);
  if (list->IsUndefined()) {
    list = NeanderArray(isolate).value();
    Utils::OpenHandle(templ)->set_property_list(*list);
  }
  NeanderArray array(list);
  array.add(isolate->factory()->NewNumberFromInt(length));
  for (int i = 0; i < length; i++) {
    i::Handle<i::Object> value = data[i].IsEmpty() ?
        i::Handle<i::Object>(isolate->factory()->undefined_value()) :
        Utils::OpenHandle(*data[i]);
    array.add(value);
  }
}

References v8::NeanderArray::add(), v8::internal::Isolate::factory(), v8::Handle< T >::IsEmpty(), v8::Utils::OpenHandle(), and v8::NeanderArray::value().

Referenced by v8::Template::Set(), and v8::Template::SetAccessorProperty().

Here is the call graph for this function:

Here is the caller graph for this function:

TemplateSetAccessor()

template<typename Getter , typename Setter , typename Data , typename Template >

static bool v8::TemplateSetAccessor ( Template *  template_obj, v8::Local< Name >  name, Getter  getter, Setter  setter, Data  data, AccessControl  settings, PropertyAttribute  attribute, v8::Local< AccessorSignature >  signature  )

static

Definition at line 1316 of file api.cc.

                                          {
  i::Isolate* isolate = Utils::OpenHandle(template_obj)->GetIsolate();
  ENTER_V8(isolate);
  i::HandleScope scope(isolate);
  i::Handle<i::AccessorInfo> obj = MakeAccessorInfo(
      name, getter, setter, data, settings, attribute, signature);
  if (obj.is_null()) return false;
  i::Handle<i::TemplateInfo> info = GetTemplateInfo(isolate, template_obj);
  AddPropertyToTemplate(info, obj);
  return true;
}

References AddPropertyToTemplate(), ENTER_V8, GetTemplateInfo(), v8::internal::Handle< T >::is_null(), MakeAccessorInfo(), name, and v8::Utils::OpenHandle().

Referenced by v8::ObjectTemplate::SetAccessor(), v8::Template::SetDeclaredAccessor(), and v8::Template::SetNativeDataProperty().

Here is the call graph for this function:

Here is the caller graph for this function:

Throw()

static Handle<Value> v8::Throw ( Isolate *  isolate, const char *  message  )

static

Definition at line 72 of file d8.cc.

                                                                  {
  return isolate->ThrowException(String::NewFromUtf8(isolate, message));
}

References v8::String::NewFromUtf8(), and v8::Isolate::ThrowException().

Referenced by v8::Shell::Load(), v8::internal::BASE_EMBEDDED< Visitor >::NewThrow(), v8::Shell::Read(), v8::Shell::ReadBuffer(), v8::Shell::RealmDispose(), v8::Shell::RealmEval(), v8::PerIsolateData::RealmIndexOrThrow(), and v8::Shell::RealmOwner().

Here is the call graph for this function:

Here is the caller graph for this function:

TimeIsOut()

static bool v8::TimeIsOut ( const struct timeval &  start_time, const int &  total_time  )

static

Definition at line 123 of file d8-posix.cc.

                                                                               {
  if (total_time == -1) return false;
  struct timeval time_now;
  gettimeofday(&time_now, NULL);
  // Careful about overflow.
  int seconds = time_now.tv_sec - start_time.tv_sec;
  if (seconds > 100) {
    if (seconds * 1000 > total_time) return true;
    return false;
  }
  int useconds = time_now.tv_usec - start_time.tv_usec;
  if (seconds * 1000000 + useconds > total_time * 1000) {
    return true;
  }
  return false;
}

References NULL.

Referenced by GetStdout(), and WaitForChild().

Here is the caller graph for this function:

ToApi()

template<class T >

T* v8::ToApi ( v8::internal::Handle< v8::internal::Object >  obj )

inline

Definition at line 309 of file api.h.

                                                        {
  return reinterpret_cast<T*>(obj.location());
}

References T.

ToApiHandle()

template<class T >

v8::Local<T> v8::ToApiHandle ( v8::internal::Handle< v8::internal::Object >  obj )

inline

Definition at line 314 of file api.h.

                                            {
  return Utils::Convert<v8::internal::Object, T>(obj);
}

ToCData()

template<typename T >

T v8::ToCData ( v8::internal::Object *  obj )

inline

Definition at line 95 of file api.h.

                                                              {
  STATIC_ASSERT(sizeof(T) == sizeof(v8::internal::Address));
  return reinterpret_cast<T>(
      reinterpret_cast<intptr_t>(
          v8::internal::Foreign::cast(obj)->foreign_address()));
}

References STATIC_ASSERT, and T.

ToInternal() [1/3]

static i::HeapGraphEdge* v8::ToInternal ( const HeapGraphEdge *  edge )

static

Definition at line 7213 of file api.cc.

                                                             {
  return const_cast<i::HeapGraphEdge*>(
      reinterpret_cast<const i::HeapGraphEdge*>(edge));
}

Referenced by v8::HeapSnapshot::Delete(), v8::HeapGraphNode::GetChild(), v8::HeapGraphNode::GetChildrenCount(), v8::HeapGraphEdge::GetFromNode(), v8::HeapGraphNode::GetId(), v8::HeapSnapshot::GetMaxSnapshotJSObjectId(), v8::HeapGraphEdge::GetName(), v8::HeapGraphNode::GetName(), v8::HeapSnapshot::GetNode(), v8::HeapSnapshot::GetNodeById(), v8::HeapSnapshot::GetNodesCount(), v8::HeapSnapshot::GetRoot(), v8::HeapGraphNode::GetShallowSize(), v8::HeapSnapshot::GetTitle(), v8::HeapGraphEdge::GetToNode(), v8::HeapGraphEdge::GetType(), v8::HeapGraphNode::GetType(), v8::HeapSnapshot::GetUid(), and v8::HeapSnapshot::Serialize().

Here is the caller graph for this function:

ToInternal() [2/3]

static i::HeapEntry* v8::ToInternal ( const HeapGraphNode *  entry )

static

Definition at line 7257 of file api.cc.

                                                          {
  return const_cast<i::HeapEntry*>(
      reinterpret_cast<const i::HeapEntry*>(entry));
}

ToInternal() [3/3]

static i::HeapSnapshot* v8::ToInternal ( const HeapSnapshot *  snapshot )

static

Definition at line 7303 of file api.cc.

                                                               {
  return const_cast<i::HeapSnapshot*>(
      reinterpret_cast<const i::HeapSnapshot*>(snapshot));
}

References snapshot().

Here is the call graph for this function:

True()

Handle< Boolean > v8::True ( Isolate *  isolate )

inline

Definition at line 6854 of file v8.h.

                                       {
  typedef internal::Object* S;
  typedef internal::Internals I;
  I::CheckInitialized(isolate);
  S* slot = I::GetRoot(isolate, I::kTrueValueRootIndex);
  return Handle<Boolean>(reinterpret_cast<Boolean*>(slot));
}

Referenced by v8::ScriptCompiler::Compile(), v8::ScriptCompiler::CompileUnbound(), and v8::Boolean::New().

Here is the caller graph for this function:

Unaligned()

static bool v8::Unaligned ( const uint16_t *  chars )

inlinestatic

Definition at line 4261 of file api.cc.

                                                    {
  return reinterpret_cast<const uintptr_t>(chars) & kAlignmentMask;
}

References kAlignmentMask.

Referenced by v8::ContainsOnlyOneByteHelper::VisitTwoByteString().

Here is the caller graph for this function:

Undefined()

Handle< Primitive > v8::Undefined ( Isolate *  isolate )

inline

Definition at line 6836 of file v8.h.

                                              {
  typedef internal::Object* S;
  typedef internal::Internals I;
  I::CheckInitialized(isolate);
  S* slot = I::GetRoot(isolate, I::kUndefinedValueRootIndex);
  return Handle<Primitive>(reinterpret_cast<Primitive*>(slot));
}

Referenced by v8::internal::HGraphBuilder::BuildCompareNil(), FunctionTemplateNew(), v8::Function::GetBoundFunction(), v8::internal::CompareNilICStub::GetInputType(), v8::HeapGraphEdge::GetName(), v8::internal::CompareNilICStub::GetType(), v8::Shell::InstallUtilityScript(), MakeAccessorInfo(), v8::FunctionCallbackInfo< T >::operator[](), v8::TryCatch::ReThrow(), v8::ObjectTemplate::SetAccessCheckCallbacks(), v8::ObjectTemplate::SetCallAsFunctionHandler(), v8::FunctionTemplate::SetCallHandler(), v8::ObjectTemplate::SetIndexedPropertyHandler(), v8::ObjectTemplate::SetNamedPropertyHandler(), v8::Isolate::ThrowException(), v8::internal::HGraphBuilder::TruncateToNumber(), v8::internal::compiler::Typer::Typer(), and v8::internal::PropertyCell::UpdatedType().

Here is the caller graph for this function:

Utf8Length()

static int v8::Utf8Length ( i::String *  str, i::Isolate *  isolate  )

static

Definition at line 4549 of file api.cc.

                                                       {
  int length = str->length();
  if (length == 0) return 0;
  uint8_t state;
  i::ConsString* cons_string =
      Utf8LengthHelper::Visitor::VisitFlat(str, &length, &state);
  if (cons_string == NULL) return length;
  return Utf8LengthHelper::Calculate(cons_string);
}

References v8::Utf8LengthHelper::Calculate(), v8::internal::String::length(), NULL, and v8::Utf8LengthHelper::Visitor::VisitFlat().

Referenced by v8::String::Utf8Length(), v8::String::Utf8Value::Utf8Value(), and v8::String::WriteUtf8().

Here is the call graph for this function:

Here is the caller graph for this function:

WaitForChild()

static bool v8::WaitForChild ( Isolate *  isolate, int  pid, ZombieProtector &  child_waiter, const struct timeval &  start_time, int  read_timeout, int  total_timeout  )

static

Definition at line 365 of file d8-posix.cc.

                                            {
#ifdef HAS_WAITID
 
  siginfo_t child_info;
  child_info.si_pid = 0;
  int useconds = 1;
  // Wait for child to exit.
  while (child_info.si_pid == 0) {
    waitid(P_PID, pid, &child_info, WEXITED | WNOHANG | WNOWAIT);
    usleep(useconds);
    if (useconds < 1000000) useconds <<= 1;
    if ((read_timeout != -1 && useconds / 1000 > read_timeout) ||
        (TimeIsOut(start_time, total_timeout))) {
      isolate->ThrowException(String::NewFromUtf8(
          isolate, "Timed out waiting for process to terminate"));
      kill(pid, SIGINT);
      return false;
    }
  }
  if (child_info.si_code == CLD_KILLED) {
    char message[999];
    snprintf(message,
             sizeof(message),
             "Child killed by signal %d",
             child_info.si_status);
    isolate->ThrowException(String::NewFromUtf8(isolate, message));
    return false;
  }
  if (child_info.si_code == CLD_EXITED && child_info.si_status != 0) {
    char message[999];
    snprintf(message,
             sizeof(message),
             "Child exited with status %d",
             child_info.si_status);
    isolate->ThrowException(String::NewFromUtf8(isolate, message));
    return false;
  }
 
#else  // No waitid call.
 
  int child_status;
  waitpid(pid, &child_status, 0);  // We hang here if the child doesn't exit.
  child_waiter.ChildIsDeadNow();
  if (WIFSIGNALED(child_status)) {
    char message[999];
    snprintf(message,
             sizeof(message),
             "Child killed by signal %d",
             WTERMSIG(child_status));
    isolate->ThrowException(String::NewFromUtf8(isolate, message));
    return false;
  }
  if (WEXITSTATUS(child_status) != 0) {
    char message[999];
    int exit_status = WEXITSTATUS(child_status);
    snprintf(message,
             sizeof(message),
             "Child exited with status %d",
             exit_status);
    isolate->ThrowException(String::NewFromUtf8(isolate, message));
    return false;
  }
 
#endif  // No waitid call.
 
  return true;
}

References v8::ZombieProtector::ChildIsDeadNow(), v8::String::NewFromUtf8(), v8::Isolate::ThrowException(), and TimeIsOut().

Referenced by v8::Shell::System().

Here is the call graph for this function:

Here is the caller graph for this function:

WaitOnFD()

static bool v8::WaitOnFD ( int  fd, int  read_timeout, int  total_timeout, const struct timeval &  start_time  )

static

Definition at line 82 of file d8-posix.cc.

                                                       {
  fd_set readfds, writefds, exceptfds;
  struct timeval timeout;
  int gone = 0;
  if (total_timeout != -1) {
    struct timeval time_now;
    gettimeofday(&time_now, NULL);
    int seconds = time_now.tv_sec - start_time.tv_sec;
    gone = seconds * 1000 + (time_now.tv_usec - start_time.tv_usec) / 1000;
    if (gone >= total_timeout) return false;
  }
  FD_ZERO(&readfds);
  FD_ZERO(&writefds);
  FD_ZERO(&exceptfds);
  FD_SET(fd, &readfds);
  FD_SET(fd, &exceptfds);
  if (read_timeout == -1 ||
      (total_timeout != -1 && total_timeout - gone < read_timeout)) {
    read_timeout = total_timeout - gone;
  }
  timeout.tv_usec = (read_timeout % 1000) * 1000;
  timeout.tv_sec = read_timeout / 1000;
#if V8_OS_NACL
  // PNaCL has no support for select.
  int number_of_fds_ready = -1;
#else
  int number_of_fds_ready = select(fd + 1,
                                   &readfds,
                                   &writefds,
                                   &exceptfds,
                                   read_timeout != -1 ? &timeout : NULL);
#endif
  return number_of_fds_ready == 1;
}

References NULL.

Referenced by GetStdout().

Here is the caller graph for this function:

WriteHelper()

template<typename CharType >

static int v8::WriteHelper ( const String *  string, CharType *  buffer, int  start, int  length, int  options  )

inlinestatic

Definition at line 4824 of file api.cc.

                                           {
  i::Isolate* isolate = Utils::OpenHandle(string)->GetIsolate();
  LOG_API(isolate, "String::Write");
  ENTER_V8(isolate);
  DCHECK(start >= 0 && length >= -1);
  i::Handle<i::String> str = Utils::OpenHandle(string);
  isolate->string_tracker()->RecordWrite(str);
  if (options & String::HINT_MANY_WRITES_EXPECTED) {
    // Flatten the string for efficiency.  This applies whether we are
    // using StringCharacterStream or Get(i) to access the characters.
    str = i::String::Flatten(str);
  }
  int end = start + length;
  if ((length == -1) || (length > str->length() - start) )
    end = str->length();
  if (end < 0) return 0;
  i::String::WriteToFlat(*str, buffer, start, end);
  if (!(options & String::NO_NULL_TERMINATION) &&
      (length == -1 || end - start < length)) {
    buffer[end - start] = '\0';
  }
  return end - start;
}

References DCHECK, ENTER_V8, v8::internal::String::Flatten(), v8::String::HINT_MANY_WRITES_EXPECTED, LOG_API, v8::String::NO_NULL_TERMINATION, v8::Utils::OpenHandle(), v8::internal::StringTracker::RecordWrite(), v8::internal::Isolate::string_tracker(), and v8::internal::String::WriteToFlat().

Referenced by v8::String::Write(), and v8::String::WriteOneByte().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

kAlignmentMask

const uintptr_t v8::kAlignmentMask = sizeof(uintptr_t) - 1

static

Definition at line 4260 of file api.cc.

Referenced by Align(), and Unaligned().

kOneByteMask

const uintptr_t v8::kOneByteMask = OneByteMask<sizeof(uintptr_t)>::value

static

Definition at line 4259 of file api.cc.

Referenced by v8::ContainsOnlyOneByteHelper::VisitTwoByteString().

kPersistentContainerNotFound

const uintptr_t v8::kPersistentContainerNotFound = 0

static

Definition at line 22 of file v8-util.h.

Referenced by v8::PersistentValueMap< K, V, Traits >::Contains(), v8::DefaultPersistentValueVectorTraits::Get(), v8::StdMapTraits< K, V >::Get(), v8::PersistentValueMap< K, V, Traits >::PersistentValueReference::IsEmpty(), v8::StdMapTraits< K, V >::Remove(), v8::PersistentValueMap< K, V, Traits >::PersistentValueReference::Reset(), v8::StdMapTraits< K, V >::Set(), and v8::PersistentValueMap< K, V, Traits >::SetReturnValueFromVal().

kReadFD

const int v8::kReadFD = 0

static

Definition at line 247 of file d8-posix.cc.

Referenced by ChildLaunchedOK(), ExecSubprocess(), and v8::Shell::System().

kWriteFD

const int v8::kWriteFD = 1

static

Definition at line 248 of file d8-posix.cc.

Referenced by ExecSubprocess(), and v8::Shell::System().

MB

const int v8::MB = 1024 * 1024

Definition at line 164 of file d8.cc.

Referenced by v8::ResourceConstraints::ConfigureDefaults(), and v8::SourceGroup::GetThreadOptions().

read_line_editor

ReadLineEditor v8::read_line_editor

static

Definition at line 47 of file d8-readline.cc.

Referenced by v8::ReadLineEditor::CompletionGenerator().