Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
2169 lines (1849 sloc) 65.171 kB
/*********************************************************************
* NAN - Native Abstractions for Node.js
*
* Copyright (c) 2015 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>
*
* MIT License <https://github.com/nodejs/nan/blob/master/LICENSE.md>
*
* Version 2.0.0: current Node 12: 0.12.7, Node 10: 0.10.40, io.js: 3.0.0
*
* See https://github.com/nodejs/nan for the latest update to this file
**********************************************************************************/
#ifndef NAN_H_
#define NAN_H_
#include <uv.h>
#include <node.h>
#include <node_buffer.h>
#include <node_version.h>
#include <node_object_wrap.h>
#include <algorithm>
#include <cstring>
#include <climits>
#include <cstdlib>
#if defined(_MSC_VER)
# pragma warning( push )
# pragma warning( disable : 4530 )
# include <map>
# include <string>
# include <vector>
# pragma warning( pop )
#else
# include <map>
# 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 {
#if defined(__GNUC__) && !(defined(DEBUG) && DEBUG)
# define NAN_INLINE inline __attribute__((always_inline))
#elif defined(_MSC_VER) && !(defined(DEBUG) && DEBUG)
# define NAN_INLINE __forceinline
#else
# define NAN_INLINE inline
#endif
#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 __cplusplus >= 201103L
# 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 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 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)
//=== 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
#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;
} // 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);
};
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);
};
//=== 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
NAN_INLINE bool HasCaught() const { return try_catch_.HasCaught(); }
NAN_INLINE bool CanContinue() const { return try_catch_.CanContinue(); }
NAN_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
}
NAN_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))
NAN_INLINE v8::MaybeLocal<v8::Value> StackTrace() const {
return try_catch_.StackTrace(GetCurrentContext());
}
#else
NAN_INLINE MaybeLocal<v8::Value> StackTrace() const {
return MaybeLocal<v8::Value>(try_catch_.StackTrace());
}
#endif
NAN_INLINE v8::Local<v8::Message> Message() const {
return try_catch_.Message();
}
NAN_INLINE void Reset() { try_catch_.Reset(); }
NAN_INLINE void SetVerbose(bool value) { try_catch_.SetVerbose(value); }
NAN_INLINE void SetCaptureMessage(bool value) {
try_catch_.SetCaptureMessage(value);
}
};
//============ =================================================================
/* node 0.12 */
#if NODE_MODULE_VERSION >= NODE_0_12_MODULE_VERSION
NAN_INLINE
void SetCounterFunction(v8::CounterLookupCallback cb) {
v8::Isolate::GetCurrent()->SetCounterFunction(cb);
}
NAN_INLINE
void SetCreateHistogramFunction(v8::CreateHistogramCallback cb) {
v8::Isolate::GetCurrent()->SetCreateHistogramFunction(cb);
}
NAN_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))
NAN_INLINE bool IdleNotification(int idle_time_in_ms) {
return v8::Isolate::GetCurrent()->IdleNotificationDeadline(
idle_time_in_ms * 0.001);
}
# else
NAN_INLINE bool IdleNotification(int idle_time_in_ms) {
return v8::Isolate::GetCurrent()->IdleNotification(idle_time_in_ms);
}
#endif
NAN_INLINE void LowMemoryNotification() {
v8::Isolate::GetCurrent()->LowMemoryNotification();
}
NAN_INLINE void ContextDisposedNotification() {
v8::Isolate::GetCurrent()->ContextDisposedNotification();
}
#else
NAN_INLINE
void SetCounterFunction(v8::CounterLookupCallback cb) {
v8::V8::SetCounterFunction(cb);
}
NAN_INLINE
void SetCreateHistogramFunction(v8::CreateHistogramCallback cb) {
v8::V8::SetCreateHistogramFunction(cb);
}
NAN_INLINE
void SetAddHistogramSampleFunction(v8::AddHistogramSampleCallback cb) {
v8::V8::SetAddHistogramSampleFunction(cb);
}
NAN_INLINE bool IdleNotification(int idle_time_in_ms) {
return v8::V8::IdleNotification(idle_time_in_ms);
}
NAN_INLINE void LowMemoryNotification() {
v8::V8::LowMemoryNotification();
}
NAN_INLINE void ContextDisposedNotification() {
v8::V8::ContextDisposedNotification();
}
#endif
#if (NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION) // Node 0.12
NAN_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
}
NAN_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
}
NAN_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
}
NAN_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
}
NAN_INLINE v8::Local<v8::String> EmptyString() {
return v8::String::Empty(v8::Isolate::GetCurrent());
}
NAN_INLINE int AdjustExternalMemory(int bc) {
return static_cast<int>(
v8::Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(bc));
}
NAN_INLINE void SetTemplate(
v8::Local<v8::Template> templ
, const char *name
, v8::Local<v8::Data> value) {
templ->Set(v8::Isolate::GetCurrent(), name, value);
}
NAN_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);
}
NAN_INLINE v8::Local<v8::Context> GetCurrentContext() {
return v8::Isolate::GetCurrent()->GetCurrentContext();
}
NAN_INLINE void* GetInternalFieldPointer(
v8::Local<v8::Object> object
, int index) {
return object->GetAlignedPointerFromInternalField(index);
}
NAN_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)
NAN_INLINE void AddGCEpilogueCallback(
v8::Isolate::GCEpilogueCallback callback
, v8::GCType gc_type_filter = v8::kGCTypeAll) {
v8::Isolate::GetCurrent()->AddGCEpilogueCallback(callback, gc_type_filter);
}
NAN_INLINE void RemoveGCEpilogueCallback(
v8::Isolate::GCEpilogueCallback callback) {
v8::Isolate::GetCurrent()->RemoveGCEpilogueCallback(callback);
}
NAN_INLINE void AddGCPrologueCallback(
v8::Isolate::GCPrologueCallback callback
, v8::GCType gc_type_filter = v8::kGCTypeAll) {
v8::Isolate::GetCurrent()->AddGCPrologueCallback(callback, gc_type_filter);
}
NAN_INLINE void RemoveGCPrologueCallback(
v8::Isolate::GCPrologueCallback callback) {
v8::Isolate::GetCurrent()->RemoveGCPrologueCallback(callback);
}
NAN_INLINE void GetHeapStatistics(
v8::HeapStatistics *heap_statistics) {
v8::Isolate::GetCurrent()->GetHeapStatistics(heap_statistics);
}
# define X(NAME) \
NAN_INLINE v8::Local<v8::Value> NAME(const char *msg) { \
EscapableHandleScope scope; \
return scope.Escape(v8::Exception::NAME(New(msg).ToLocalChecked())); \
} \
\
NAN_INLINE \
v8::Local<v8::Value> NAME(v8::Local<v8::String> msg) { \
return v8::Exception::NAME(msg); \
} \
\
NAN_INLINE void Throw ## NAME(const char *msg) { \
HandleScope scope; \
v8::Isolate::GetCurrent()->ThrowException( \
v8::Exception::NAME(New(msg).ToLocalChecked())); \
} \
\
NAN_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
NAN_INLINE void ThrowError(v8::Local<v8::Value> error) {
v8::Isolate::GetCurrent()->ThrowException(error);
}
NAN_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 MaybeLocal<v8::Object>(node::Buffer::New(
v8::Isolate::GetCurrent(), data, length, callback, hint));
#endif
}
NAN_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 MaybeLocal<v8::Object>(node::Buffer::New(
v8::Isolate::GetCurrent(), data, size));
#endif
}
NAN_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 MaybeLocal<v8::Object>(node::Buffer::New(
v8::Isolate::GetCurrent(), size));
#endif
}
NAN_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 MaybeLocal<v8::Object>(
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))
NAN_INLINE MaybeLocal<v8::String>
NewOneByteString(const uint8_t * value, int length = -1) {
return v8::String::NewFromOneByte(v8::Isolate::GetCurrent(), value,
v8::NewStringType::kNormal, length);
}
NAN_INLINE MaybeLocal<BoundScript> CompileScript(
v8::Local<v8::String> s
, const v8::ScriptOrigin& origin
) {
v8::ScriptCompiler::Source source(s, origin);
return v8::ScriptCompiler::Compile(GetCurrentContext(), &source);
}
NAN_INLINE MaybeLocal<BoundScript> CompileScript(
v8::Local<v8::String> s
) {
v8::ScriptCompiler::Source source(s);
return v8::ScriptCompiler::Compile(GetCurrentContext(), &source);
}
NAN_INLINE MaybeLocal<v8::Value> RunScript(
v8::Local<UnboundScript> script
) {
return script->BindToCurrentContext()->Run(GetCurrentContext());
}
NAN_INLINE MaybeLocal<v8::Value> RunScript(
v8::Local<BoundScript> script
) {
return script->Run(GetCurrentContext());
}
#else
NAN_INLINE MaybeLocal<v8::String>
NewOneByteString(const uint8_t * value, int length = -1) {
return MaybeLocal<v8::String>(
v8::String::NewFromOneByte(
v8::Isolate::GetCurrent()
, value
, v8::String::kNormalString, length));
}
NAN_INLINE MaybeLocal<BoundScript> CompileScript(
v8::Local<v8::String> s
, const v8::ScriptOrigin& origin
) {
v8::ScriptCompiler::Source source(s, origin);
return MaybeLocal<BoundScript>(
v8::ScriptCompiler::Compile(v8::Isolate::GetCurrent(), &source));
}
NAN_INLINE MaybeLocal<BoundScript> CompileScript(
v8::Local<v8::String> s
) {
v8::ScriptCompiler::Source source(s);
return MaybeLocal<BoundScript>(
v8::ScriptCompiler::Compile(v8::Isolate::GetCurrent(), &source));
}
NAN_INLINE MaybeLocal<v8::Value> RunScript(
v8::Local<UnboundScript> script
) {
return MaybeLocal<v8::Value>(script->BindToCurrentContext()->Run());
}
NAN_INLINE MaybeLocal<v8::Value> RunScript(
v8::Local<BoundScript> script
) {
return MaybeLocal<v8::Value>(script->Run());
}
#endif
NAN_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
return New(node::MakeCallback(
v8::Isolate::GetCurrent(), target, func, argc, argv));
#else
return node::MakeCallback(
v8::Isolate::GetCurrent(), target, func, argc, argv);
#endif
}
NAN_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
return New(node::MakeCallback(
v8::Isolate::GetCurrent(), target, symbol, argc, argv));
#else
return node::MakeCallback(
v8::Isolate::GetCurrent(), target, symbol, argc, argv);
#endif
}
NAN_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
return New(node::MakeCallback(
v8::Isolate::GetCurrent(), target, method, argc, argv));
#else
return node::MakeCallback(
v8::Isolate::GetCurrent(), target, method, argc, argv);
#endif
}
NAN_INLINE void FatalException(const TryCatch& try_catch) {
node::FatalException(v8::Isolate::GetCurrent(), try_catch.try_catch_);
}
NAN_INLINE v8::Local<v8::Value> NanErrnoException(
int errorno
, const char* syscall = NULL
, const char* message = NULL
, const char* path = NULL) {
return node::ErrnoException(v8::Isolate::GetCurrent(), errorno, syscall,
message, path);
}
template<typename T>
NAN_INLINE void SetIsolateData(
v8::Isolate *isolate
, T *data
) {
isolate->SetData(0, data);
}
template<typename T>
NAN_INLINE T *GetIsolateData(
v8::Isolate *isolate
) {
return static_cast<T*>(isolate->GetData(0));
}
class Utf8String {
public:
NAN_INLINE explicit Utf8String(v8::Local<v8::Value> from) :
length_(0), str_(str_st_) {
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 |
v8::String::REPLACE_INVALID_UTF8;
length_ = string->WriteUtf8(str_, static_cast<int>(len), 0, flags);
str_[length_] = '\0';
}
}
}
NAN_INLINE int length() const {
return length_;
}
NAN_INLINE char* operator*() { return str_; }
NAN_INLINE const char* operator*() const { return str_; }
NAN_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
NAN_INLINE v8::Local<v8::Primitive> Undefined() {
EscapableHandleScope scope;
return scope.Escape(New(v8::Undefined()));
}
NAN_INLINE v8::Local<v8::Primitive> Null() {
EscapableHandleScope scope;
return scope.Escape(New(v8::Null()));
}
NAN_INLINE v8::Local<v8::Boolean> True() {
EscapableHandleScope scope;
return scope.Escape(New(v8::True()));
}
NAN_INLINE v8::Local<v8::Boolean> False() {
EscapableHandleScope scope;
return scope.Escape(New(v8::False()));
}
NAN_INLINE v8::Local<v8::String> EmptyString() {
return v8::String::Empty();
}
NAN_INLINE int AdjustExternalMemory(int bc) {
return static_cast<int>(v8::V8::AdjustAmountOfExternalAllocatedMemory(bc));
}
NAN_INLINE void SetTemplate(
v8::Local<v8::Template> templ
, const char *name
, v8::Local<v8::Data> value) {
templ->Set(name, value);
}
NAN_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);
}
NAN_INLINE v8::Local<v8::Context> GetCurrentContext() {
return v8::Context::GetCurrent();
}
NAN_INLINE void* GetInternalFieldPointer(
v8::Local<v8::Object> object
, int index) {
return object->GetPointerFromInternalField(index);
}
NAN_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)
NAN_INLINE void AddGCEpilogueCallback(
v8::GCEpilogueCallback callback
, v8::GCType gc_type_filter = v8::kGCTypeAll) {
v8::V8::AddGCEpilogueCallback(callback, gc_type_filter);
}
NAN_INLINE void RemoveGCEpilogueCallback(
v8::GCEpilogueCallback callback) {
v8::V8::RemoveGCEpilogueCallback(callback);
}
NAN_INLINE void AddGCPrologueCallback(
v8::GCPrologueCallback callback
, v8::GCType gc_type_filter = v8::kGCTypeAll) {
v8::V8::AddGCPrologueCallback(callback, gc_type_filter);
}
NAN_INLINE void RemoveGCPrologueCallback(
v8::GCPrologueCallback callback) {
v8::V8::RemoveGCPrologueCallback(callback);
}
NAN_INLINE void GetHeapStatistics(
v8::HeapStatistics *heap_statistics) {
v8::V8::GetHeapStatistics(heap_statistics);
}
# define X(NAME) \
NAN_INLINE v8::Local<v8::Value> NAME(const char *msg) { \
EscapableHandleScope scope; \
return scope.Escape(v8::Exception::NAME(New(msg).ToLocalChecked())); \
} \
\
NAN_INLINE \
v8::Local<v8::Value> NAME(v8::Local<v8::String> msg) { \
return v8::Exception::NAME(msg); \
} \
\
NAN_INLINE void Throw ## NAME(const char *msg) { \
HandleScope scope; \
v8::ThrowException(v8::Exception::NAME(New(msg).ToLocalChecked())); \
} \
\
NAN_INLINE \
void Throw ## NAME(v8::Local<v8::String> errmsg) { \
v8::ThrowException(v8::Exception::NAME(errmsg)); \
}
X(Error)
X(RangeError)
X(ReferenceError)
X(SyntaxError)
X(TypeError)
# undef X
NAN_INLINE void ThrowError(v8::Local<v8::Value> error) {
v8::ThrowException(error);
}
NAN_INLINE MaybeLocal<v8::Object> NewBuffer(
char *data
, size_t length
, node::Buffer::free_callback callback
, void *hint
) {
HandleScope scope;
// arbitrary buffer lengths requires
// NODE_MODULE_VERSION >= IOJS_3_0_MODULE_VERSION
assert(length <= imp::kMaxLength && "too large buffer");
return MaybeLocal<v8::Object>(
New(node::Buffer::New(data, length, callback, hint)->handle_));
}
NAN_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 MaybeLocal<v8::Object>(
scope.Escape(New(node::Buffer::New(data, size)->handle_)));
#else
return MaybeLocal<v8::Object>(scope.Escape(
New(node::Buffer::New(const_cast<char*>(data), size)->handle_)));
#endif
}
NAN_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 MaybeLocal<v8::Object>(
scope.Escape(New(node::Buffer::New(size)->handle_)));
}
NAN_INLINE void FreeData(char *data, void *hint) {
(void) hint; // unused
delete[] data;
}
NAN_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 MaybeLocal<v8::Object>(scope.Escape(New(
node::Buffer::New(data, size, FreeData, NULL)->handle_)));
}
namespace imp {
NAN_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
NAN_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 imp::Factory<v8::String>::return_t(v8::String::New(
&wideString.front(), static_cast<int>(wideString.size())));
}
NAN_INLINE MaybeLocal<BoundScript> CompileScript(
v8::Local<v8::String> s
, const v8::ScriptOrigin& origin
) {
return MaybeLocal<BoundScript>(
v8::Script::Compile(s, const_cast<v8::ScriptOrigin *>(&origin)));
}
NAN_INLINE MaybeLocal<BoundScript> CompileScript(
v8::Local<v8::String> s
) {
return MaybeLocal<BoundScript>(v8::Script::Compile(s));
}
NAN_INLINE
MaybeLocal<v8::Value> RunScript(v8::Local<v8::Script> script) {
return MaybeLocal<v8::Value>(script->Run());
}
NAN_INLINE v8::Local<v8::Value> MakeCallback(
v8::Local<v8::Object> target
, v8::Local<v8::Function> func
, int argc
, v8::Local<v8::Value>* argv) {
return New(node::MakeCallback(target, func, argc, argv));
}
NAN_INLINE v8::Local<v8::Value> MakeCallback(
v8::Local<v8::Object> target
, v8::Local<v8::String> symbol
, int argc
, v8::Local<v8::Value>* argv) {
return New(node::MakeCallback(target, symbol, argc, argv));
}
NAN_INLINE v8::Local<v8::Value> MakeCallback(
v8::Local<v8::Object> target
, const char* method
, int argc
, v8::Local<v8::Value>* argv) {
return New(node::MakeCallback(target, method, argc, argv));
}
NAN_INLINE void FatalException(const TryCatch& try_catch) {
node::FatalException(const_cast<v8::TryCatch &>(try_catch.try_catch_));
}
NAN_INLINE v8::Local<v8::Value> NanErrnoException(
int errorno
, const char* syscall = NULL
, const char* message = NULL
, const char* path = NULL) {
return node::ErrnoException(errorno, syscall, message, path);
}
template<typename T>
NAN_INLINE void SetIsolateData(
v8::Isolate *isolate
, T *data
) {
isolate->SetData(data);
}
template<typename T>
NAN_INLINE T *GetIsolateData(
v8::Isolate *isolate
) {
return static_cast<T*>(isolate->GetData());
}
class Utf8String {
public:
NAN_INLINE explicit Utf8String(v8::Local<v8::Value> from) :
length_(0), str_(str_st_) {
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 |
v8::String::REPLACE_INVALID_UTF8;
length_ = string->WriteUtf8(str_, static_cast<int>(len), 0, flags);
str_[length_] = '\0';
}
}
}
NAN_INLINE int length() const {
return length_;
}
NAN_INLINE char* operator*() { return str_; }
NAN_INLINE const char* operator*() const { return str_; }
NAN_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() {
HandleScope scope;
v8::Local<v8::Object> obj = New<v8::Object>();
handle.Reset(obj);
}
explicit Callback(const v8::Local<v8::Function> &fn) {
HandleScope scope;
v8::Local<v8::Object> obj = New<v8::Object>();
handle.Reset(obj);
SetFunction(fn);
}
~Callback() {
if (handle.IsEmpty()) return;
handle.Reset();
}
bool operator==(const Callback &other) const {
HandleScope scope;
v8::Local<v8::Value> a = New(handle)->Get(kCallbackIndex);
v8::Local<v8::Value> b = New(other.handle)->Get(kCallbackIndex);
return a->StrictEquals(b);
}
bool operator!=(const Callback &other) const {
return !this->operator==(other);
}
NAN_INLINE
v8::Local<v8::Function> operator*() const { return this->GetFunction(); }
NAN_INLINE v8::Local<v8::Value> operator()(
v8::Local<v8::Object> target
, int argc = 0
, v8::Local<v8::Value> argv[] = 0) const {
return this->Call(target, argc, argv);
}
NAN_INLINE v8::Local<v8::Value> operator()(
int argc = 0
, v8::Local<v8::Value> argv[] = 0) const {
return this->Call(argc, argv);
}
NAN_INLINE void SetFunction(const v8::Local<v8::Function> &fn) {
HandleScope scope;
Set(New(handle), kCallbackIndex, fn);
}
NAN_INLINE v8::Local<v8::Function> GetFunction() const {
EscapableHandleScope scope;
return scope.Escape(New(handle)->Get(kCallbackIndex)
.As<v8::Function>());
}
NAN_INLINE bool IsEmpty() const {
HandleScope scope;
return New(handle)->Get(kCallbackIndex)->IsUndefined();
}
NAN_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();
return Call_(isolate, target, argc, argv);
#else
return Call_(target, argc, argv);
#endif
}
NAN_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();
return Call_(isolate, isolate->GetCurrentContext()->Global(), argc, argv);
#else
return Call_(v8::Context::GetCurrent()->Global(), argc, argv);
#endif
}
private:
NAN_DISALLOW_ASSIGN_COPY_MOVE(Callback)
Persistent<v8::Object> handle;
static const uint32_t kCallbackIndex = 0;
#if (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)->
Get(kCallbackIndex).As<v8::Function>();
# 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)->
Get(kCallbackIndex).As<v8::Function>();
return scope.Escape(New(node::MakeCallback(
target
, callback
, argc
, argv
)));
}
#endif
};
/* abstract */ class AsyncWorker {
public:
explicit AsyncWorker(Callback *callback_)
: callback(callback_), errmsg_(NULL) {
request.data = this;
HandleScope scope;
v8::Local<v8::Object> obj = New<v8::Object>();
persistentHandle.Reset(obj);
}
virtual ~AsyncWorker() {
HandleScope scope;
if (!persistentHandle.IsEmpty())
persistentHandle.Reset();
if (callback)
delete callback;
if (errmsg_)
delete[] errmsg_;
}
virtual void WorkComplete() {
HandleScope scope;
if (errmsg_ == NULL)
HandleOKCallback();
else
HandleErrorCallback();
delete callback;
callback = NULL;
}
NAN_INLINE void SaveToPersistent(
const char *key, const v8::Local<v8::Value> &value) {
HandleScope scope;
New(persistentHandle)->Set(New(key).ToLocalChecked(), value);
}
NAN_INLINE void SaveToPersistent(
const v8::Local<v8::String> &key, const v8::Local<v8::Value> &value) {
HandleScope scope;
New(persistentHandle)->Set(key, value);
}
NAN_INLINE void SaveToPersistent(
uint32_t index, const v8::Local<v8::Value> &value) {
HandleScope scope;
New(persistentHandle)->Set(index, value);
}
NAN_INLINE v8::Local<v8::Value> GetFromPersistent(const char *key) const {
EscapableHandleScope scope;
return scope.Escape(
New(persistentHandle)->Get(New(key).ToLocalChecked()));
}
NAN_INLINE v8::Local<v8::Value>
GetFromPersistent(const v8::Local<v8::String> &key) const {
EscapableHandleScope scope;
return scope.Escape(New(persistentHandle)->Get(key));
}
NAN_INLINE v8::Local<v8::Value> GetFromPersistent(uint32_t index) const {
EscapableHandleScope scope;
return scope.Escape(New(persistentHandle)->Get(index));
}
virtual void Execute() = 0;
uv_work_t request;
virtual void Destroy() {
delete this;
}
protected:
Persistent<v8::Object> persistentHandle;
Callback *callback;
virtual void HandleOKCallback() {
callback->Call(0, NULL);
}
virtual void HandleErrorCallback() {
HandleScope scope;
v8::Local<v8::Value> argv[] = {
v8::Exception::Error(New<v8::String>(ErrorMessage()).ToLocalChecked())
};
callback->Call(1, argv);
}
void SetErrorMessage(const char *msg) {
if (errmsg_) {
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 AsyncProgressWorker : public AsyncWorker {
public:
explicit AsyncProgressWorker(Callback *callback_)
: AsyncWorker(callback_), asyncdata_(NULL), asyncsize_(0) {
async = new uv_async_t;
uv_async_init(
uv_default_loop()
, async
, AsyncProgress_
);
async->data = this;
uv_mutex_init(&async_lock);
}
virtual ~AsyncProgressWorker() {
uv_mutex_destroy(&async_lock);
if (asyncdata_) {
delete[] asyncdata_;
}
}
void WorkProgress() {
uv_mutex_lock(&async_lock);
char *data = asyncdata_;
size_t size = asyncsize_;
asyncdata_ = NULL;
uv_mutex_unlock(&async_lock);
// Dont send progress events after we've already completed.
if (callback) {
HandleProgressCallback(data, size);
}
delete[] data;
}
class ExecutionProgress {
friend class AsyncProgressWorker;
public:
// You could do fancy generics with templates here.
void Send(const char* data, size_t size) const {
that_->SendProgress_(data, size);
}
private:
explicit ExecutionProgress(AsyncProgressWorker* that) : that_(that) {}
NAN_DISALLOW_ASSIGN_COPY_MOVE(ExecutionProgress)
AsyncProgressWorker* const that_;
};
virtual void Execute(const ExecutionProgress& progress) = 0;
virtual void HandleProgressCallback(const char *data, size_t size) = 0;
virtual void Destroy() {
uv_close(reinterpret_cast<uv_handle_t*>(async), AsyncClose_);
}
private:
void Execute() /*final override*/ {
ExecutionProgress progress(this);
Execute(progress);
}
void SendProgress_(const char *data, size_t size) {
char *new_data = new char[size];
memcpy(new_data, data, size);
uv_mutex_lock(&async_lock);
char *old_data = asyncdata_;
asyncdata_ = new_data;
asyncsize_ = size;
uv_mutex_unlock(&async_lock);
if (old_data) {
delete[] old_data;
}
uv_async_send(async);
}
NAN_INLINE static NAUV_WORK_CB(AsyncProgress_) {
AsyncProgressWorker *worker =
static_cast<AsyncProgressWorker*>(async->data);
worker->WorkProgress();
}
NAN_INLINE static void AsyncClose_(uv_handle_t* handle) {
AsyncProgressWorker *worker =
static_cast<AsyncProgressWorker*>(handle->data);
delete reinterpret_cast<uv_async_t*>(handle);
delete worker;
}
uv_async_t *async;
uv_mutex_t async_lock;
char *asyncdata_;
size_t asyncsize_;
};
NAN_INLINE void AsyncExecute (uv_work_t* req) {
AsyncWorker *worker = static_cast<AsyncWorker*>(req->data);
worker->Execute();
}
NAN_INLINE void AsyncExecuteComplete (uv_work_t* req) {
AsyncWorker* worker = static_cast<AsyncWorker*>(req->data);
worker->WorkComplete();
worker->Destroy();
}
NAN_INLINE void AsyncQueueWorker (AsyncWorker* worker) {
uv_queue_work(
uv_default_loop()
, &worker->request
, AsyncExecute
, (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
NAN_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
}
NAN_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
}
NAN_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
}
NAN_INLINE void SetPrototypeTemplate(
v8::Local<v8::FunctionTemplate> templ
, const char *name
, v8::Local<v8::Data> value
) {
SetTemplate(templ->PrototypeTemplate(), name, value);
}
NAN_INLINE void SetPrototypeTemplate(
v8::Local<v8::FunctionTemplate> templ
, v8::Local<v8::String> name
, v8::Local<v8::Data> value
, v8::PropertyAttribute attributes
) {
SetTemplate(templ->PrototypeTemplate(), name, value, attributes);
}
NAN_INLINE void SetInstanceTemplate(
v8::Local<v8::FunctionTemplate> templ
, const char *name
, v8::Local<v8::Data> value
) {
SetTemplate(templ->InstanceTemplate(), name, value);
}
NAN_INLINE void SetInstanceTemplate(
v8::Local<v8::FunctionTemplate> templ
, v8::Local<v8::String> name
, v8::Local<v8::Data> value
, v8::PropertyAttribute attributes
) {
SetTemplate(templ->InstanceTemplate(), name, value, attributes);
}
template<typename T>
NAN_INLINE void SetMethod(
const T &recv
, const char *name
, FunctionCallback callback) {
HandleScope scope;
v8::Local<v8::Function> fn = New<v8::FunctionTemplate>(
callback)->GetFunction();
v8::Local<v8::String> fn_name = New(name).ToLocalChecked();
fn->SetName(fn_name);
recv->Set(fn_name, fn);
}
NAN_INLINE void SetPrototypeMethod(
v8::Local<v8::FunctionTemplate> recv
, const char* name, FunctionCallback callback) {
HandleScope scope;
v8::Local<v8::Function> fn = New<v8::FunctionTemplate>(
callback
, v8::Local<v8::Value>()
, New<v8::Signature>(recv))->GetFunction();
v8::Local<v8::String> fn_name = New(name).ToLocalChecked();
recv->PrototypeTemplate()->Set(fn_name, fn);
fn->SetName(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 = otpl->NewInstance();
SetInternalFieldPointer(
obj
, imp::kGetterIndex
, imp::GetWrapper<GetterCallback, imp::GetterWrapper>(getter));
if (setter != 0) {
SetInternalFieldPointer(
obj
, imp::kSetterIndex
, imp::GetWrapper<SetterCallback,
imp::SetterWrapper>(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) {
EscapableHandleScope 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 = otpl->NewInstance();
SetInternalFieldPointer(
dataobj
, imp::kGetterIndex
, imp::GetWrapper<GetterCallback, imp::GetterWrapper>(getter));
if (!data.IsEmpty()) {
dataobj->SetInternalField(imp::kDataIndex, data);
}
if (setter) {
SetInternalFieldPointer(
dataobj
, imp::kPropertySetterIndex
, imp::GetWrapper<SetterCallback,
imp::SetterWrapper>(setter));
}
return obj->SetAccessor(
name
, getter_
, setter_
, dataobj
, settings
, attribute);
}
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 = otpl->NewInstance();
SetInternalFieldPointer(
obj
, imp::kPropertyGetterIndex
, imp::GetWrapper<PropertyGetterCallback,
imp::PropertyGetterWrapper>(getter));
if (setter) {
SetInternalFieldPointer(
obj
, imp::kPropertySetterIndex
, imp::GetWrapper<PropertySetterCallback,
imp::PropertySetterWrapper>(setter));
}
if (query) {
SetInternalFieldPointer(
obj
, imp::kPropertyQueryIndex
, imp::GetWrapper<PropertyQueryCallback,
imp::PropertyQueryWrapper>(query));
}
if (deleter) {
SetInternalFieldPointer(
obj
, imp::kPropertyDeleterIndex
, imp::GetWrapper<PropertyDeleterCallback,
imp::PropertyDeleterWrapper>(deleter));
}
if (enumerator) {
SetInternalFieldPointer(
obj
, imp::kPropertyEnumeratorIndex
, imp::GetWrapper<PropertyEnumeratorCallback,
imp::PropertyEnumeratorWrapper>(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 = otpl->NewInstance();
SetInternalFieldPointer(
obj
, imp::kIndexPropertyGetterIndex
, imp::GetWrapper<IndexGetterCallback,
imp::IndexGetterWrapper>(getter));
if (setter) {
SetInternalFieldPointer(
obj
, imp::kIndexPropertySetterIndex
, imp::GetWrapper<IndexSetterCallback,
imp::IndexSetterWrapper>(setter));
}
if (query) {
SetInternalFieldPointer(
obj
, imp::kIndexPropertyQueryIndex
, imp::GetWrapper<IndexQueryCallback,
imp::IndexQueryWrapper>(query));
}
if (deleter) {
SetInternalFieldPointer(
obj
, imp::kIndexPropertyDeleterIndex
, imp::GetWrapper<IndexDeleterCallback,
imp::IndexDeleterWrapper>(deleter));
}
if (enumerator) {
SetInternalFieldPointer(
obj
, imp::kIndexPropertyEnumeratorIndex
, imp::GetWrapper<IndexEnumeratorCallback,
imp::IndexEnumeratorWrapper>(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
}
//=== ObjectWrap ===============================================================
class ObjectWrap : public node::ObjectWrap {
public:
#if NODE_MODULE_VERSION < NODE_0_12_MODULE_VERSION
inline v8::Local<v8::Object> handle() { return New(handle_); }
inline Persistent<v8::Object> &persistent() {
Persistent<v8::Object> temp(handle_);
std::memcpy(&persistent_, &temp, sizeof(persistent_));
return persistent_;
}
private:
Persistent<v8::Object> persistent_;
#else
inline Persistent<v8::Object> &persistent() {
return static_cast<Persistent<v8::Object>&>(node::ObjectWrap::persistent());
}
#endif
};
//=== Weak Persistent Handling =================================================
#include "nan_weak.h" // NOLINT(build/include)
//=== Export ==================================================================
inline
void
Export(ADDON_REGISTER_FUNCTION_ARGS_TYPE target, const char *name,
FunctionCallback f) {
Set(target, New<v8::String>(name).ToLocalChecked(),
New<v8::FunctionTemplate>(f)->GetFunction());
}
//=== Tap Reverse Binding =====================================================
struct Tap {
explicit Tap(v8::Local<v8::Value> t) : t_() {
t_.Reset(To<v8::Object>(t).ToLocalChecked());
}
~Tap() { t_.Reset(); } // not sure if neccessary
inline void plan(int i) {
v8::Local<v8::Value> arg = New(i);
MakeCallback(New(t_), "plan", 1, &arg);
}
inline void ok(bool isOk, const char *msg = NULL) {
v8::Local<v8::Value> args[2];
args[0] = New(isOk);
if (msg) args[1] = New(msg).ToLocalChecked();
MakeCallback(New(t_), "ok", msg ? 2 : 1, args);
}
inline void pass(const char * msg = NULL) {
v8::Local<v8::Value> hmsg;
if (msg) hmsg = New(msg).ToLocalChecked();
MakeCallback(New(t_), "pass", msg ? 1 : 0, &hmsg);
}
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
} // end of namespace Nan
#endif // NAN_H_
Jump to Line
Something went wrong with that request. Please try again.