2893 lines
86 KiB
C++
2893 lines
86 KiB
C++
/*********************************************************************
|
|
* 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_
|