| /********************************************************************* |
| * NAN - Native Abstractions for Node.js |
| * |
| * Copyright (c) 2018 NAN contributors: |
| * - Rod Vagg <https://github.com/rvagg> |
| * - Benjamin Byholm <https://github.com/kkoopa> |
| * - Trevor Norris <https://github.com/trevnorris> |
| * - Nathan Rajlich <https://github.com/TooTallNate> |
| * - Brett Lawson <https://github.com/brett19> |
| * - Ben Noordhuis <https://github.com/bnoordhuis> |
| * - David Siegel <https://github.com/agnat> |
| * - Michael Ira Krufky <https://github.com/mkrufky> |
| * |
| * MIT License <https://github.com/nodejs/nan/blob/master/LICENSE.md> |
| * |
| * Version 2.14.0: current Node 12.2.0, Node 12: 0.12.18, Node 10: 0.10.48, iojs: 3.3.1 |
| * |
| * See https://github.com/nodejs/nan for the latest update to this file |
| **********************************************************************************/ |
| |
| #ifndef NAN_H_ |
| #define NAN_H_ |
| |
| #include <node_version.h> |
| |
| #define NODE_0_10_MODULE_VERSION 11 |
| #define NODE_0_12_MODULE_VERSION 14 |
| #define ATOM_0_21_MODULE_VERSION 41 |
| #define IOJS_1_0_MODULE_VERSION 42 |
| #define IOJS_1_1_MODULE_VERSION 43 |
| #define IOJS_2_0_MODULE_VERSION 44 |
| #define IOJS_3_0_MODULE_VERSION 45 |
| #define NODE_4_0_MODULE_VERSION 46 |
| #define NODE_5_0_MODULE_VERSION 47 |
| #define NODE_6_0_MODULE_VERSION 48 |
| #define NODE_7_0_MODULE_VERSION 51 |
| #define NODE_8_0_MODULE_VERSION 57 |
| #define NODE_9_0_MODULE_VERSION 59 |
| #define NODE_10_0_MODULE_VERSION 64 |
| #define NODE_11_0_MODULE_VERSION 67 |
| #define NODE_12_0_MODULE_VERSION 72 |
| |
| #ifdef _MSC_VER |
| # define NAN_HAS_CPLUSPLUS_11 (_MSC_VER >= 1800) |
| #else |
| # define NAN_HAS_CPLUSPLUS_11 (__cplusplus >= 201103L) |
| #endif |
| |
| #if NODE_MODULE_VERSION >= IOJS_3_0_MODULE_VERSION && !NAN_HAS_CPLUSPLUS_11 |
| # error This version of node/NAN/v8 requires a C++11 compiler |
| #endif |
| |
| #include <uv.h> |
| #include <node.h> |
| #include <node_buffer.h> |
| #include <node_object_wrap.h> |
| #include <algorithm> |
| #include <cstring> |
| #include <climits> |
| #include <cstdlib> |
| #include <utility> |
| #if defined(_MSC_VER) |
| # pragma warning( push ) |
| # pragma warning( disable : 4530 ) |
| # include <queue> |
| # include <string> |
| # include <vector> |
| # pragma warning( pop ) |
| #else |
| # include <queue> |
| # include <string> |
| # include <vector> |
| #endif |
| |
| // uv helpers |
| #ifdef UV_VERSION_MAJOR |
| # ifndef UV_VERSION_PATCH |
| # define UV_VERSION_PATCH 0 |
| # endif |
| # define NAUV_UVVERSION ((UV_VERSION_MAJOR << 16) | \ |
| (UV_VERSION_MINOR << 8) | \ |
| (UV_VERSION_PATCH)) |
| #else |
| # define NAUV_UVVERSION 0x000b00 |
| #endif |
| |
| #if NAUV_UVVERSION < 0x000b0b |
| # ifdef WIN32 |
| # include <windows.h> |
| # else |
| # include <pthread.h> |
| # endif |
| #endif |
| |
| namespace Nan { |
| |
| #define NAN_CONCAT(a, b) NAN_CONCAT_HELPER(a, b) |
| #define NAN_CONCAT_HELPER(a, b) a##b |
| |
| #define NAN_INLINE inline // TODO(bnoordhuis) Remove in v3.0.0. |
| |
| #if defined(__GNUC__) && \ |
| !(defined(V8_DISABLE_DEPRECATIONS) && V8_DISABLE_DEPRECATIONS) |
| # define NAN_DEPRECATED __attribute__((deprecated)) |
| #elif defined(_MSC_VER) && \ |
| !(defined(V8_DISABLE_DEPRECATIONS) && V8_DISABLE_DEPRECATIONS) |
| # define NAN_DEPRECATED __declspec(deprecated) |
| #else |
| # define NAN_DEPRECATED |
| #endif |
| |
| #if NAN_HAS_CPLUSPLUS_11 |
| # define NAN_DISALLOW_ASSIGN(CLASS) void operator=(const CLASS&) = delete; |
| # define NAN_DISALLOW_COPY(CLASS) CLASS(const CLASS&) = delete; |
| # define NAN_DISALLOW_MOVE(CLASS) \ |
| CLASS(CLASS&&) = delete; /* NOLINT(build/c++11) */ \ |
| void operator=(CLASS&&) = delete; |
| #else |
| # define NAN_DISALLOW_ASSIGN(CLASS) void operator=(const CLASS&); |
| # define NAN_DISALLOW_COPY(CLASS) CLASS(const CLASS&); |
| # define NAN_DISALLOW_MOVE(CLASS) |
| #endif |
| |
| #define NAN_DISALLOW_ASSIGN_COPY(CLASS) \ |
| NAN_DISALLOW_ASSIGN(CLASS) \ |
| NAN_DISALLOW_COPY(CLASS) |
| |
| #define NAN_DISALLOW_ASSIGN_MOVE(CLASS) \ |
| NAN_DISALLOW_ASSIGN(CLASS) \ |
| NAN_DISALLOW_MOVE(CLASS) |
| |
| #define NAN_DISALLOW_COPY_MOVE(CLASS) \ |
| NAN_DISALLOW_COPY(CLASS) \ |
| NAN_DISALLOW_MOVE(CLASS) |
| |
| #define NAN_DISALLOW_ASSIGN_COPY_MOVE(CLASS) \ |
| NAN_DISALLOW_ASSIGN(CLASS) \ |
| NAN_DISALLOW_COPY(CLASS) \ |
| NAN_DISALLOW_MOVE(CLASS) |
| |
| #define TYPE_CHECK(T, S) \ |
| while (false) { \ |
| *(static_cast<T *volatile *>(0)) = static_cast<S*>(0); \ |
| } |
| |
| //=== RegistrationFunction ===================================================== |
| |
| #if NODE_MODULE_VERSION < IOJS_3_0_MODULE_VERSION |
| typedef v8::Handle<v8::Object> ADDON_REGISTER_FUNCTION_ARGS_TYPE; |
| #else |
| typedef v8::Local<v8::Object> ADDON_REGISTER_FUNCTION_ARGS_TYPE; |
| #endif |
| |
| #define NAN_MODULE_INIT(name) \ |
| void name(Nan::ADDON_REGISTER_FUNCTION_ARGS_TYPE target) |
| |
| #if NODE_MAJOR_VERSION >= 10 || \ |
| NODE_MAJOR_VERSION == 9 && NODE_MINOR_VERSION >= 3 |
| #define NAN_MODULE_WORKER_ENABLED(module_name, registration) \ |
| extern "C" NODE_MODULE_EXPORT void \ |
| NAN_CONCAT(node_register_module_v, NODE_MODULE_VERSION)( \ |
| v8::Local<v8::Object> exports, v8::Local<v8::Value> module, \ |
| v8::Local<v8::Context> context) \ |
| { \ |
| registration(exports); \ |
| } |
| #else |
| #define NAN_MODULE_WORKER_ENABLED(module_name, registration) \ |
| NODE_MODULE(module_name, registration) |
| #endif |
| |
| //=== CallbackInfo ============================================================= |
| |
| #include "nan_callbacks.h" // NOLINT(build/include) |
| |
| //============================================================================== |
| |
| #if (NODE_MODULE_VERSION < NODE_0_12_MODULE_VERSION) |
| typedef v8::Script UnboundScript; |
| typedef v8::Script BoundScript; |
| #else |
| typedef v8::UnboundScript UnboundScript; |
| typedef v8::Script BoundScript; |
| #endif |
| |
| #if (NODE_MODULE_VERSION < ATOM_0_21_MODULE_VERSION) |
| typedef v8::String::ExternalAsciiStringResource |
| ExternalOneByteStringResource; |
| #else |
| typedef v8::String::ExternalOneByteStringResource |
| ExternalOneByteStringResource; |
| #endif |
| |
| #if (NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION) |
| template<typename T> |
| class NonCopyablePersistentTraits : |
| public v8::NonCopyablePersistentTraits<T> {}; |
| template<typename T> |
| class CopyablePersistentTraits : |
| public v8::CopyablePersistentTraits<T> {}; |
| |
| template<typename T> |
| class PersistentBase : |
| public v8::PersistentBase<T> {}; |
| |
| template<typename T, typename M = v8::NonCopyablePersistentTraits<T> > |
| class Persistent; |
| #else |
| template<typename T> class NonCopyablePersistentTraits; |
| template<typename T> class PersistentBase; |
| template<typename T, typename P> class WeakCallbackData; |
| template<typename T, typename M = NonCopyablePersistentTraits<T> > |
| class Persistent; |
| #endif // NODE_MODULE_VERSION |
| |
| template<typename T> |
| class Maybe { |
| public: |
| inline bool IsNothing() const { return !has_value_; } |
| inline bool IsJust() const { return has_value_; } |
| |
| inline T ToChecked() const { return FromJust(); } |
| inline void Check() const { FromJust(); } |
| |
| inline bool To(T* out) const { |
| if (IsJust()) *out = value_; |
| return IsJust(); |
| } |
| |
| inline T FromJust() const { |
| #if defined(V8_ENABLE_CHECKS) |
| assert(IsJust() && "FromJust is Nothing"); |
| #endif // V8_ENABLE_CHECKS |
| return value_; |
| } |
| |
| inline T FromMaybe(const T& default_value) const { |
| return has_value_ ? value_ : default_value; |
| } |
| |
| inline bool operator==(const Maybe &other) const { |
| return (IsJust() == other.IsJust()) && |
| (!IsJust() || FromJust() == other.FromJust()); |
| } |
| |
| inline bool operator!=(const Maybe &other) const { |
| return !operator==(other); |
| } |
| |
| #if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 || \ |
| (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3)) |
| // Allow implicit conversions from v8::Maybe<T> to Nan::Maybe<T>. |
| Maybe(const v8::Maybe<T>& that) // NOLINT(runtime/explicit) |
| : has_value_(that.IsJust()) |
| , value_(that.FromMaybe(T())) {} |
| #endif |
| |
| private: |
| Maybe() : has_value_(false) {} |
| explicit Maybe(const T& t) : has_value_(true), value_(t) {} |
| bool has_value_; |
| T value_; |
| |
| template<typename U> |
| friend Maybe<U> Nothing(); |
| template<typename U> |
| friend Maybe<U> Just(const U& u); |
| }; |
| |
| template<typename T> |
| inline Maybe<T> Nothing() { |
| return Maybe<T>(); |
| } |
| |
| template<typename T> |
| inline Maybe<T> Just(const T& t) { |
| return Maybe<T>(t); |
| } |
| |
| #if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 || \ |
| (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3)) |
| # include "nan_maybe_43_inl.h" // NOLINT(build/include) |
| #else |
| # include "nan_maybe_pre_43_inl.h" // NOLINT(build/include) |
| #endif |
| |
| #include "nan_converters.h" // NOLINT(build/include) |
| #include "nan_new.h" // NOLINT(build/include) |
| |
| #if NAUV_UVVERSION < 0x000b17 |
| #define NAUV_WORK_CB(func) \ |
| void func(uv_async_t *async, int) |
| #else |
| #define NAUV_WORK_CB(func) \ |
| void func(uv_async_t *async) |
| #endif |
| |
| #if NAUV_UVVERSION >= 0x000b0b |
| |
| typedef uv_key_t nauv_key_t; |
| |
| inline int nauv_key_create(nauv_key_t *key) { |
| return uv_key_create(key); |
| } |
| |
| inline void nauv_key_delete(nauv_key_t *key) { |
| uv_key_delete(key); |
| } |
| |
| inline void* nauv_key_get(nauv_key_t *key) { |
| return uv_key_get(key); |
| } |
| |
| inline void nauv_key_set(nauv_key_t *key, void *value) { |
| uv_key_set(key, value); |
| } |
| |
| #else |
| |
| /* Implement thread local storage for older versions of libuv. |
| * This is essentially a backport of libuv commit 5d2434bf |
| * written by Ben Noordhuis, adjusted for names and inline. |
| */ |
| |
| #ifndef WIN32 |
| |
| typedef pthread_key_t nauv_key_t; |
| |
| inline int nauv_key_create(nauv_key_t* key) { |
| return -pthread_key_create(key, NULL); |
| } |
| |
| inline void nauv_key_delete(nauv_key_t* key) { |
| if (pthread_key_delete(*key)) |
| abort(); |
| } |
| |
| inline void* nauv_key_get(nauv_key_t* key) { |
| return pthread_getspecific(*key); |
| } |
| |
| inline void nauv_key_set(nauv_key_t* key, void* value) { |
| if (pthread_setspecific(*key, value)) |
| abort(); |
| } |
| |
| #else |
| |
| typedef struct { |
| DWORD tls_index; |
| } nauv_key_t; |
| |
| inline int nauv_key_create(nauv_key_t* key) { |
| key->tls_index = TlsAlloc(); |
| if (key->tls_index == TLS_OUT_OF_INDEXES) |
| return UV_ENOMEM; |
| return 0; |
| } |
| |
| inline void nauv_key_delete(nauv_key_t* key) { |
| if (TlsFree(key->tls_index) == FALSE) |
| abort(); |
| key->tls_index = TLS_OUT_OF_INDEXES; |
| } |
| |
| inline void* nauv_key_get(nauv_key_t* key) { |
| void* value = TlsGetValue(key->tls_index); |
| if (value == NULL) |
| if (GetLastError() != ERROR_SUCCESS) |
| abort(); |
| return value; |
| } |
| |
| inline void nauv_key_set(nauv_key_t* key, void* value) { |
| if (TlsSetValue(key->tls_index, value) == FALSE) |
| abort(); |
| } |
| |
| #endif |
| #endif |
| |
| #if NODE_MODULE_VERSION < IOJS_3_0_MODULE_VERSION |
| template<typename T> |
| v8::Local<T> New(v8::Handle<T>); |
| #endif |
| |
| #if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 || \ |
| (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3)) |
| typedef v8::WeakCallbackType WeakCallbackType; |
| #else |
| struct WeakCallbackType { |
| enum E {kParameter, kInternalFields}; |
| E type; |
| WeakCallbackType(E other) : type(other) {} // NOLINT(runtime/explicit) |
| inline bool operator==(E other) { return other == this->type; } |
| inline bool operator!=(E other) { return !operator==(other); } |
| }; |
| #endif |
| |
| template<typename P> class WeakCallbackInfo; |
| |
| #if NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION |
| # include "nan_persistent_12_inl.h" // NOLINT(build/include) |
| #else |
| # include "nan_persistent_pre_12_inl.h" // NOLINT(build/include) |
| #endif |
| |
| namespace imp { |
| static const size_t kMaxLength = 0x3fffffff; |
| // v8::String::REPLACE_INVALID_UTF8 was introduced |
| // in node.js v0.10.29 and v0.8.27. |
| #if NODE_MAJOR_VERSION > 0 || \ |
| NODE_MINOR_VERSION > 10 || \ |
| NODE_MINOR_VERSION == 10 && NODE_PATCH_VERSION >= 29 || \ |
| NODE_MINOR_VERSION == 8 && NODE_PATCH_VERSION >= 27 |
| static const unsigned kReplaceInvalidUtf8 = v8::String::REPLACE_INVALID_UTF8; |
| #else |
| static const unsigned kReplaceInvalidUtf8 = 0; |
| #endif |
| } // end of namespace imp |
| |
| //=== HandleScope ============================================================== |
| |
| class HandleScope { |
| v8::HandleScope scope; |
| |
| public: |
| #if NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION |
| inline HandleScope() : scope(v8::Isolate::GetCurrent()) {} |
| inline static int NumberOfHandles() { |
| return v8::HandleScope::NumberOfHandles(v8::Isolate::GetCurrent()); |
| } |
| #else |
| inline HandleScope() : scope() {} |
| inline static int NumberOfHandles() { |
| return v8::HandleScope::NumberOfHandles(); |
| } |
| #endif |
| |
| private: |
| // Make it hard to create heap-allocated or illegal handle scopes by |
| // disallowing certain operations. |
| HandleScope(const HandleScope &); |
| void operator=(const HandleScope &); |
| void *operator new(size_t size); |
| void operator delete(void *, size_t) { |
| abort(); |
| } |
| }; |
| |
| class EscapableHandleScope { |
| public: |
| #if NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION |
| inline EscapableHandleScope() : scope(v8::Isolate::GetCurrent()) {} |
| |
| inline static int NumberOfHandles() { |
| return v8::EscapableHandleScope::NumberOfHandles(v8::Isolate::GetCurrent()); |
| } |
| |
| template<typename T> |
| inline v8::Local<T> Escape(v8::Local<T> value) { |
| return scope.Escape(value); |
| } |
| |
| private: |
| v8::EscapableHandleScope scope; |
| #else |
| inline EscapableHandleScope() : scope() {} |
| |
| inline static int NumberOfHandles() { |
| return v8::HandleScope::NumberOfHandles(); |
| } |
| |
| template<typename T> |
| inline v8::Local<T> Escape(v8::Local<T> value) { |
| return scope.Close(value); |
| } |
| |
| private: |
| v8::HandleScope scope; |
| #endif |
| |
| private: |
| // Make it hard to create heap-allocated or illegal handle scopes by |
| // disallowing certain operations. |
| EscapableHandleScope(const EscapableHandleScope &); |
| void operator=(const EscapableHandleScope &); |
| void *operator new(size_t size); |
| void operator delete(void *, size_t) { |
| abort(); |
| } |
| }; |
| |
| //=== TryCatch ================================================================= |
| |
| class TryCatch { |
| v8::TryCatch try_catch_; |
| friend void FatalException(const TryCatch&); |
| |
| public: |
| #if NODE_MODULE_VERSION > NODE_0_12_MODULE_VERSION |
| TryCatch() : try_catch_(v8::Isolate::GetCurrent()) {} |
| #endif |
| |
| inline bool HasCaught() const { return try_catch_.HasCaught(); } |
| |
| inline bool CanContinue() const { return try_catch_.CanContinue(); } |
| |
| inline v8::Local<v8::Value> ReThrow() { |
| #if NODE_MODULE_VERSION < IOJS_3_0_MODULE_VERSION |
| return New(try_catch_.ReThrow()); |
| #else |
| return try_catch_.ReThrow(); |
| #endif |
| } |
| |
| inline v8::Local<v8::Value> Exception() const { |
| return try_catch_.Exception(); |
| } |
| |
| #if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 || \ |
| (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3)) |
| inline v8::MaybeLocal<v8::Value> StackTrace() const { |
| v8::Isolate *isolate = v8::Isolate::GetCurrent(); |
| v8::EscapableHandleScope scope(isolate); |
| return scope.Escape(try_catch_.StackTrace(isolate->GetCurrentContext()) |
| .FromMaybe(v8::Local<v8::Value>())); |
| } |
| #else |
| inline MaybeLocal<v8::Value> StackTrace() const { |
| return try_catch_.StackTrace(); |
| } |
| #endif |
| |
| inline v8::Local<v8::Message> Message() const { |
| return try_catch_.Message(); |
| } |
| |
| inline void Reset() { try_catch_.Reset(); } |
| |
| inline void SetVerbose(bool value) { try_catch_.SetVerbose(value); } |
| |
| inline void SetCaptureMessage(bool value) { |
| try_catch_.SetCaptureMessage(value); |
| } |
| }; |
| |
| v8::Local<v8::Value> MakeCallback(v8::Local<v8::Object> target, |
| v8::Local<v8::Function> func, |
| int argc, |
| v8::Local<v8::Value>* argv); |
| v8::Local<v8::Value> MakeCallback(v8::Local<v8::Object> target, |
| v8::Local<v8::String> symbol, |
| int argc, |
| v8::Local<v8::Value>* argv); |
| v8::Local<v8::Value> MakeCallback(v8::Local<v8::Object> target, |
| const char* method, |
| int argc, |
| v8::Local<v8::Value>* argv); |
| |
| // === AsyncResource =========================================================== |
| |
| class AsyncResource { |
| public: |
| AsyncResource( |
| v8::Local<v8::String> name |
| , v8::Local<v8::Object> resource = New<v8::Object>()) { |
| #if NODE_MODULE_VERSION >= NODE_9_0_MODULE_VERSION |
| v8::Isolate* isolate = v8::Isolate::GetCurrent(); |
| |
| if (resource.IsEmpty()) { |
| resource = New<v8::Object>(); |
| } |
| |
| context = node::EmitAsyncInit(isolate, resource, name); |
| #endif |
| } |
| |
| AsyncResource( |
| const char* name |
| , v8::Local<v8::Object> resource = New<v8::Object>()) { |
| #if NODE_MODULE_VERSION >= NODE_9_0_MODULE_VERSION |
| v8::Isolate* isolate = v8::Isolate::GetCurrent(); |
| |
| if (resource.IsEmpty()) { |
| resource = New<v8::Object>(); |
| } |
| |
| v8::Local<v8::String> name_string = |
| New<v8::String>(name).ToLocalChecked(); |
| context = node::EmitAsyncInit(isolate, resource, name_string); |
| #endif |
| } |
| |
| ~AsyncResource() { |
| #if NODE_MODULE_VERSION >= NODE_9_0_MODULE_VERSION |
| v8::Isolate* isolate = v8::Isolate::GetCurrent(); |
| node::EmitAsyncDestroy(isolate, context); |
| #endif |
| } |
| |
| inline MaybeLocal<v8::Value> runInAsyncScope( |
| v8::Local<v8::Object> target |
| , v8::Local<v8::Function> func |
| , int argc |
| , v8::Local<v8::Value>* argv) { |
| #if NODE_MODULE_VERSION < NODE_9_0_MODULE_VERSION |
| return MakeCallback(target, func, argc, argv); |
| #else |
| return node::MakeCallback( |
| v8::Isolate::GetCurrent(), target, func, argc, argv, context); |
| #endif |
| } |
| |
| inline MaybeLocal<v8::Value> runInAsyncScope( |
| v8::Local<v8::Object> target |
| , v8::Local<v8::String> symbol |
| , int argc |
| , v8::Local<v8::Value>* argv) { |
| #if NODE_MODULE_VERSION < NODE_9_0_MODULE_VERSION |
| return MakeCallback(target, symbol, argc, argv); |
| #else |
| return node::MakeCallback( |
| v8::Isolate::GetCurrent(), target, symbol, argc, argv, context); |
| #endif |
| } |
| |
| inline MaybeLocal<v8::Value> runInAsyncScope( |
| v8::Local<v8::Object> target |
| , const char* method |
| , int argc |
| , v8::Local<v8::Value>* argv) { |
| #if NODE_MODULE_VERSION < NODE_9_0_MODULE_VERSION |
| return MakeCallback(target, method, argc, argv); |
| #else |
| return node::MakeCallback( |
| v8::Isolate::GetCurrent(), target, method, argc, argv, context); |
| #endif |
| } |
| |
| private: |
| NAN_DISALLOW_ASSIGN_COPY_MOVE(AsyncResource) |
| #if NODE_MODULE_VERSION >= NODE_9_0_MODULE_VERSION |
| node::async_context context; |
| #endif |
| }; |
| |
| inline uv_loop_t* GetCurrentEventLoop() { |
| #if NODE_MAJOR_VERSION >= 10 || \ |
| NODE_MAJOR_VERSION == 9 && NODE_MINOR_VERSION >= 3 || \ |
| NODE_MAJOR_VERSION == 8 && NODE_MINOR_VERSION >= 10 |
| return node::GetCurrentEventLoop(v8::Isolate::GetCurrent()); |
| #else |
| return uv_default_loop(); |
| #endif |
| } |
| |
| //============ ================================================================= |
| |
| /* node 0.12 */ |
| #if NODE_MODULE_VERSION >= NODE_0_12_MODULE_VERSION |
| inline |
| void SetCounterFunction(v8::CounterLookupCallback cb) { |
| v8::Isolate::GetCurrent()->SetCounterFunction(cb); |
| } |
| |
| inline |
| void SetCreateHistogramFunction(v8::CreateHistogramCallback cb) { |
| v8::Isolate::GetCurrent()->SetCreateHistogramFunction(cb); |
| } |
| |
| inline |
| void SetAddHistogramSampleFunction(v8::AddHistogramSampleCallback cb) { |
| v8::Isolate::GetCurrent()->SetAddHistogramSampleFunction(cb); |
| } |
| |
| #if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 || \ |
| (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3)) |
| inline bool IdleNotification(int idle_time_in_ms) { |
| return v8::Isolate::GetCurrent()->IdleNotificationDeadline( |
| idle_time_in_ms * 0.001); |
| } |
| # else |
| inline bool IdleNotification(int idle_time_in_ms) { |
| return v8::Isolate::GetCurrent()->IdleNotification(idle_time_in_ms); |
| } |
| #endif |
| |
| inline void LowMemoryNotification() { |
| v8::Isolate::GetCurrent()->LowMemoryNotification(); |
| } |
| |
| inline void ContextDisposedNotification() { |
| v8::Isolate::GetCurrent()->ContextDisposedNotification(); |
| } |
| #else |
| inline |
| void SetCounterFunction(v8::CounterLookupCallback cb) { |
| v8::V8::SetCounterFunction(cb); |
| } |
| |
| inline |
| void SetCreateHistogramFunction(v8::CreateHistogramCallback cb) { |
| v8::V8::SetCreateHistogramFunction(cb); |
| } |
| |
| inline |
| void SetAddHistogramSampleFunction(v8::AddHistogramSampleCallback cb) { |
| v8::V8::SetAddHistogramSampleFunction(cb); |
| } |
| |
| inline bool IdleNotification(int idle_time_in_ms) { |
| return v8::V8::IdleNotification(idle_time_in_ms); |
| } |
| |
| inline void LowMemoryNotification() { |
| v8::V8::LowMemoryNotification(); |
| } |
| |
| inline void ContextDisposedNotification() { |
| v8::V8::ContextDisposedNotification(); |
| } |
| #endif |
| |
| #if (NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION) // Node 0.12 |
| inline v8::Local<v8::Primitive> Undefined() { |
| # if NODE_MODULE_VERSION < IOJS_3_0_MODULE_VERSION |
| EscapableHandleScope scope; |
| return scope.Escape(New(v8::Undefined(v8::Isolate::GetCurrent()))); |
| # else |
| return v8::Undefined(v8::Isolate::GetCurrent()); |
| # endif |
| } |
| |
| inline v8::Local<v8::Primitive> Null() { |
| # if NODE_MODULE_VERSION < IOJS_3_0_MODULE_VERSION |
| EscapableHandleScope scope; |
| return scope.Escape(New(v8::Null(v8::Isolate::GetCurrent()))); |
| # else |
| return v8::Null(v8::Isolate::GetCurrent()); |
| # endif |
| } |
| |
| inline v8::Local<v8::Boolean> True() { |
| # if NODE_MODULE_VERSION < IOJS_3_0_MODULE_VERSION |
| EscapableHandleScope scope; |
| return scope.Escape(New(v8::True(v8::Isolate::GetCurrent()))); |
| # else |
| return v8::True(v8::Isolate::GetCurrent()); |
| # endif |
| } |
| |
| inline v8::Local<v8::Boolean> False() { |
| # if NODE_MODULE_VERSION < IOJS_3_0_MODULE_VERSION |
| EscapableHandleScope scope; |
| return scope.Escape(New(v8::False(v8::Isolate::GetCurrent()))); |
| # else |
| return v8::False(v8::Isolate::GetCurrent()); |
| # endif |
| } |
| |
| inline v8::Local<v8::String> EmptyString() { |
| return v8::String::Empty(v8::Isolate::GetCurrent()); |
| } |
| |
| inline int AdjustExternalMemory(int bc) { |
| return static_cast<int>( |
| v8::Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(bc)); |
| } |
| |
| inline void SetTemplate( |
| v8::Local<v8::Template> templ |
| , const char *name |
| , v8::Local<v8::Data> value) { |
| templ->Set(v8::Isolate::GetCurrent(), name, value); |
| } |
| |
| inline void SetTemplate( |
| v8::Local<v8::Template> templ |
| , v8::Local<v8::String> name |
| , v8::Local<v8::Data> value |
| , v8::PropertyAttribute attributes) { |
| templ->Set(name, value, attributes); |
| } |
| |
| inline v8::Local<v8::Context> GetCurrentContext() { |
| return v8::Isolate::GetCurrent()->GetCurrentContext(); |
| } |
| |
| inline void* GetInternalFieldPointer( |
| v8::Local<v8::Object> object |
| , int index) { |
| return object->GetAlignedPointerFromInternalField(index); |
| } |
| |
| inline void SetInternalFieldPointer( |
| v8::Local<v8::Object> object |
| , int index |
| , void* value) { |
| object->SetAlignedPointerInInternalField(index, value); |
| } |
| |
| # define NAN_GC_CALLBACK(name) \ |
| void name(v8::Isolate *isolate, v8::GCType type, v8::GCCallbackFlags flags) |
| |
| #if NODE_MODULE_VERSION <= NODE_4_0_MODULE_VERSION |
| typedef v8::Isolate::GCEpilogueCallback GCEpilogueCallback; |
| typedef v8::Isolate::GCPrologueCallback GCPrologueCallback; |
| #else |
| typedef v8::Isolate::GCCallback GCEpilogueCallback; |
| typedef v8::Isolate::GCCallback GCPrologueCallback; |
| #endif |
| |
| inline void AddGCEpilogueCallback( |
| GCEpilogueCallback callback |
| , v8::GCType gc_type_filter = v8::kGCTypeAll) { |
| v8::Isolate::GetCurrent()->AddGCEpilogueCallback(callback, gc_type_filter); |
| } |
| |
| inline void RemoveGCEpilogueCallback( |
| GCEpilogueCallback callback) { |
| v8::Isolate::GetCurrent()->RemoveGCEpilogueCallback(callback); |
| } |
| |
| inline void AddGCPrologueCallback( |
| GCPrologueCallback callback |
| , v8::GCType gc_type_filter = v8::kGCTypeAll) { |
| v8::Isolate::GetCurrent()->AddGCPrologueCallback(callback, gc_type_filter); |
| } |
| |
| inline void RemoveGCPrologueCallback( |
| GCPrologueCallback callback) { |
| v8::Isolate::GetCurrent()->RemoveGCPrologueCallback(callback); |
| } |
| |
| inline void GetHeapStatistics( |
| v8::HeapStatistics *heap_statistics) { |
| v8::Isolate::GetCurrent()->GetHeapStatistics(heap_statistics); |
| } |
| |
| # define X(NAME) \ |
| inline v8::Local<v8::Value> NAME(const char *msg) { \ |
| EscapableHandleScope scope; \ |
| return scope.Escape(v8::Exception::NAME(New(msg).ToLocalChecked())); \ |
| } \ |
| \ |
| inline \ |
| v8::Local<v8::Value> NAME(v8::Local<v8::String> msg) { \ |
| return v8::Exception::NAME(msg); \ |
| } \ |
| \ |
| inline void Throw ## NAME(const char *msg) { \ |
| HandleScope scope; \ |
| v8::Isolate::GetCurrent()->ThrowException( \ |
| v8::Exception::NAME(New(msg).ToLocalChecked())); \ |
| } \ |
| \ |
| inline void Throw ## NAME(v8::Local<v8::String> msg) { \ |
| HandleScope scope; \ |
| v8::Isolate::GetCurrent()->ThrowException( \ |
| v8::Exception::NAME(msg)); \ |
| } |
| |
| X(Error) |
| X(RangeError) |
| X(ReferenceError) |
| X(SyntaxError) |
| X(TypeError) |
| |
| # undef X |
| |
| inline void ThrowError(v8::Local<v8::Value> error) { |
| v8::Isolate::GetCurrent()->ThrowException(error); |
| } |
| |
| inline MaybeLocal<v8::Object> NewBuffer( |
| char *data |
| , size_t length |
| #if NODE_MODULE_VERSION > IOJS_2_0_MODULE_VERSION |
| , node::Buffer::FreeCallback callback |
| #else |
| , node::smalloc::FreeCallback callback |
| #endif |
| , void *hint |
| ) { |
| // arbitrary buffer lengths requires |
| // NODE_MODULE_VERSION >= IOJS_3_0_MODULE_VERSION |
| assert(length <= imp::kMaxLength && "too large buffer"); |
| #if NODE_MODULE_VERSION > IOJS_2_0_MODULE_VERSION |
| return node::Buffer::New( |
| v8::Isolate::GetCurrent(), data, length, callback, hint); |
| #else |
| return node::Buffer::New(v8::Isolate::GetCurrent(), data, length, callback, |
| hint); |
| #endif |
| } |
| |
| inline MaybeLocal<v8::Object> CopyBuffer( |
| const char *data |
| , uint32_t size |
| ) { |
| // arbitrary buffer lengths requires |
| // NODE_MODULE_VERSION >= IOJS_3_0_MODULE_VERSION |
| assert(size <= imp::kMaxLength && "too large buffer"); |
| #if NODE_MODULE_VERSION > IOJS_2_0_MODULE_VERSION |
| return node::Buffer::Copy( |
| v8::Isolate::GetCurrent(), data, size); |
| #else |
| return node::Buffer::New(v8::Isolate::GetCurrent(), data, size); |
| #endif |
| } |
| |
| inline MaybeLocal<v8::Object> NewBuffer(uint32_t size) { |
| // arbitrary buffer lengths requires |
| // NODE_MODULE_VERSION >= IOJS_3_0_MODULE_VERSION |
| assert(size <= imp::kMaxLength && "too large buffer"); |
| #if NODE_MODULE_VERSION > IOJS_2_0_MODULE_VERSION |
| return node::Buffer::New( |
| v8::Isolate::GetCurrent(), size); |
| #else |
| return node::Buffer::New(v8::Isolate::GetCurrent(), size); |
| #endif |
| } |
| |
| inline MaybeLocal<v8::Object> NewBuffer( |
| char* data |
| , uint32_t size |
| ) { |
| // arbitrary buffer lengths requires |
| // NODE_MODULE_VERSION >= IOJS_3_0_MODULE_VERSION |
| assert(size <= imp::kMaxLength && "too large buffer"); |
| #if NODE_MODULE_VERSION > IOJS_2_0_MODULE_VERSION |
| return node::Buffer::New(v8::Isolate::GetCurrent(), data, size); |
| #else |
| return node::Buffer::Use(v8::Isolate::GetCurrent(), data, size); |
| #endif |
| } |
| |
| #if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 || \ |
| (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3)) |
| inline MaybeLocal<v8::String> |
| NewOneByteString(const uint8_t * value, int length = -1) { |
| return v8::String::NewFromOneByte(v8::Isolate::GetCurrent(), value, |
| v8::NewStringType::kNormal, length); |
| } |
| |
| inline MaybeLocal<BoundScript> CompileScript( |
| v8::Local<v8::String> s |
| , const v8::ScriptOrigin& origin |
| ) { |
| v8::Isolate *isolate = v8::Isolate::GetCurrent(); |
| v8::EscapableHandleScope scope(isolate); |
| v8::ScriptCompiler::Source source(s, origin); |
| return scope.Escape( |
| v8::ScriptCompiler::Compile(isolate->GetCurrentContext(), &source) |
| .FromMaybe(v8::Local<BoundScript>())); |
| } |
| |
| inline MaybeLocal<BoundScript> CompileScript( |
| v8::Local<v8::String> s |
| ) { |
| v8::Isolate *isolate = v8::Isolate::GetCurrent(); |
| v8::EscapableHandleScope scope(isolate); |
| v8::ScriptCompiler::Source source(s); |
| return scope.Escape( |
| v8::ScriptCompiler::Compile(isolate->GetCurrentContext(), &source) |
| .FromMaybe(v8::Local<BoundScript>())); |
| } |
| |
| inline MaybeLocal<v8::Value> RunScript( |
| v8::Local<UnboundScript> script |
| ) { |
| v8::Isolate *isolate = v8::Isolate::GetCurrent(); |
| v8::EscapableHandleScope scope(isolate); |
| return scope.Escape(script->BindToCurrentContext() |
| ->Run(isolate->GetCurrentContext()) |
| .FromMaybe(v8::Local<v8::Value>())); |
| } |
| |
| inline MaybeLocal<v8::Value> RunScript( |
| v8::Local<BoundScript> script |
| ) { |
| v8::Isolate *isolate = v8::Isolate::GetCurrent(); |
| v8::EscapableHandleScope scope(isolate); |
| return scope.Escape(script->Run(isolate->GetCurrentContext()) |
| .FromMaybe(v8::Local<v8::Value>())); |
| } |
| #else |
| inline MaybeLocal<v8::String> |
| NewOneByteString(const uint8_t * value, int length = -1) { |
| return v8::String::NewFromOneByte(v8::Isolate::GetCurrent(), value, |
| v8::String::kNormalString, length); |
| } |
| |
| inline MaybeLocal<BoundScript> CompileScript( |
| v8::Local<v8::String> s |
| , const v8::ScriptOrigin& origin |
| ) { |
| v8::ScriptCompiler::Source source(s, origin); |
| return v8::ScriptCompiler::Compile(v8::Isolate::GetCurrent(), &source); |
| } |
| |
| inline MaybeLocal<BoundScript> CompileScript( |
| v8::Local<v8::String> s |
| ) { |
| v8::ScriptCompiler::Source source(s); |
| return v8::ScriptCompiler::Compile(v8::Isolate::GetCurrent(), &source); |
| } |
| |
| inline MaybeLocal<v8::Value> RunScript( |
| v8::Local<UnboundScript> script |
| ) { |
| EscapableHandleScope scope; |
| return scope.Escape(script->BindToCurrentContext()->Run()); |
| } |
| |
| inline MaybeLocal<v8::Value> RunScript( |
| v8::Local<BoundScript> script |
| ) { |
| return script->Run(); |
| } |
| #endif |
| |
| NAN_DEPRECATED inline v8::Local<v8::Value> MakeCallback( |
| v8::Local<v8::Object> target |
| , v8::Local<v8::Function> func |
| , int argc |
| , v8::Local<v8::Value>* argv) { |
| #if NODE_MODULE_VERSION < IOJS_3_0_MODULE_VERSION |
| EscapableHandleScope scope; |
| return scope.Escape(New(node::MakeCallback( |
| v8::Isolate::GetCurrent(), target, func, argc, argv))); |
| #else |
| # if NODE_MODULE_VERSION >= NODE_9_0_MODULE_VERSION |
| AsyncResource res("nan:makeCallback"); |
| return res.runInAsyncScope(target, func, argc, argv) |
| .FromMaybe(v8::Local<v8::Value>()); |
| # else |
| return node::MakeCallback( |
| v8::Isolate::GetCurrent(), target, func, argc, argv); |
| # endif // NODE_MODULE_VERSION >= NODE_9_0_MODULE_VERSION |
| #endif // NODE_MODULE_VERSION < IOJS_3_0_MODULE_VERSION |
| } |
| |
| NAN_DEPRECATED inline v8::Local<v8::Value> MakeCallback( |
| v8::Local<v8::Object> target |
| , v8::Local<v8::String> symbol |
| , int argc |
| , v8::Local<v8::Value>* argv) { |
| #if NODE_MODULE_VERSION < IOJS_3_0_MODULE_VERSION |
| EscapableHandleScope scope; |
| return scope.Escape(New(node::MakeCallback( |
| v8::Isolate::GetCurrent(), target, symbol, argc, argv))); |
| #else |
| # if NODE_MODULE_VERSION >= NODE_9_0_MODULE_VERSION |
| AsyncResource res("nan:makeCallback"); |
| return res.runInAsyncScope(target, symbol, argc, argv) |
| .FromMaybe(v8::Local<v8::Value>()); |
| # else |
| return node::MakeCallback( |
| v8::Isolate::GetCurrent(), target, symbol, argc, argv); |
| # endif // NODE_MODULE_VERSION >= NODE_9_0_MODULE_VERSION |
| #endif // NODE_MODULE_VERSION < IOJS_3_0_MODULE_VERSION |
| } |
| |
| NAN_DEPRECATED inline v8::Local<v8::Value> MakeCallback( |
| v8::Local<v8::Object> target |
| , const char* method |
| , int argc |
| , v8::Local<v8::Value>* argv) { |
| #if NODE_MODULE_VERSION < IOJS_3_0_MODULE_VERSION |
| EscapableHandleScope scope; |
| return scope.Escape(New(node::MakeCallback( |
| v8::Isolate::GetCurrent(), target, method, argc, argv))); |
| #else |
| # if NODE_MODULE_VERSION >= NODE_9_0_MODULE_VERSION |
| AsyncResource res("nan:makeCallback"); |
| return res.runInAsyncScope(target, method, argc, argv) |
| .FromMaybe(v8::Local<v8::Value>()); |
| # else |
| return node::MakeCallback( |
| v8::Isolate::GetCurrent(), target, method, argc, argv); |
| # endif // NODE_MODULE_VERSION >= NODE_9_0_MODULE_VERSION |
| #endif // NODE_MODULE_VERSION < IOJS_3_0_MODULE_VERSION |
| } |
| |
| inline void FatalException(const TryCatch& try_catch) { |
| node::FatalException(v8::Isolate::GetCurrent(), try_catch.try_catch_); |
| } |
| |
| inline v8::Local<v8::Value> ErrnoException( |
| int errorno |
| , const char* syscall = NULL |
| , const char* message = NULL |
| , const char* path = NULL) { |
| return node::ErrnoException(v8::Isolate::GetCurrent(), errorno, syscall, |
| message, path); |
| } |
| |
| NAN_DEPRECATED inline v8::Local<v8::Value> NanErrnoException( |
| int errorno |
| , const char* syscall = NULL |
| , const char* message = NULL |
| , const char* path = NULL) { |
| return ErrnoException(errorno, syscall, message, path); |
| } |
| |
| template<typename T> |
| inline void SetIsolateData( |
| v8::Isolate *isolate |
| , T *data |
| ) { |
| isolate->SetData(0, data); |
| } |
| |
| template<typename T> |
| inline T *GetIsolateData( |
| v8::Isolate *isolate |
| ) { |
| return static_cast<T*>(isolate->GetData(0)); |
| } |
| |
| class Utf8String { |
| public: |
| inline explicit Utf8String(v8::Local<v8::Value> from) : |
| length_(0), str_(str_st_) { |
| HandleScope scope; |
| if (!from.IsEmpty()) { |
| #if NODE_MAJOR_VERSION >= 10 |
| v8::Local<v8::Context> context = GetCurrentContext(); |
| v8::Local<v8::String> string = |
| from->ToString(context).FromMaybe(v8::Local<v8::String>()); |
| #else |
| v8::Local<v8::String> string = from->ToString(); |
| #endif |
| if (!string.IsEmpty()) { |
| size_t len = 3 * string->Length() + 1; |
| assert(len <= INT_MAX); |
| if (len > sizeof (str_st_)) { |
| str_ = static_cast<char*>(malloc(len)); |
| assert(str_ != 0); |
| } |
| const int flags = |
| v8::String::NO_NULL_TERMINATION | imp::kReplaceInvalidUtf8; |
| #if NODE_MAJOR_VERSION >= 11 |
| length_ = string->WriteUtf8(v8::Isolate::GetCurrent(), str_, |
| static_cast<int>(len), 0, flags); |
| #else |
| // See https://github.com/nodejs/nan/issues/832. |
| // Disable the warning as there is no way around it. |
| #ifdef _MSC_VER |
| #pragma warning(push) |
| #pragma warning(disable : 4996) |
| #endif |
| #ifdef __GNUC__ |
| #pragma GCC diagnostic push |
| #pragma GCC diagnostic ignored "-Wdeprecated-declarations" |
| #endif |
| length_ = string->WriteUtf8(str_, static_cast<int>(len), 0, flags); |
| #ifdef __GNUC__ |
| #pragma GCC diagnostic pop |
| #endif |
| #ifdef _MSC_VER |
| #pragma warning(pop) |
| #endif |
| #endif // NODE_MAJOR_VERSION < 11 |
| str_[length_] = '\0'; |
| } |
| } |
| } |
| |
| inline int length() const { |
| return length_; |
| } |
| |
| inline char* operator*() { return str_; } |
| inline const char* operator*() const { return str_; } |
| |
| inline ~Utf8String() { |
| if (str_ != str_st_) { |
| free(str_); |
| } |
| } |
| |
| private: |
| NAN_DISALLOW_ASSIGN_COPY_MOVE(Utf8String) |
| |
| int length_; |
| char *str_; |
| char str_st_[1024]; |
| }; |
| |
| #else // Node 0.8 and 0.10 |
| inline v8::Local<v8::Primitive> Undefined() { |
| EscapableHandleScope scope; |
| return scope.Escape(New(v8::Undefined())); |
| } |
| |
| inline v8::Local<v8::Primitive> Null() { |
| EscapableHandleScope scope; |
| return scope.Escape(New(v8::Null())); |
| } |
| |
| inline v8::Local<v8::Boolean> True() { |
| EscapableHandleScope scope; |
| return scope.Escape(New(v8::True())); |
| } |
| |
| inline v8::Local<v8::Boolean> False() { |
| EscapableHandleScope scope; |
| return scope.Escape(New(v8::False())); |
| } |
| |
| inline v8::Local<v8::String> EmptyString() { |
| return v8::String::Empty(); |
| } |
| |
| inline int AdjustExternalMemory(int bc) { |
| return static_cast<int>(v8::V8::AdjustAmountOfExternalAllocatedMemory(bc)); |
| } |
| |
| inline void SetTemplate( |
| v8::Local<v8::Template> templ |
| , const char *name |
| , v8::Local<v8::Data> value) { |
| templ->Set(name, value); |
| } |
| |
| inline void SetTemplate( |
| v8::Local<v8::Template> templ |
| , v8::Local<v8::String> name |
| , v8::Local<v8::Data> value |
| , v8::PropertyAttribute attributes) { |
| templ->Set(name, value, attributes); |
| } |
| |
| inline v8::Local<v8::Context> GetCurrentContext() { |
| return v8::Context::GetCurrent(); |
| } |
| |
| inline void* GetInternalFieldPointer( |
| v8::Local<v8::Object> object |
| , int index) { |
| return object->GetPointerFromInternalField(index); |
| } |
| |
| inline void SetInternalFieldPointer( |
| v8::Local<v8::Object> object |
| , int index |
| , void* value) { |
| object->SetPointerInInternalField(index, value); |
| } |
| |
| # define NAN_GC_CALLBACK(name) \ |
| void name(v8::GCType type, v8::GCCallbackFlags flags) |
| |
| inline void AddGCEpilogueCallback( |
| v8::GCEpilogueCallback callback |
| , v8::GCType gc_type_filter = v8::kGCTypeAll) { |
| v8::V8::AddGCEpilogueCallback(callback, gc_type_filter); |
| } |
| inline void RemoveGCEpilogueCallback( |
| v8::GCEpilogueCallback callback) { |
| v8::V8::RemoveGCEpilogueCallback(callback); |
| } |
| inline void AddGCPrologueCallback( |
| v8::GCPrologueCallback callback |
| , v8::GCType gc_type_filter = v8::kGCTypeAll) { |
| v8::V8::AddGCPrologueCallback(callback, gc_type_filter); |
| } |
| inline void RemoveGCPrologueCallback( |
| v8::GCPrologueCallback callback) { |
| v8::V8::RemoveGCPrologueCallback(callback); |
| } |
| inline void GetHeapStatistics( |
| v8::HeapStatistics *heap_statistics) { |
| v8::V8::GetHeapStatistics(heap_statistics); |
| } |
| |
| # define X(NAME) \ |
| inline v8::Local<v8::Value> NAME(const char *msg) { \ |
| EscapableHandleScope scope; \ |
| return scope.Escape(v8::Exception::NAME(New(msg).ToLocalChecked())); \ |
| } \ |
| \ |
| inline \ |
| v8::Local<v8::Value> NAME(v8::Local<v8::String> msg) { \ |
| return v8::Exception::NAME(msg); \ |
| } \ |
| \ |
| inline void Throw ## NAME(const char *msg) { \ |
| HandleScope scope; \ |
| v8::ThrowException(v8::Exception::NAME(New(msg).ToLocalChecked())); \ |
| } \ |
| \ |
| inline \ |
| void Throw ## NAME(v8::Local<v8::String> errmsg) { \ |
| HandleScope scope; \ |
| v8::ThrowException(v8::Exception::NAME(errmsg)); \ |
| } |
| |
| X(Error) |
| X(RangeError) |
| X(ReferenceError) |
| X(SyntaxError) |
| X(TypeError) |
| |
| # undef X |
| |
| inline void ThrowError(v8::Local<v8::Value> error) { |
| v8::ThrowException(error); |
| } |
| |
| inline MaybeLocal<v8::Object> NewBuffer( |
| char *data |
| , size_t length |
| , node::Buffer::free_callback callback |
| , void *hint |
| ) { |
| EscapableHandleScope scope; |
| // arbitrary buffer lengths requires |
| // NODE_MODULE_VERSION >= IOJS_3_0_MODULE_VERSION |
| assert(length <= imp::kMaxLength && "too large buffer"); |
| return scope.Escape( |
| New(node::Buffer::New(data, length, callback, hint)->handle_)); |
| } |
| |
| inline MaybeLocal<v8::Object> CopyBuffer( |
| const char *data |
| , uint32_t size |
| ) { |
| EscapableHandleScope scope; |
| // arbitrary buffer lengths requires |
| // NODE_MODULE_VERSION >= IOJS_3_0_MODULE_VERSION |
| assert(size <= imp::kMaxLength && "too large buffer"); |
| #if NODE_MODULE_VERSION >= NODE_0_10_MODULE_VERSION |
| return scope.Escape(New(node::Buffer::New(data, size)->handle_)); |
| #else |
| return scope.Escape( |
| New(node::Buffer::New(const_cast<char *>(data), size)->handle_)); |
| #endif |
| } |
| |
| inline MaybeLocal<v8::Object> NewBuffer(uint32_t size) { |
| // arbitrary buffer lengths requires |
| // NODE_MODULE_VERSION >= IOJS_3_0_MODULE_VERSION |
| EscapableHandleScope scope; |
| assert(size <= imp::kMaxLength && "too large buffer"); |
| return scope.Escape(New(node::Buffer::New(size)->handle_)); |
| } |
| |
| inline void FreeData(char *data, void *hint) { |
| (void) hint; // unused |
| delete[] data; |
| } |
| |
| inline MaybeLocal<v8::Object> NewBuffer( |
| char* data |
| , uint32_t size |
| ) { |
| EscapableHandleScope scope; |
| // arbitrary buffer lengths requires |
| // NODE_MODULE_VERSION >= IOJS_3_0_MODULE_VERSION |
| assert(size <= imp::kMaxLength && "too large buffer"); |
| return scope.Escape( |
| New(node::Buffer::New(data, size, FreeData, NULL)->handle_)); |
| } |
| |
| namespace imp { |
| inline void |
| widenString(std::vector<uint16_t> *ws, const uint8_t *s, int l) { |
| size_t len = static_cast<size_t>(l); |
| if (l < 0) { |
| len = strlen(reinterpret_cast<const char*>(s)); |
| } |
| assert(len <= INT_MAX && "string too long"); |
| ws->resize(len); |
| std::copy(s, s + len, ws->begin()); // NOLINT(build/include_what_you_use) |
| } |
| } // end of namespace imp |
| |
| inline MaybeLocal<v8::String> |
| NewOneByteString(const uint8_t * value, int length = -1) { |
| std::vector<uint16_t> wideString; // NOLINT(build/include_what_you_use) |
| imp::widenString(&wideString, value, length); |
| return v8::String::New(wideString.data(), |
| static_cast<int>(wideString.size())); |
| } |
| |
| inline MaybeLocal<BoundScript> CompileScript( |
| v8::Local<v8::String> s |
| , const v8::ScriptOrigin& origin |
| ) { |
| return v8::Script::Compile(s, const_cast<v8::ScriptOrigin *>(&origin)); |
| } |
| |
| inline MaybeLocal<BoundScript> CompileScript( |
| v8::Local<v8::String> s |
| ) { |
| return v8::Script::Compile(s); |
| } |
| |
| inline |
| MaybeLocal<v8::Value> RunScript(v8::Local<v8::Script> script) { |
| return script->Run(); |
| } |
| |
| inline v8::Local<v8::Value> MakeCallback( |
| v8::Local<v8::Object> target |
| , v8::Local<v8::Function> func |
| , int argc |
| , v8::Local<v8::Value>* argv) { |
| v8::HandleScope scope; |
| return scope.Close(New(node::MakeCallback(target, func, argc, argv))); |
| } |
| |
| inline v8::Local<v8::Value> MakeCallback( |
| v8::Local<v8::Object> target |
| , v8::Local<v8::String> symbol |
| , int argc |
| , v8::Local<v8::Value>* argv) { |
| v8::HandleScope scope; |
| return scope.Close(New(node::MakeCallback(target, symbol, argc, argv))); |
| } |
| |
| inline v8::Local<v8::Value> MakeCallback( |
| v8::Local<v8::Object> target |
| , const char* method |
| , int argc |
| , v8::Local<v8::Value>* argv) { |
| v8::HandleScope scope; |
| return scope.Close(New(node::MakeCallback(target, method, argc, argv))); |
| } |
| |
| inline void FatalException(const TryCatch& try_catch) { |
| node::FatalException(const_cast<v8::TryCatch &>(try_catch.try_catch_)); |
| } |
| |
| inline v8::Local<v8::Value> ErrnoException( |
| int errorno |
| , const char* syscall = NULL |
| , const char* message = NULL |
| , const char* path = NULL) { |
| return node::ErrnoException(errorno, syscall, message, path); |
| } |
| |
| NAN_DEPRECATED inline v8::Local<v8::Value> NanErrnoException( |
| int errorno |
| , const char* syscall = NULL |
| , const char* message = NULL |
| , const char* path = NULL) { |
| return ErrnoException(errorno, syscall, message, path); |
| } |
| |
| |
| template<typename T> |
| inline void SetIsolateData( |
| v8::Isolate *isolate |
| , T *data |
| ) { |
| isolate->SetData(data); |
| } |
| |
| template<typename T> |
| inline T *GetIsolateData( |
| v8::Isolate *isolate |
| ) { |
| return static_cast<T*>(isolate->GetData()); |
| } |
| |
| class Utf8String { |
| public: |
| inline explicit Utf8String(v8::Local<v8::Value> from) : |
| length_(0), str_(str_st_) { |
| v8::HandleScope scope; |
| if (!from.IsEmpty()) { |
| v8::Local<v8::String> string = from->ToString(); |
| if (!string.IsEmpty()) { |
| size_t len = 3 * string->Length() + 1; |
| assert(len <= INT_MAX); |
| if (len > sizeof (str_st_)) { |
| str_ = static_cast<char*>(malloc(len)); |
| assert(str_ != 0); |
| } |
| const int flags = |
| v8::String::NO_NULL_TERMINATION | imp::kReplaceInvalidUtf8; |
| length_ = string->WriteUtf8(str_, static_cast<int>(len), 0, flags); |
| str_[length_] = '\0'; |
| } |
| } |
| } |
| |
| inline int length() const { |
| return length_; |
| } |
| |
| inline char* operator*() { return str_; } |
| inline const char* operator*() const { return str_; } |
| |
| inline ~Utf8String() { |
| if (str_ != str_st_) { |
| free(str_); |
| } |
| } |
| |
| private: |
| NAN_DISALLOW_ASSIGN_COPY_MOVE(Utf8String) |
| |
| int length_; |
| char *str_; |
| char str_st_[1024]; |
| }; |
| |
| #endif // NODE_MODULE_VERSION |
| |
| typedef void (*FreeCallback)(char *data, void *hint); |
| |
| typedef const FunctionCallbackInfo<v8::Value>& NAN_METHOD_ARGS_TYPE; |
| typedef void NAN_METHOD_RETURN_TYPE; |
| |
| typedef const PropertyCallbackInfo<v8::Value>& NAN_GETTER_ARGS_TYPE; |
| typedef void NAN_GETTER_RETURN_TYPE; |
| |
| typedef const PropertyCallbackInfo<void>& NAN_SETTER_ARGS_TYPE; |
| typedef void NAN_SETTER_RETURN_TYPE; |
| |
| typedef const PropertyCallbackInfo<v8::Value>& |
| NAN_PROPERTY_GETTER_ARGS_TYPE; |
| typedef void NAN_PROPERTY_GETTER_RETURN_TYPE; |
| |
| typedef const PropertyCallbackInfo<v8::Value>& |
| NAN_PROPERTY_SETTER_ARGS_TYPE; |
| typedef void NAN_PROPERTY_SETTER_RETURN_TYPE; |
| |
| typedef const PropertyCallbackInfo<v8::Array>& |
| NAN_PROPERTY_ENUMERATOR_ARGS_TYPE; |
| typedef void NAN_PROPERTY_ENUMERATOR_RETURN_TYPE; |
| |
| typedef const PropertyCallbackInfo<v8::Boolean>& |
| NAN_PROPERTY_DELETER_ARGS_TYPE; |
| typedef void NAN_PROPERTY_DELETER_RETURN_TYPE; |
| |
| typedef const PropertyCallbackInfo<v8::Integer>& |
| NAN_PROPERTY_QUERY_ARGS_TYPE; |
| typedef void NAN_PROPERTY_QUERY_RETURN_TYPE; |
| |
| typedef const PropertyCallbackInfo<v8::Value>& NAN_INDEX_GETTER_ARGS_TYPE; |
| typedef void NAN_INDEX_GETTER_RETURN_TYPE; |
| |
| typedef const PropertyCallbackInfo<v8::Value>& NAN_INDEX_SETTER_ARGS_TYPE; |
| typedef void NAN_INDEX_SETTER_RETURN_TYPE; |
| |
| typedef const PropertyCallbackInfo<v8::Array>& |
| NAN_INDEX_ENUMERATOR_ARGS_TYPE; |
| typedef void NAN_INDEX_ENUMERATOR_RETURN_TYPE; |
| |
| typedef const PropertyCallbackInfo<v8::Boolean>& |
| NAN_INDEX_DELETER_ARGS_TYPE; |
| typedef void NAN_INDEX_DELETER_RETURN_TYPE; |
| |
| typedef const PropertyCallbackInfo<v8::Integer>& |
| NAN_INDEX_QUERY_ARGS_TYPE; |
| typedef void NAN_INDEX_QUERY_RETURN_TYPE; |
| |
| #define NAN_METHOD(name) \ |
| Nan::NAN_METHOD_RETURN_TYPE name(Nan::NAN_METHOD_ARGS_TYPE info) |
| #define NAN_GETTER(name) \ |
| Nan::NAN_GETTER_RETURN_TYPE name( \ |
| v8::Local<v8::String> property \ |
| , Nan::NAN_GETTER_ARGS_TYPE info) |
| #define NAN_SETTER(name) \ |
| Nan::NAN_SETTER_RETURN_TYPE name( \ |
| v8::Local<v8::String> property \ |
| , v8::Local<v8::Value> value \ |
| , Nan::NAN_SETTER_ARGS_TYPE info) |
| #define NAN_PROPERTY_GETTER(name) \ |
| Nan::NAN_PROPERTY_GETTER_RETURN_TYPE name( \ |
| v8::Local<v8::String> property \ |
| , Nan::NAN_PROPERTY_GETTER_ARGS_TYPE info) |
| #define NAN_PROPERTY_SETTER(name) \ |
| Nan::NAN_PROPERTY_SETTER_RETURN_TYPE name( \ |
| v8::Local<v8::String> property \ |
| , v8::Local<v8::Value> value \ |
| , Nan::NAN_PROPERTY_SETTER_ARGS_TYPE info) |
| #define NAN_PROPERTY_ENUMERATOR(name) \ |
| Nan::NAN_PROPERTY_ENUMERATOR_RETURN_TYPE name( \ |
| Nan::NAN_PROPERTY_ENUMERATOR_ARGS_TYPE info) |
| #define NAN_PROPERTY_DELETER(name) \ |
| Nan::NAN_PROPERTY_DELETER_RETURN_TYPE name( \ |
| v8::Local<v8::String> property \ |
| , Nan::NAN_PROPERTY_DELETER_ARGS_TYPE info) |
| #define NAN_PROPERTY_QUERY(name) \ |
| Nan::NAN_PROPERTY_QUERY_RETURN_TYPE name( \ |
| v8::Local<v8::String> property \ |
| , Nan::NAN_PROPERTY_QUERY_ARGS_TYPE info) |
| # define NAN_INDEX_GETTER(name) \ |
| Nan::NAN_INDEX_GETTER_RETURN_TYPE name( \ |
| uint32_t index \ |
| , Nan::NAN_INDEX_GETTER_ARGS_TYPE info) |
| #define NAN_INDEX_SETTER(name) \ |
| Nan::NAN_INDEX_SETTER_RETURN_TYPE name( \ |
| uint32_t index \ |
| , v8::Local<v8::Value> value \ |
| , Nan::NAN_INDEX_SETTER_ARGS_TYPE info) |
| #define NAN_INDEX_ENUMERATOR(name) \ |
| Nan::NAN_INDEX_ENUMERATOR_RETURN_TYPE \ |
| name(Nan::NAN_INDEX_ENUMERATOR_ARGS_TYPE info) |
| #define NAN_INDEX_DELETER(name) \ |
| Nan::NAN_INDEX_DELETER_RETURN_TYPE name( \ |
| uint32_t index \ |
| , Nan::NAN_INDEX_DELETER_ARGS_TYPE info) |
| #define NAN_INDEX_QUERY(name) \ |
| Nan::NAN_INDEX_QUERY_RETURN_TYPE name( \ |
| uint32_t index \ |
| , Nan::NAN_INDEX_QUERY_ARGS_TYPE info) |
| |
| class Callback { |
| public: |
| Callback() {} |
| |
| explicit Callback(const v8::Local<v8::Function> &fn) : handle_(fn) {} |
| |
| ~Callback() { |
| handle_.Reset(); |
| } |
| |
| bool operator==(const Callback &other) const { |
| return handle_ == other.handle_; |
| } |
| |
| bool operator!=(const Callback &other) const { |
| return !operator==(other); |
| } |
| |
| inline |
| v8::Local<v8::Function> operator*() const { return GetFunction(); } |
| |
| NAN_DEPRECATED inline v8::Local<v8::Value> operator()( |
| v8::Local<v8::Object> target |
| , int argc = 0 |
| , v8::Local<v8::Value> argv[] = 0) const { |
| #if NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION |
| v8::Isolate *isolate = v8::Isolate::GetCurrent(); |
| # if NODE_MODULE_VERSION >= NODE_9_0_MODULE_VERSION |
| AsyncResource async("nan:Callback:operator()"); |
| return Call_(isolate, target, argc, argv, &async) |
| .FromMaybe(v8::Local<v8::Value>()); |
| # else |
| return Call_(isolate, target, argc, argv); |
| # endif // NODE_MODULE_VERSION >= NODE_9_0_MODULE_VERSION |
| #else |
| return Call_(target, argc, argv); |
| #endif // NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION |
| } |
| |
| NAN_DEPRECATED inline v8::Local<v8::Value> operator()( |
| int argc = 0 |
| , v8::Local<v8::Value> argv[] = 0) const { |
| #if NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION |
| v8::Isolate *isolate = v8::Isolate::GetCurrent(); |
| v8::EscapableHandleScope scope(isolate); |
| # if NODE_MODULE_VERSION >= NODE_9_0_MODULE_VERSION |
| AsyncResource async("nan:Callback:operator()"); |
| return scope.Escape(Call_(isolate, isolate->GetCurrentContext()->Global(), |
| argc, argv, &async) |
| .FromMaybe(v8::Local<v8::Value>())); |
| # else |
| return scope.Escape( |
| Call_(isolate, isolate->GetCurrentContext()->Global(), argc, argv)); |
| # endif // NODE_MODULE_VERSION >= NODE_9_0_MODULE_VERSION |
| #else |
| v8::HandleScope scope; |
| return scope.Close(Call_(v8::Context::GetCurrent()->Global(), argc, argv)); |
| #endif // NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION |
| } |
| |
| inline MaybeLocal<v8::Value> operator()( |
| AsyncResource* resource |
| , int argc = 0 |
| , v8::Local<v8::Value> argv[] = 0) const { |
| return this->Call(argc, argv, resource); |
| } |
| |
| inline MaybeLocal<v8::Value> operator()( |
| AsyncResource* resource |
| , v8::Local<v8::Object> target |
| , int argc = 0 |
| , v8::Local<v8::Value> argv[] = 0) const { |
| return this->Call(target, argc, argv, resource); |
| } |
| |
| // TODO(kkoopa): remove |
| inline void SetFunction(const v8::Local<v8::Function> &fn) { |
| Reset(fn); |
| } |
| |
| inline void Reset(const v8::Local<v8::Function> &fn) { |
| handle_.Reset(fn); |
| } |
| |
| inline void Reset() { |
| handle_.Reset(); |
| } |
| |
| inline v8::Local<v8::Function> GetFunction() const { |
| return New(handle_); |
| } |
| |
| inline bool IsEmpty() const { |
| return handle_.IsEmpty(); |
| } |
| |
| // Deprecated: For async callbacks Use the versions that accept an |
| // AsyncResource. If this callback does not correspond to an async resource, |
| // that is, it is a synchronous function call on a non-empty JS stack, you |
| // should Nan::Call instead. |
| NAN_DEPRECATED inline v8::Local<v8::Value> |
| Call(v8::Local<v8::Object> target |
| , int argc |
| , v8::Local<v8::Value> argv[]) const { |
| #if NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION |
| v8::Isolate *isolate = v8::Isolate::GetCurrent(); |
| # if NODE_MODULE_VERSION >= NODE_9_0_MODULE_VERSION |
| AsyncResource async("nan:Callback:Call"); |
| return Call_(isolate, target, argc, argv, &async) |
| .FromMaybe(v8::Local<v8::Value>()); |
| # else |
| return Call_(isolate, target, argc, argv); |
| # endif // NODE_MODULE_VERSION >= NODE_9_0_MODULE_VERSION |
| #else |
| return Call_(target, argc, argv); |
| #endif |
| } |
| |
| // Deprecated: For async callbacks Use the versions that accept an |
| // AsyncResource. If this callback does not correspond to an async resource, |
| // that is, it is a synchronous function call on a non-empty JS stack, you |
| // should Nan::Call instead. |
| NAN_DEPRECATED inline v8::Local<v8::Value> |
| Call(int argc, v8::Local<v8::Value> argv[]) const { |
| #if NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION |
| v8::Isolate *isolate = v8::Isolate::GetCurrent(); |
| v8::EscapableHandleScope scope(isolate); |
| # if NODE_MODULE_VERSION >= NODE_9_0_MODULE_VERSION |
| AsyncResource async("nan:Callback:Call"); |
| return scope.Escape(Call_(isolate, isolate->GetCurrentContext()->Global(), |
| argc, argv, &async) |
| .FromMaybe(v8::Local<v8::Value>())); |
| # else |
| return scope.Escape( |
| Call_(isolate, isolate->GetCurrentContext()->Global(), argc, argv)); |
| # endif // NODE_MODULE_VERSION >= NODE_9_0_MODULE_VERSION |
| #else |
| v8::HandleScope scope; |
| return scope.Close(Call_(v8::Context::GetCurrent()->Global(), argc, argv)); |
| #endif |
| } |
| |
| inline MaybeLocal<v8::Value> |
| Call(v8::Local<v8::Object> target |
| , int argc |
| , v8::Local<v8::Value> argv[] |
| , AsyncResource* resource) const { |
| #if NODE_MODULE_VERSION >= NODE_9_0_MODULE_VERSION |
| v8::Isolate* isolate = v8::Isolate::GetCurrent(); |
| return Call_(isolate, target, argc, argv, resource); |
| #elif NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION |
| v8::Isolate *isolate = v8::Isolate::GetCurrent(); |
| return Call_(isolate, target, argc, argv); |
| #else |
| return Call_(target, argc, argv); |
| #endif |
| } |
| |
| inline MaybeLocal<v8::Value> |
| Call(int argc, v8::Local<v8::Value> argv[], AsyncResource* resource) const { |
| #if NODE_MODULE_VERSION >= NODE_9_0_MODULE_VERSION |
| v8::Isolate* isolate = v8::Isolate::GetCurrent(); |
| return Call(isolate->GetCurrentContext()->Global(), argc, argv, resource); |
| #elif NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION |
| v8::Isolate *isolate = v8::Isolate::GetCurrent(); |
| v8::EscapableHandleScope scope(isolate); |
| return scope.Escape( |
| Call_(isolate, isolate->GetCurrentContext()->Global(), argc, argv)); |
| #else |
| v8::HandleScope scope; |
| return scope.Close(Call_(v8::Context::GetCurrent()->Global(), argc, argv)); |
| #endif |
| } |
| |
| private: |
| NAN_DISALLOW_ASSIGN_COPY_MOVE(Callback) |
| Persistent<v8::Function> handle_; |
| |
| #if NODE_MODULE_VERSION >= NODE_9_0_MODULE_VERSION |
| MaybeLocal<v8::Value> Call_(v8::Isolate *isolate |
| , v8::Local<v8::Object> target |
| , int argc |
| , v8::Local<v8::Value> argv[] |
| , AsyncResource* resource) const { |
| EscapableHandleScope scope; |
| v8::Local<v8::Function> func = New(handle_); |
| auto maybe = resource->runInAsyncScope(target, func, argc, argv); |
| v8::Local<v8::Value> local; |
| if (!maybe.ToLocal(&local)) return MaybeLocal<v8::Value>(); |
| return scope.Escape(local); |
| } |
| #elif NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION |
| v8::Local<v8::Value> Call_(v8::Isolate *isolate |
| , v8::Local<v8::Object> target |
| , int argc |
| , v8::Local<v8::Value> argv[]) const { |
| EscapableHandleScope scope; |
| |
| v8::Local<v8::Function> callback = New(handle_); |
| # if NODE_MODULE_VERSION < IOJS_3_0_MODULE_VERSION |
| return scope.Escape(New(node::MakeCallback( |
| isolate |
| , target |
| , callback |
| , argc |
| , argv |
| ))); |
| # else |
| return scope.Escape(node::MakeCallback( |
| isolate |
| , target |
| , callback |
| , argc |
| , argv |
| )); |
| # endif |
| } |
| #else |
| v8::Local<v8::Value> Call_(v8::Local<v8::Object> target |
| , int argc |
| , v8::Local<v8::Value> argv[]) const { |
| EscapableHandleScope scope; |
| |
| v8::Local<v8::Function> callback = New(handle_); |
| return scope.Escape(New(node::MakeCallback( |
| target |
| , callback |
| , argc |
| , argv |
| ))); |
| } |
| #endif |
| }; |
| |
| inline MaybeLocal<v8::Value> Call( |
| const Nan::Callback& callback |
| , v8::Local<v8::Object> recv |
| , int argc |
| , v8::Local<v8::Value> argv[]) { |
| return Call(*callback, recv, argc, argv); |
| } |
| |
| inline MaybeLocal<v8::Value> Call( |
| const Nan::Callback& callback |
| , int argc |
| , v8::Local<v8::Value> argv[]) { |
| #if NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION |
| v8::Isolate* isolate = v8::Isolate::GetCurrent(); |
| v8::EscapableHandleScope scope(isolate); |
| return scope.Escape( |
| Call(*callback, isolate->GetCurrentContext()->Global(), argc, argv) |
| .FromMaybe(v8::Local<v8::Value>())); |
| #else |
| EscapableHandleScope scope; |
| return scope.Escape( |
| Call(*callback, v8::Context::GetCurrent()->Global(), argc, argv) |
| .FromMaybe(v8::Local<v8::Value>())); |
| #endif |
| } |
| |
| inline MaybeLocal<v8::Value> Call( |
| v8::Local<v8::String> symbol |
| , v8::Local<v8::Object> recv |
| , int argc |
| , v8::Local<v8::Value> argv[]) { |
| EscapableHandleScope scope; |
| v8::Local<v8::Value> fn_v = |
| Get(recv, symbol).FromMaybe(v8::Local<v8::Value>()); |
| if (fn_v.IsEmpty() || !fn_v->IsFunction()) return v8::Local<v8::Value>(); |
| v8::Local<v8::Function> fn = fn_v.As<v8::Function>(); |
| return scope.Escape( |
| Call(fn, recv, argc, argv).FromMaybe(v8::Local<v8::Value>())); |
| } |
| |
| inline MaybeLocal<v8::Value> Call( |
| const char* method |
| , v8::Local<v8::Object> recv |
| , int argc |
| , v8::Local<v8::Value> argv[]) { |
| EscapableHandleScope scope; |
| v8::Local<v8::String> method_string = |
| New<v8::String>(method).ToLocalChecked(); |
| return scope.Escape( |
| Call(method_string, recv, argc, argv).FromMaybe(v8::Local<v8::Value>())); |
| } |
| |
| /* abstract */ class AsyncWorker { |
| public: |
| explicit AsyncWorker(Callback *callback_, |
| const char* resource_name = "nan:AsyncWorker") |
| : callback(callback_), errmsg_(NULL) { |
| request.data = this; |
| |
| HandleScope scope; |
| v8::Local<v8::Object> obj = New<v8::Object>(); |
| persistentHandle.Reset(obj); |
| async_resource = new AsyncResource(resource_name, obj); |
| } |
| |
| virtual ~AsyncWorker() { |
| HandleScope scope; |
| |
| if (!persistentHandle.IsEmpty()) |
| persistentHandle.Reset(); |
| delete callback; |
| delete[] errmsg_; |
| delete async_resource; |
| } |
| |
| virtual void WorkComplete() { |
| HandleScope scope; |
| |
| if (errmsg_ == NULL) |
| HandleOKCallback(); |
| else |
| HandleErrorCallback(); |
| delete callback; |
| callback = NULL; |
| } |
| |
| inline void SaveToPersistent( |
| const char *key, const v8::Local<v8::Value> &value) { |
| HandleScope scope; |
| Set(New(persistentHandle), New(key).ToLocalChecked(), value).FromJust(); |
| } |
| |
| inline void SaveToPersistent( |
| const v8::Local<v8::String> &key, const v8::Local<v8::Value> &value) { |
| HandleScope scope; |
| Set(New(persistentHandle), key, value).FromJust(); |
| } |
| |
| inline void SaveToPersistent( |
| uint32_t index, const v8::Local<v8::Value> &value) { |
| HandleScope scope; |
| Set(New(persistentHandle), index, value).FromJust(); |
| } |
| |
| inline v8::Local<v8::Value> GetFromPersistent(const char *key) const { |
| EscapableHandleScope scope; |
| return scope.Escape( |
| Get(New(persistentHandle), New(key).ToLocalChecked()) |
| .FromMaybe(v8::Local<v8::Value>())); |
| } |
| |
| inline v8::Local<v8::Value> |
| GetFromPersistent(const v8::Local<v8::String> &key) const { |
| EscapableHandleScope scope; |
| return scope.Escape( |
| Get(New(persistentHandle), key) |
| .FromMaybe(v8::Local<v8::Value>())); |
| } |
| |
| inline v8::Local<v8::Value> GetFromPersistent(uint32_t index) const { |
| EscapableHandleScope scope; |
| return scope.Escape( |
| Get(New(persistentHandle), index) |
| .FromMaybe(v8::Local<v8::Value>())); |
| } |
| |
| virtual void Execute() = 0; |
| |
| uv_work_t request; |
| |
| virtual void Destroy() { |
| delete this; |
| } |
| |
| protected: |
| Persistent<v8::Object> persistentHandle; |
| Callback *callback; |
| AsyncResource *async_resource; |
| |
| virtual void HandleOKCallback() { |
| HandleScope scope; |
| |
| callback->Call(0, NULL, async_resource); |
| } |
| |
| virtual void HandleErrorCallback() { |
| HandleScope scope; |
| |
| v8::Local<v8::Value> argv[] = { |
| v8::Exception::Error(New<v8::String>(ErrorMessage()).ToLocalChecked()) |
| }; |
| callback->Call(1, argv, async_resource); |
| } |
| |
| void SetErrorMessage(const char *msg) { |
| delete[] errmsg_; |
| |
| size_t size = strlen(msg) + 1; |
| errmsg_ = new char[size]; |
| memcpy(errmsg_, msg, size); |
| } |
| |
| const char* ErrorMessage() const { |
| return errmsg_; |
| } |
| |
| private: |
| NAN_DISALLOW_ASSIGN_COPY_MOVE(AsyncWorker) |
| char *errmsg_; |
| }; |
| |
| /* abstract */ class AsyncBareProgressWorkerBase : public AsyncWorker { |
| public: |
| explicit AsyncBareProgressWorkerBase( |
| Callback *callback_, |
| const char* resource_name = "nan:AsyncBareProgressWorkerBase") |
| : AsyncWorker(callback_, resource_name) { |
| uv_async_init( |
| GetCurrentEventLoop() |
| , &async |
| , AsyncProgress_ |
| ); |
| async.data = this; |
| } |
| |
| virtual ~AsyncBareProgressWorkerBase() { |
| } |
| |
| virtual void WorkProgress() = 0; |
| |
| virtual void Destroy() { |
| uv_close(reinterpret_cast<uv_handle_t*>(&async), AsyncClose_); |
| } |
| |
| private: |
| inline static NAUV_WORK_CB(AsyncProgress_) { |
| AsyncBareProgressWorkerBase *worker = |
| static_cast<AsyncBareProgressWorkerBase*>(async->data); |
| worker->WorkProgress(); |
| } |
| |
| inline static void AsyncClose_(uv_handle_t* handle) { |
| AsyncBareProgressWorkerBase *worker = |
| static_cast<AsyncBareProgressWorkerBase*>(handle->data); |
| delete worker; |
| } |
| |
| protected: |
| uv_async_t async; |
| }; |
| |
| template<class T> |
| /* abstract */ |
| class AsyncBareProgressWorker : public AsyncBareProgressWorkerBase { |
| public: |
| explicit AsyncBareProgressWorker( |
| Callback *callback_, |
| const char* resource_name = "nan:AsyncBareProgressWorker") |
| : AsyncBareProgressWorkerBase(callback_, resource_name) { |
| uv_mutex_init(&async_lock); |
| } |
| |
| virtual ~AsyncBareProgressWorker() { |
| uv_mutex_destroy(&async_lock); |
| } |
| |
| class ExecutionProgress { |
| friend class AsyncBareProgressWorker; |
| public: |
| void Signal() const { |
| uv_mutex_lock(&that_->async_lock); |
| uv_async_send(&that_->async); |
| uv_mutex_unlock(&that_->async_lock); |
| } |
| |
| void Send(const T* data, size_t count) const { |
| that_->SendProgress_(data, count); |
| } |
| |
| private: |
| explicit ExecutionProgress(AsyncBareProgressWorker *that) : that_(that) {} |
| NAN_DISALLOW_ASSIGN_COPY_MOVE(ExecutionProgress) |
| AsyncBareProgressWorker* const that_; |
| }; |
| |
| virtual void Execute(const ExecutionProgress& progress) = 0; |
| virtual void HandleProgressCallback(const T *data, size_t size) = 0; |
| |
| protected: |
| uv_mutex_t async_lock; |
| |
| private: |
| void Execute() /*final override*/ { |
| ExecutionProgress progress(this); |
| Execute(progress); |
| } |
| |
| virtual void SendProgress_(const T *data, size_t count) = 0; |
| }; |
| |
| template<class T> |
| /* abstract */ |
| class AsyncProgressWorkerBase : public AsyncBareProgressWorker<T> { |
| public: |
| explicit AsyncProgressWorkerBase( |
| Callback *callback_, |
| const char* resource_name = "nan:AsyncProgressWorkerBase") |
| : AsyncBareProgressWorker<T>(callback_, resource_name), asyncdata_(NULL), |
| asyncsize_(0) { |
| } |
| |
| virtual ~AsyncProgressWorkerBase() { |
| delete[] asyncdata_; |
| } |
| |
| void WorkProgress() { |
| uv_mutex_lock(&this->async_lock); |
| T *data = asyncdata_; |
| size_t size = asyncsize_; |
| asyncdata_ = NULL; |
| asyncsize_ = 0; |
| uv_mutex_unlock(&this->async_lock); |
| |
| // Don't send progress events after we've already completed. |
| if (this->callback) { |
| this->HandleProgressCallback(data, size); |
| } |
| delete[] data; |
| } |
| |
| private: |
| void SendProgress_(const T *data, size_t count) { |
| T *new_data = new T[count]; |
| { |
| T *it = new_data; |
| std::copy(data, data + count, it); |
| } |
| |
| uv_mutex_lock(&this->async_lock); |
| T *old_data = asyncdata_; |
| asyncdata_ = new_data; |
| asyncsize_ = count; |
| uv_async_send(&this->async); |
| uv_mutex_unlock(&this->async_lock); |
| |
| delete[] old_data; |
| } |
| |
| T *asyncdata_; |
| size_t asyncsize_; |
| }; |
| |
| // This ensures compatibility to the previous un-templated AsyncProgressWorker |
| // class definition. |
| typedef AsyncProgressWorkerBase<char> AsyncProgressWorker; |
| |
| template<class T> |
| /* abstract */ |
| class AsyncBareProgressQueueWorker : public AsyncBareProgressWorkerBase { |
| public: |
| explicit AsyncBareProgressQueueWorker( |
| Callback *callback_, |
| const char* resource_name = "nan:AsyncBareProgressQueueWorker") |
| : AsyncBareProgressWorkerBase(callback_, resource_name) { |
| } |
| |
| virtual ~AsyncBareProgressQueueWorker() { |
| } |
| |
| class ExecutionProgress { |
| friend class AsyncBareProgressQueueWorker; |
| public: |
| void Send(const T* data, size_t count) const { |
| that_->SendProgress_(data, count); |
| } |
| |
| private: |
| explicit ExecutionProgress(AsyncBareProgressQueueWorker *that) |
| : that_(that) {} |
| NAN_DISALLOW_ASSIGN_COPY_MOVE(ExecutionProgress) |
| AsyncBareProgressQueueWorker* const that_; |
| }; |
| |
| virtual void Execute(const ExecutionProgress& progress) = 0; |
| virtual void HandleProgressCallback(const T *data, size_t size) = 0; |
| |
| private: |
| void Execute() /*final override*/ { |
| ExecutionProgress progress(this); |
| Execute(progress); |
| } |
| |
| virtual void SendProgress_(const T *data, size_t count) = 0; |
| }; |
| |
| template<class T> |
| /* abstract */ |
| class AsyncProgressQueueWorker : public AsyncBareProgressQueueWorker<T> { |
| public: |
| explicit AsyncProgressQueueWorker( |
| Callback *callback_, |
| const char* resource_name = "nan:AsyncProgressQueueWorker") |
| : AsyncBareProgressQueueWorker<T>(callback_) { |
| uv_mutex_init(&async_lock); |
| } |
| |
| virtual ~AsyncProgressQueueWorker() { |
| uv_mutex_lock(&async_lock); |
| |
| while (!asyncdata_.empty()) { |
| std::pair<T*, size_t> &datapair = asyncdata_.front(); |
| T *data = datapair.first; |
| |
| asyncdata_.pop(); |
| |
| delete[] data; |
| } |
| |
| uv_mutex_unlock(&async_lock); |
| uv_mutex_destroy(&async_lock); |
| } |
| |
| void WorkComplete() { |
| WorkProgress(); |
| AsyncWorker::WorkComplete(); |
| } |
| |
| void WorkProgress() { |
| uv_mutex_lock(&async_lock); |
| |
| while (!asyncdata_.empty()) { |
| std::pair<T*, size_t> &datapair = asyncdata_.front(); |
| |
| T *data = datapair.first; |
| size_t size = datapair.second; |
| |
| asyncdata_.pop(); |
| uv_mutex_unlock(&async_lock); |
| |
| // Don't send progress events after we've already completed. |
| if (this->callback) { |
| this->HandleProgressCallback(data, size); |
| } |
| |
| delete[] data; |
| |
| uv_mutex_lock(&async_lock); |
| } |
| |
| uv_mutex_unlock(&async_lock); |
| } |
| |
| private: |
| void SendProgress_(const T *data, size_t count) { |
| T *new_data = new T[count]; |
| { |
| T *it = new_data; |
| std::copy(data, data + count, it); |
| } |
| |
| uv_mutex_lock(&async_lock); |
| asyncdata_.push(std::pair<T*, size_t>(new_data, count)); |
| uv_mutex_unlock(&async_lock); |
| |
| uv_async_send(&this->async); |
| } |
| |
| uv_mutex_t async_lock; |
| std::queue<std::pair<T*, size_t> > asyncdata_; |
| }; |
| |
| inline void AsyncExecute (uv_work_t* req) { |
| AsyncWorker *worker = static_cast<AsyncWorker*>(req->data); |
| worker->Execute(); |
| } |
| |
| inline void AsyncExecuteComplete (uv_work_t* req) { |
| AsyncWorker* worker = static_cast<AsyncWorker*>(req->data); |
| worker->WorkComplete(); |
| worker->Destroy(); |
| } |
| |
| inline void AsyncQueueWorker (AsyncWorker* worker) { |
| uv_queue_work( |
| GetCurrentEventLoop() |
| , &worker->request |
| , AsyncExecute |
| , reinterpret_cast<uv_after_work_cb>(AsyncExecuteComplete) |
| ); |
| } |
| |
| namespace imp { |
| |
| inline |
| ExternalOneByteStringResource const* |
| GetExternalResource(v8::Local<v8::String> str) { |
| #if NODE_MODULE_VERSION < ATOM_0_21_MODULE_VERSION |
| return str->GetExternalAsciiStringResource(); |
| #else |
| return str->GetExternalOneByteStringResource(); |
| #endif |
| } |
| |
| inline |
| bool |
| IsExternal(v8::Local<v8::String> str) { |
| #if NODE_MODULE_VERSION < ATOM_0_21_MODULE_VERSION |
| return str->IsExternalAscii(); |
| #else |
| return str->IsExternalOneByte(); |
| #endif |
| } |
| |
| } // end of namespace imp |
| |
| enum Encoding {ASCII, UTF8, BASE64, UCS2, BINARY, HEX, BUFFER}; |
| |
| #if NODE_MODULE_VERSION < NODE_0_10_MODULE_VERSION |
| # include "nan_string_bytes.h" // NOLINT(build/include) |
| #endif |
| |
| inline v8::Local<v8::Value> Encode( |
| const void *buf, size_t len, enum Encoding encoding = BINARY) { |
| #if (NODE_MODULE_VERSION >= ATOM_0_21_MODULE_VERSION) |
| v8::Isolate* isolate = v8::Isolate::GetCurrent(); |
| node::encoding node_enc = static_cast<node::encoding>(encoding); |
| |
| if (encoding == UCS2) { |
| return node::Encode( |
| isolate |
| , reinterpret_cast<const uint16_t *>(buf) |
| , len / 2); |
| } else { |
| return node::Encode( |
| isolate |
| , reinterpret_cast<const char *>(buf) |
| , len |
| , node_enc); |
| } |
| #elif (NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION) |
| return node::Encode( |
| v8::Isolate::GetCurrent() |
| , buf, len |
| , static_cast<node::encoding>(encoding)); |
| #else |
| # if NODE_MODULE_VERSION >= NODE_0_10_MODULE_VERSION |
| return node::Encode(buf, len, static_cast<node::encoding>(encoding)); |
| # else |
| return imp::Encode(reinterpret_cast<const char*>(buf), len, encoding); |
| # endif |
| #endif |
| } |
| |
| inline ssize_t DecodeBytes( |
| v8::Local<v8::Value> val, enum Encoding encoding = BINARY) { |
| #if (NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION) |
| return node::DecodeBytes( |
| v8::Isolate::GetCurrent() |
| , val |
| , static_cast<node::encoding>(encoding)); |
| #else |
| # if (NODE_MODULE_VERSION < NODE_0_10_MODULE_VERSION) |
| if (encoding == BUFFER) { |
| return node::DecodeBytes(val, node::BINARY); |
| } |
| # endif |
| return node::DecodeBytes(val, static_cast<node::encoding>(encoding)); |
| #endif |
| } |
| |
| inline ssize_t DecodeWrite( |
| char *buf |
| , size_t len |
| , v8::Local<v8::Value> val |
| , enum Encoding encoding = BINARY) { |
| #if (NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION) |
| return node::DecodeWrite( |
| v8::Isolate::GetCurrent() |
| , buf |
| , len |
| , val |
| , static_cast<node::encoding>(encoding)); |
| #else |
| # if (NODE_MODULE_VERSION < NODE_0_10_MODULE_VERSION) |
| if (encoding == BUFFER) { |
| return node::DecodeWrite(buf, len, val, node::BINARY); |
| } |
| # endif |
| return node::DecodeWrite( |
| buf |
| , len |
| , val |
| , static_cast<node::encoding>(encoding)); |
| #endif |
| } |
| |
| inline void SetPrototypeTemplate( |
| v8::Local<v8::FunctionTemplate> templ |
| , const char *name |
| , v8::Local<v8::Data> value |
| ) { |
| HandleScope scope; |
| SetTemplate(templ->PrototypeTemplate(), name, value); |
| } |
| |
| inline void SetPrototypeTemplate( |
| v8::Local<v8::FunctionTemplate> templ |
| , v8::Local<v8::String> name |
| , v8::Local<v8::Data> value |
| , v8::PropertyAttribute attributes |
| ) { |
| HandleScope scope; |
| SetTemplate(templ->PrototypeTemplate(), name, value, attributes); |
| } |
| |
| inline void SetInstanceTemplate( |
| v8::Local<v8::FunctionTemplate> templ |
| , const char *name |
| , v8::Local<v8::Data> value |
| ) { |
| HandleScope scope; |
| SetTemplate(templ->InstanceTemplate(), name, value); |
| } |
| |
| inline void SetInstanceTemplate( |
| v8::Local<v8::FunctionTemplate> templ |
| , v8::Local<v8::String> name |
| , v8::Local<v8::Data> value |
| , v8::PropertyAttribute attributes |
| ) { |
| HandleScope scope; |
| SetTemplate(templ->InstanceTemplate(), name, value, attributes); |
| } |
| |
| namespace imp { |
| |
| // Note(@agnat): Helper to distinguish different receiver types. The first |
| // version deals with receivers derived from v8::Template. The second version |
| // handles everything else. The final argument only serves as discriminator and |
| // is unused. |
| template <typename T> |
| inline |
| void |
| SetMethodAux(T recv, |
| v8::Local<v8::String> name, |
| v8::Local<v8::FunctionTemplate> tpl, |
| v8::Template *) { |
| recv->Set(name, tpl); |
| } |
| |
| template <typename T> |
| inline |
| void |
| SetMethodAux(T recv, |
| v8::Local<v8::String> name, |
| v8::Local<v8::FunctionTemplate> tpl, |
| ...) { |
| Set(recv, name, GetFunction(tpl).ToLocalChecked()); |
| } |
| |
| } // end of namespace imp |
| |
| template <typename T, template <typename> class HandleType> |
| inline void SetMethod( |
| HandleType<T> recv |
| , const char *name |
| , FunctionCallback callback) { |
| HandleScope scope; |
| v8::Local<v8::FunctionTemplate> t = New<v8::FunctionTemplate>(callback); |
| v8::Local<v8::String> fn_name = New(name).ToLocalChecked(); |
| t->SetClassName(fn_name); |
| // Note(@agnat): Pass an empty T* as discriminator. See note on |
| // SetMethodAux(...) above |
| imp::SetMethodAux(recv, fn_name, t, static_cast<T*>(0)); |
| } |
| |
| inline void SetPrototypeMethod( |
| v8::Local<v8::FunctionTemplate> recv |
| , const char* name, FunctionCallback callback) { |
| HandleScope scope; |
| v8::Local<v8::FunctionTemplate> t = New<v8::FunctionTemplate>( |
| callback |
| , v8::Local<v8::Value>() |
| , New<v8::Signature>(recv)); |
| v8::Local<v8::String> fn_name = New(name).ToLocalChecked(); |
| recv->PrototypeTemplate()->Set(fn_name, t); |
| t->SetClassName(fn_name); |
| } |
| |
| //=== Accessors and Such ======================================================= |
| |
| inline void SetAccessor( |
| v8::Local<v8::ObjectTemplate> tpl |
| , v8::Local<v8::String> name |
| , GetterCallback getter |
| , SetterCallback setter = 0 |
| , v8::Local<v8::Value> data = v8::Local<v8::Value>() |
| , v8::AccessControl settings = v8::DEFAULT |
| , v8::PropertyAttribute attribute = v8::None |
| , imp::Sig signature = imp::Sig()) { |
| HandleScope scope; |
| |
| imp::NativeGetter getter_ = |
| imp::GetterCallbackWrapper; |
| imp::NativeSetter setter_ = |
| setter ? imp::SetterCallbackWrapper : 0; |
| |
| v8::Local<v8::ObjectTemplate> otpl = New<v8::ObjectTemplate>(); |
| otpl->SetInternalFieldCount(imp::kAccessorFieldCount); |
| v8::Local<v8::Object> obj = NewInstance(otpl).ToLocalChecked(); |
| |
| obj->SetInternalField( |
| imp::kGetterIndex |
| , New<v8::External>(reinterpret_cast<void *>(getter))); |
| |
| if (setter != 0) { |
| obj->SetInternalField( |
| imp::kSetterIndex |
| , New<v8::External>(reinterpret_cast<void *>(setter))); |
| } |
| |
| if (!data.IsEmpty()) { |
| obj->SetInternalField(imp::kDataIndex, data); |
| } |
| |
| tpl->SetAccessor( |
| name |
| , getter_ |
| , setter_ |
| , obj |
| , settings |
| , attribute |
| , signature); |
| } |
| |
| inline bool SetAccessor( |
| v8::Local<v8::Object> obj |
| , v8::Local<v8::String> name |
| , GetterCallback getter |
| , SetterCallback setter = 0 |
| , v8::Local<v8::Value> data = v8::Local<v8::Value>() |
| , v8::AccessControl settings = v8::DEFAULT |
| , v8::PropertyAttribute attribute = v8::None) { |
| HandleScope scope; |
| |
| imp::NativeGetter getter_ = |
| imp::GetterCallbackWrapper; |
| imp::NativeSetter setter_ = |
| setter ? imp::SetterCallbackWrapper : 0; |
| |
| v8::Local<v8::ObjectTemplate> otpl = New<v8::ObjectTemplate>(); |
| otpl->SetInternalFieldCount(imp::kAccessorFieldCount); |
| v8::Local<v8::Object> dataobj = NewInstance(otpl).ToLocalChecked(); |
| |
| dataobj->SetInternalField( |
| imp::kGetterIndex |
| , New<v8::External>(reinterpret_cast<void *>(getter))); |
| |
| if (!data.IsEmpty()) { |
| dataobj->SetInternalField(imp::kDataIndex, data); |
| } |
| |
| if (setter) { |
| dataobj->SetInternalField( |
| imp::kSetterIndex |
| , New<v8::External>(reinterpret_cast<void *>(setter))); |
| } |
| |
| #if (NODE_MODULE_VERSION >= NODE_6_0_MODULE_VERSION) |
| return obj->SetAccessor( |
| GetCurrentContext() |
| , name |
| , getter_ |
| , setter_ |
| , dataobj |
| , settings |
| , attribute).FromMaybe(false); |
| #else |
| return obj->SetAccessor( |
| name |
| , getter_ |
| , setter_ |
| , dataobj |
| , settings |
| , attribute); |
| #endif |
| } |
| |
| inline void SetNamedPropertyHandler( |
| v8::Local<v8::ObjectTemplate> tpl |
| , PropertyGetterCallback getter |
| , PropertySetterCallback setter = 0 |
| , PropertyQueryCallback query = 0 |
| , PropertyDeleterCallback deleter = 0 |
| , PropertyEnumeratorCallback enumerator = 0 |
| , v8::Local<v8::Value> data = v8::Local<v8::Value>()) { |
| HandleScope scope; |
| |
| imp::NativePropertyGetter getter_ = |
| imp::PropertyGetterCallbackWrapper; |
| imp::NativePropertySetter setter_ = |
| setter ? imp::PropertySetterCallbackWrapper : 0; |
| imp::NativePropertyQuery query_ = |
| query ? imp::PropertyQueryCallbackWrapper : 0; |
| imp::NativePropertyDeleter *deleter_ = |
| deleter ? imp::PropertyDeleterCallbackWrapper : 0; |
| imp::NativePropertyEnumerator enumerator_ = |
| enumerator ? imp::PropertyEnumeratorCallbackWrapper : 0; |
| |
| v8::Local<v8::ObjectTemplate> otpl = New<v8::ObjectTemplate>(); |
| otpl->SetInternalFieldCount(imp::kPropertyFieldCount); |
| v8::Local<v8::Object> obj = NewInstance(otpl).ToLocalChecked(); |
| obj->SetInternalField( |
| imp::kPropertyGetterIndex |
| , New<v8::External>(reinterpret_cast<void *>(getter))); |
| |
| if (setter) { |
| obj->SetInternalField( |
| imp::kPropertySetterIndex |
| , New<v8::External>(reinterpret_cast<void *>(setter))); |
| } |
| |
| if (query) { |
| obj->SetInternalField( |
| imp::kPropertyQueryIndex |
| , New<v8::External>(reinterpret_cast<void *>(query))); |
| } |
| |
| if (deleter) { |
| obj->SetInternalField( |
| imp::kPropertyDeleterIndex |
| , New<v8::External>(reinterpret_cast<void *>(deleter))); |
| } |
| |
| if (enumerator) { |
| obj->SetInternalField( |
| imp::kPropertyEnumeratorIndex |
| , New<v8::External>(reinterpret_cast<void *>(enumerator))); |
| } |
| |
| if (!data.IsEmpty()) { |
| obj->SetInternalField(imp::kDataIndex, data); |
| } |
| |
| #if NODE_MODULE_VERSION > NODE_0_12_MODULE_VERSION |
| tpl->SetHandler(v8::NamedPropertyHandlerConfiguration( |
| getter_, setter_, query_, deleter_, enumerator_, obj)); |
| #else |
| tpl->SetNamedPropertyHandler( |
| getter_ |
| , setter_ |
| , query_ |
| , deleter_ |
| , enumerator_ |
| , obj); |
| #endif |
| } |
| |
| inline void SetIndexedPropertyHandler( |
| v8::Local<v8::ObjectTemplate> tpl |
| , IndexGetterCallback getter |
| , IndexSetterCallback setter = 0 |
| , IndexQueryCallback query = 0 |
| , IndexDeleterCallback deleter = 0 |
| , IndexEnumeratorCallback enumerator = 0 |
| , v8::Local<v8::Value> data = v8::Local<v8::Value>()) { |
| HandleScope scope; |
| |
| imp::NativeIndexGetter getter_ = |
| imp::IndexGetterCallbackWrapper; |
| imp::NativeIndexSetter setter_ = |
| setter ? imp::IndexSetterCallbackWrapper : 0; |
| imp::NativeIndexQuery query_ = |
| query ? imp::IndexQueryCallbackWrapper : 0; |
| imp::NativeIndexDeleter deleter_ = |
| deleter ? imp::IndexDeleterCallbackWrapper : 0; |
| imp::NativeIndexEnumerator enumerator_ = |
| enumerator ? imp::IndexEnumeratorCallbackWrapper : 0; |
| |
| v8::Local<v8::ObjectTemplate> otpl = New<v8::ObjectTemplate>(); |
| otpl->SetInternalFieldCount(imp::kIndexPropertyFieldCount); |
| v8::Local<v8::Object> obj = NewInstance(otpl).ToLocalChecked(); |
| obj->SetInternalField( |
| imp::kIndexPropertyGetterIndex |
| , New<v8::External>(reinterpret_cast<void *>(getter))); |
| |
| if (setter) { |
| obj->SetInternalField( |
| imp::kIndexPropertySetterIndex |
| , New<v8::External>(reinterpret_cast<void *>(setter))); |
| } |
| |
| if (query) { |
| obj->SetInternalField( |
| imp::kIndexPropertyQueryIndex |
| , New<v8::External>(reinterpret_cast<void *>(query))); |
| } |
| |
| if (deleter) { |
| obj->SetInternalField( |
| imp::kIndexPropertyDeleterIndex |
| , New<v8::External>(reinterpret_cast<void *>(deleter))); |
| } |
| |
| if (enumerator) { |
| obj->SetInternalField( |
| imp::kIndexPropertyEnumeratorIndex |
| , New<v8::External>(reinterpret_cast<void *>(enumerator))); |
| } |
| |
| if (!data.IsEmpty()) { |
| obj->SetInternalField(imp::kDataIndex, data); |
| } |
| |
| #if NODE_MODULE_VERSION > NODE_0_12_MODULE_VERSION |
| tpl->SetHandler(v8::IndexedPropertyHandlerConfiguration( |
| getter_, setter_, query_, deleter_, enumerator_, obj)); |
| #else |
| tpl->SetIndexedPropertyHandler( |
| getter_ |
| , setter_ |
| , query_ |
| , deleter_ |
| , enumerator_ |
| , obj); |
| #endif |
| } |
| |
| inline void SetCallHandler( |
| v8::Local<v8::FunctionTemplate> tpl |
| , FunctionCallback callback |
| , v8::Local<v8::Value> data = v8::Local<v8::Value>()) { |
| HandleScope scope; |
| |
| v8::Local<v8::ObjectTemplate> otpl = New<v8::ObjectTemplate>(); |
| otpl->SetInternalFieldCount(imp::kFunctionFieldCount); |
| v8::Local<v8::Object> obj = NewInstance(otpl).ToLocalChecked(); |
| |
| obj->SetInternalField( |
| imp::kFunctionIndex |
| , New<v8::External>(reinterpret_cast<void *>(callback))); |
| |
| if (!data.IsEmpty()) { |
| obj->SetInternalField(imp::kDataIndex, data); |
| } |
| |
| tpl->SetCallHandler(imp::FunctionCallbackWrapper, obj); |
| } |
| |
| |
| inline void SetCallAsFunctionHandler( |
| v8::Local<v8::ObjectTemplate> tpl, |
| FunctionCallback callback, |
| v8::Local<v8::Value> data = v8::Local<v8::Value>()) { |
| HandleScope scope; |
| |
| v8::Local<v8::ObjectTemplate> otpl = New<v8::ObjectTemplate>(); |
| otpl->SetInternalFieldCount(imp::kFunctionFieldCount); |
| v8::Local<v8::Object> obj = NewInstance(otpl).ToLocalChecked(); |
| |
| obj->SetInternalField( |
| imp::kFunctionIndex |
| , New<v8::External>(reinterpret_cast<void *>(callback))); |
| |
| if (!data.IsEmpty()) { |
| obj->SetInternalField(imp::kDataIndex, data); |
| } |
| |
| tpl->SetCallAsFunctionHandler(imp::FunctionCallbackWrapper, obj); |
| } |
| |
| //=== Weak Persistent Handling ================================================= |
| |
| #include "nan_weak.h" // NOLINT(build/include) |
| |
| //=== ObjectWrap =============================================================== |
| |
| #include "nan_object_wrap.h" // NOLINT(build/include) |
| |
| //=== HiddenValue/Private ====================================================== |
| |
| #include "nan_private.h" // NOLINT(build/include) |
| |
| //=== Export ================================================================== |
| |
| inline |
| void |
| Export(ADDON_REGISTER_FUNCTION_ARGS_TYPE target, const char *name, |
| FunctionCallback f) { |
| HandleScope scope; |
| |
| Set(target, New<v8::String>(name).ToLocalChecked(), |
| GetFunction(New<v8::FunctionTemplate>(f)).ToLocalChecked()); |
| } |
| |
| //=== Tap Reverse Binding ===================================================== |
| |
| struct Tap { |
| explicit Tap(v8::Local<v8::Value> t) : t_() { |
| HandleScope scope; |
| |
| t_.Reset(To<v8::Object>(t).ToLocalChecked()); |
| } |
| |
| ~Tap() { t_.Reset(); } // not sure if neccessary |
| |
| inline void plan(int i) { |
| HandleScope scope; |
| v8::Local<v8::Value> arg = New(i); |
| Call("plan", New(t_), 1, &arg); |
| } |
| |
| inline void ok(bool isOk, const char *msg = NULL) { |
| HandleScope scope; |
| v8::Local<v8::Value> args[2]; |
| args[0] = New(isOk); |
| if (msg) args[1] = New(msg).ToLocalChecked(); |
| Call("ok", New(t_), msg ? 2 : 1, args); |
| } |
| |
| inline void pass(const char * msg = NULL) { |
| HandleScope scope; |
| v8::Local<v8::Value> hmsg; |
| if (msg) hmsg = New(msg).ToLocalChecked(); |
| Call("pass", New(t_), msg ? 1 : 0, &hmsg); |
| } |
| |
| inline void end() { |
| HandleScope scope; |
| Call("end", New(t_), 0, NULL); |
| } |
| |
| private: |
| Persistent<v8::Object> t_; |
| }; |
| |
| #define NAN_STRINGIZE2(x) #x |
| #define NAN_STRINGIZE(x) NAN_STRINGIZE2(x) |
| #define NAN_TEST_EXPRESSION(expression) \ |
| ( expression ), __FILE__ ":" NAN_STRINGIZE(__LINE__) ": " #expression |
| |
| #define NAN_EXPORT(target, function) Export(target, #function, function) |
| |
| #undef TYPE_CHECK |
| |
| //=== Generic Maybefication =================================================== |
| |
| namespace imp { |
| |
| template <typename T> struct Maybefier; |
| |
| template <typename T> struct Maybefier<v8::Local<T> > { |
| inline static MaybeLocal<T> convert(v8::Local<T> v) { |
| return v; |
| } |
| }; |
| |
| template <typename T> struct Maybefier<MaybeLocal<T> > { |
| inline static MaybeLocal<T> convert(MaybeLocal<T> v) { |
| return v; |
| } |
| }; |
| |
| } // end of namespace imp |
| |
| template <typename T, template <typename> class MaybeMaybe> |
| inline MaybeLocal<T> |
| MakeMaybe(MaybeMaybe<T> v) { |
| return imp::Maybefier<MaybeMaybe<T> >::convert(v); |
| } |
| |
| //=== TypedArrayContents ======================================================= |
| |
| #include "nan_typedarray_contents.h" // NOLINT(build/include) |
| |
| //=== JSON ===================================================================== |
| |
| #include "nan_json.h" // NOLINT(build/include) |
| |
| } // end of namespace Nan |
| |
| #endif // NAN_H_ |