node-v11.10.1-headers.tar.gz

// Copyright 2012 the V8 project authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. /** \mainpage V8 API Reference Guide * * V8 is Google's open source JavaScript engine. * * This set of documents provides reference material generated from the * V8 header file, include/v8.h. * * For other documentation see http://code.google.com/apis/v8/ */ #ifndef INCLUDE_V8_H_ #define INCLUDE_V8_H_ #include <stddef.h> #include <stdint.h> #include <stdio.h> #include <memory> #include <utility> #include <vector> #include "v8-version.h" // NOLINT(build/include) #include "v8config.h" // NOLINT(build/include) // We reserve the V8_* prefix for macros defined in V8 public API and // assume there are no name conflicts with the embedder's code. #ifdef V8_OS_WIN // Setup for Windows DLL export/import. When building the V8 DLL the // BUILDING_V8_SHARED needs to be defined. When building a program which uses // the V8 DLL USING_V8_SHARED needs to be defined. When either building the V8 // static library or building a program which uses the V8 static library neither // BUILDING_V8_SHARED nor USING_V8_SHARED should be defined. #ifdef BUILDING_V8_SHARED # define V8_EXPORT __declspec(dllexport) #elif USING_V8_SHARED # define V8_EXPORT __declspec(dllimport) #else # define V8_EXPORT #endif // BUILDING_V8_SHARED #else // V8_OS_WIN // Setup for Linux shared library export. #if V8_HAS_ATTRIBUTE_VISIBILITY # ifdef BUILDING_V8_SHARED # define V8_EXPORT __attribute__ ((visibility("default"))) # else # define V8_EXPORT # endif #else # define V8_EXPORT #endif #endif // V8_OS_WIN /** * The v8 JavaScript engine. */ namespace v8 { class AccessorSignature; class Array; class ArrayBuffer; class BigInt; class BigIntObject; class Boolean; class BooleanObject; class Context; class Data; class Date; class External; class Function; class FunctionTemplate; class HeapProfiler; class ImplementationUtilities; class Int32; class Integer; class Isolate; template <class T> class Maybe; class Name; class Number; class NumberObject; class Object; class ObjectOperationDescriptor; class ObjectTemplate; class Platform; class Primitive; class Promise; class PropertyDescriptor; class Proxy; class RawOperationDescriptor; class Script; class SharedArrayBuffer; class Signature; class StartupData; class StackFrame; class StackTrace; class String; class StringObject; class Symbol; class SymbolObject; class PrimitiveArray; class Private; class Uint32; class Utils; class Value; class WasmCompiledModule; template <class T> class Local; template <class T> class MaybeLocal; template <class T> class Eternal; template<class T> class NonCopyablePersistentTraits; template<class T> class PersistentBase; template <class T, class M = NonCopyablePersistentTraits<T> > class Persistent; template <class T> class Global; template<class K, class V, class T> class PersistentValueMap; template <class K, class V, class T> class PersistentValueMapBase; template <class K, class V, class T> class GlobalValueMap; template<class V, class T> class PersistentValueVector; template<class T, class P> class WeakCallbackObject; class FunctionTemplate; class ObjectTemplate; template<typename T> class FunctionCallbackInfo; template<typename T> class PropertyCallbackInfo; class StackTrace; class StackFrame; class Isolate; class CallHandlerHelper; class EscapableHandleScope; template<typename T> class ReturnValue; namespace internal { class Arguments; class DeferredHandles; class Heap; class HeapObject; class Isolate; class LocalEmbedderHeapTracer; class NeverReadOnlySpaceObject; class Object; struct ScriptStreamingData; template<typename T> class CustomArguments; class PropertyCallbackArguments; class FunctionCallbackArguments; class GlobalHandles; namespace wasm { class NativeModule; class StreamingDecoder; } // namespace wasm /** * Configuration of tagging scheme. */ const int kApiPointerSize = sizeof(void*); // NOLINT const int kApiDoubleSize = sizeof(double); // NOLINT const int kApiIntSize = sizeof(int); // NOLINT const int kApiInt64Size = sizeof(int64_t); // NOLINT // Tag information for HeapObject. const int kHeapObjectTag = 1; const int kWeakHeapObjectTag = 3; const int kHeapObjectTagSize = 2; const intptr_t kHeapObjectTagMask = (1 << kHeapObjectTagSize) - 1; // Tag information for Smi. const int kSmiTag = 0; const int kSmiTagSize = 1; const intptr_t kSmiTagMask = (1 << kSmiTagSize) - 1; template <size_t tagged_ptr_size> struct SmiTagging; template <int kSmiShiftSize> V8_INLINE internal::Object* IntToSmi(int value) { int smi_shift_bits = kSmiTagSize + kSmiShiftSize; intptr_t tagged_value = (static_cast<intptr_t>(value) << smi_shift_bits) | kSmiTag; return reinterpret_cast<internal::Object*>(tagged_value); } // Smi constants for systems where tagged pointer is a 32-bit value. template <> struct SmiTagging<4> { enum { kSmiShiftSize = 0, kSmiValueSize = 31 }; static int SmiShiftSize() { return kSmiShiftSize; } static int SmiValueSize() { return kSmiValueSize; } V8_INLINE static int SmiToInt(const internal::Object* value) { int shift_bits = kSmiTagSize + kSmiShiftSize; // Throw away top 32 bits and shift down (requires >> to be sign extending). return static_cast<int>(reinterpret_cast<intptr_t>(value)) >> shift_bits; } V8_INLINE static internal::Object* IntToSmi(int value) { return internal::IntToSmi<kSmiShiftSize>(value); } V8_INLINE static constexpr bool IsValidSmi(intptr_t value) { // To be representable as an tagged small integer, the two // most-significant bits of 'value' must be either 00 or 11 due to // sign-extension. To check this we add 01 to the two // most-significant bits, and check if the most-significant bit is 0 // // CAUTION: The original code below: // bool result = ((value + 0x40000000) & 0x80000000) == 0; // may lead to incorrect results according to the C language spec, and // in fact doesn't work correctly with gcc4.1.1 in some cases: The // compiler may produce undefined results in case of signed integer // overflow. The computation must be done w/ unsigned ints. return static_cast<uintptr_t>(value) + 0x40000000U < 0x80000000U; } }; // Smi constants for systems where tagged pointer is a 64-bit value. template <> struct SmiTagging<8> { enum { kSmiShiftSize = 31, kSmiValueSize = 32 }; static int SmiShiftSize() { return kSmiShiftSize; } static int SmiValueSize() { return kSmiValueSize; } V8_INLINE static int SmiToInt(const internal::Object* value) { int shift_bits = kSmiTagSize + kSmiShiftSize; // Shift down and throw away top 32 bits. return static_cast<int>(reinterpret_cast<intptr_t>(value) >> shift_bits); } V8_INLINE static internal::Object* IntToSmi(int value) { return internal::IntToSmi<kSmiShiftSize>(value); } V8_INLINE static constexpr bool IsValidSmi(intptr_t value) { // To be representable as a long smi, the value must be a 32-bit integer. return (value == static_cast<int32_t>(value)); } }; #if V8_COMPRESS_POINTERS static_assert( kApiPointerSize == kApiInt64Size, "Pointer compression can be enabled only for 64-bit architectures"); typedef SmiTagging<4> PlatformSmiTagging; #else typedef SmiTagging<kApiPointerSize> PlatformSmiTagging; #endif const int kSmiShiftSize = PlatformSmiTagging::kSmiShiftSize; const int kSmiValueSize = PlatformSmiTagging::kSmiValueSize; const int kSmiMinValue = (static_cast<unsigned int>(-1)) << (kSmiValueSize - 1); const int kSmiMaxValue = -(kSmiMinValue + 1); constexpr bool SmiValuesAre31Bits() { return kSmiValueSize == 31; } constexpr bool SmiValuesAre32Bits() { return kSmiValueSize == 32; } } // namespace internal namespace debug { class ConsoleCallArguments; } // namespace debug // --- Handles --- #define TYPE_CHECK(T, S) \ while (false) {