Launch Week Day 5: Introducing Reachability for PHP.Learn More →
Socket
Book a DemoSign in
Socket
Book a DemoSign in

nan

Package Overview
Dependencies
Maintainers
1
Versions
98
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

nan - npm Package Compare versions

Comparing version
0.8.0
 to
1.0.0
+968
-254
nan.h

@@ -14,5 +14,28 @@ /**********************************************************************************

*
* Version 0.8.0 (current Node unstable: 0.11.10, Node stable: 0.10.24)
* Version 1.0.0 (current Node unstable: 0.11.13, Node stable: 0.10.28)
*
* ChangeLog:
* * 1.0.0 May 4 2014
* - Heavy API changes for V8 3.25 / Node 0.11.13
* - Use cpplint.py
* - Removed NanInitPersistent
* - Removed NanPersistentToLocal
* - Removed NanFromV8String
* - Removed NanMakeWeak
* - Removed NanNewLocal
* - Removed NAN_WEAK_CALLBACK_OBJECT
* - Removed NAN_WEAK_CALLBACK_DATA
* - Introduce NanNew, replaces NanNewLocal, NanPersistentToLocal, adds many overloaded typed versions
* - Introduce NanUndefined, NanNull, NanTrue and NanFalse
* - Introduce NanEscapableScope and NanEscapeScope
* - Introduce NanMakeWeakPersistent (requires a special callback to work on both old and new node)
* - Introduce NanMakeCallback for node::MakeCallback
* - Introduce NanSetTemplate
* - Introduce NanGetCurrentContext
* - Introduce NanCompileScript and NanRunScript
* - Introduce NanAdjustExternalMemory
* - Introduce NanAddGCEpilogueCallback, NanAddGCPrologueCallback, NanRemoveGCEpilogueCallback, NanRemoveGCPrologueCallback
* - Introduce NanGetHeapStatistics
* - Rename NanAsyncWorker#SavePersistent() to SaveToPersistent()
*
* * 0.8.0 Jan 9 2014

@@ -131,4 +154,4 @@ * - NanDispose -> NanDisposePersistent, deprecate NanDispose

#ifndef NAN_H
#define NAN_H
#ifndef NAN_H_
#define NAN_H_

@@ -143,15 +166,15 @@ #include <uv.h>

#if defined(__GNUC__) && !defined(DEBUG)
# define NAN_INLINE(declarator) inline __attribute__((always_inline)) declarator
# define NAN_INLINE inline __attribute__((always_inline))
#elif defined(_MSC_VER) && !defined(DEBUG)
# define NAN_INLINE(declarator) __forceinline declarator
# define NAN_INLINE __forceinline
#else
# define NAN_INLINE(declarator) inline declarator
# define NAN_INLINE inline
#endif
#if defined(__GNUC__) && !V8_DISABLE_DEPRECATIONS
# define NAN_DEPRECATED(declarator) __attribute__((deprecated)) declarator
# define NAN_DEPRECATED __attribute__((deprecated))
#elif defined(_MSC_VER) && !V8_DISABLE_DEPRECATIONS
# define NAN_DEPRECATED(declarator) __declspec(deprecated) declarator
# define NAN_DEPRECATED __declspec(deprecated)
#else
# define NAN_DEPRECATED(declarator) declarator
# define NAN_DEPRECATED
#endif

@@ -161,6 +184,6 @@

template<class T> static NAN_INLINE(bool NanSetPointerSafe(
template<typename T> NAN_INLINE bool NanSetPointerSafe(
T *var
, T val
)) {
) {
if (var) {

@@ -174,6 +197,6 @@ *var = val;

template<class T> static NAN_INLINE(T NanGetPointerSafe(
template<typename T> NAN_INLINE T NanGetPointerSafe(
T *var
, T fallback = reinterpret_cast<T>(0)
)) {
) {
if (var) {

@@ -186,8 +209,6 @@ return *var;

#define NanSymbol(value) v8::String::NewSymbol(value)
static NAN_INLINE(bool NanBooleanOptionValue(
NAN_INLINE bool NanBooleanOptionValue(
v8::Local<v8::Object> optionsObj
, v8::Handle<v8::String> opt, bool def
)) {
) {
if (def) {

@@ -204,14 +225,14 @@ return optionsObj.IsEmpty()

static NAN_INLINE(bool NanBooleanOptionValue(
NAN_INLINE bool NanBooleanOptionValue(
v8::Local<v8::Object> optionsObj
, v8::Handle<v8::String> opt
)) {
) {
return NanBooleanOptionValue(optionsObj, opt, false);
}
static NAN_INLINE(uint32_t NanUInt32OptionValue(
NAN_INLINE uint32_t NanUInt32OptionValue(
v8::Local<v8::Object> optionsObj
, v8::Handle<v8::String> opt
, uint32_t def
)) {
) {
return !optionsObj.IsEmpty()

@@ -227,4 +248,2 @@ && optionsObj->Has(opt)

static v8::Isolate* nan_isolate = v8::Isolate::GetCurrent();
# define _NAN_METHOD_ARGS_TYPE const v8::FunctionCallbackInfo<v8::Value>&

@@ -293,2 +312,15 @@ # define _NAN_METHOD_ARGS _NAN_METHOD_ARGS_TYPE args

typedef v8::FunctionCallback NanFunctionCallback;
static v8::Isolate* nan_isolate = v8::Isolate::GetCurrent();
# define NanUndefined() v8::Undefined(nan_isolate)
# define NanNull() v8::Null(nan_isolate)
# define NanTrue() v8::True(nan_isolate)
# define NanFalse() v8::False(nan_isolate)
# define NanAdjustExternalMemory(amount) \
nan_isolate->AdjustAmountOfExternalAllocatedMemory(amount)
# define NanSetTemplate(templ, name, value) templ->Set(nan_isolate, name, value)
# define NanGetCurrentContext() nan_isolate->GetCurrentContext()
# define NanMakeCallback(target, func, argc, argv) \
node::MakeCallback(nan_isolate, target, func, argc, argv)
# define NanGetInternalFieldPointer(object, index) \

@@ -299,11 +331,365 @@ object->GetAlignedPointerFromInternalField(index)

# define NAN_WEAK_CALLBACK(type, name) \
void name( \
v8::Isolate* isolate \
, v8::Persistent<v8::Object>* object \
, type data)
# define NAN_WEAK_CALLBACK_OBJECT (*object)
# define NAN_WEAK_CALLBACK_DATA(type) ((type) data)
template<typename T>
NAN_INLINE v8::Local<T> NanNew() {
return T::New(nan_isolate);
}
template<typename T, typename P>
NAN_INLINE v8::Local<T> NanNew(P arg1) {
return T::New(nan_isolate, arg1);
}
template<typename T>
NAN_INLINE v8::Local<v8::Signature> NanNew(
v8::Handle<v8::FunctionTemplate> receiver
, int argc
, v8::Handle<v8::FunctionTemplate> argv[] = 0) {
return v8::Signature::New(nan_isolate, receiver, argc, argv);
}
template<typename T>
NAN_INLINE v8::Local<v8::FunctionTemplate> NanNew(
NanFunctionCallback callback
, v8::Handle<v8::Value> data = v8::Handle<v8::Value>()
, v8::Handle<v8::Signature> signature = v8::Handle<v8::Signature>()) {
return T::New(nan_isolate, callback, data, signature);
}
template<typename T>
NAN_INLINE v8::Local<T> NanNew(v8::Handle<T> arg1) {
return v8::Local<T>::New(nan_isolate, arg1);
}
template<typename T>
NAN_INLINE v8::Local<T> NanNew(const v8::Persistent<T> &arg1) {
return v8::Local<T>::New(nan_isolate, arg1);
}
template<typename T, typename P>
NAN_INLINE v8::Local<T> NanNew(P arg1, int arg2) {
return T::New(nan_isolate, arg1, arg2);
}
template<>
NAN_INLINE v8::Local<v8::Array> NanNew<v8::Array>() {
return v8::Array::New(nan_isolate);
}
template<>
NAN_INLINE v8::Local<v8::Array> NanNew<v8::Array>(int length) {
return v8::Array::New(nan_isolate, length);
}
template<>
NAN_INLINE v8::Local<v8::Date> NanNew<v8::Date>(double time) {
return v8::Date::New(nan_isolate, time).As<v8::Date>();
}
template<>
NAN_INLINE v8::Local<v8::Date> NanNew<v8::Date>(int time) {
return v8::Date::New(nan_isolate, time).As<v8::Date>();
}
typedef v8::UnboundScript NanUnboundScript;
typedef v8::Script NanBoundScript;
template<typename T, typename P>
NAN_INLINE v8::Local<T> NanNew(
P s
, const v8::ScriptOrigin& origin
) {
v8::ScriptCompiler::Source source(s, origin);
return v8::ScriptCompiler::CompileUnbound(nan_isolate, &source);
}
template<>
NAN_INLINE v8::Local<NanUnboundScript> NanNew<NanUnboundScript>(
v8::Local<v8::String> s
) {
v8::ScriptCompiler::Source source(s);
return v8::ScriptCompiler::CompileUnbound(nan_isolate, &source);
}
NAN_INLINE v8::Local<v8::String> NanNew(
v8::String::ExternalStringResource *resource) {
return v8::String::NewExternal(nan_isolate, resource);
}
NAN_INLINE v8::Local<v8::String> NanNew(
v8::String::ExternalAsciiStringResource *resource) {
return v8::String::NewExternal(nan_isolate, resource);
}
template<>
NAN_INLINE v8::Local<v8::BooleanObject> NanNew(bool value) {
return v8::BooleanObject::New(value).As<v8::BooleanObject>();
}
template<>
NAN_INLINE v8::Local<v8::StringObject>
NanNew<v8::StringObject, v8::Local<v8::String> >(
v8::Local<v8::String> value) {
return v8::StringObject::New(value).As<v8::StringObject>();
}
template<>
NAN_INLINE v8::Local<v8::StringObject>
NanNew<v8::StringObject, v8::Handle<v8::String> >(
v8::Handle<v8::String> value) {
return v8::StringObject::New(value).As<v8::StringObject>();
}
template<>
NAN_INLINE v8::Local<v8::NumberObject> NanNew<v8::NumberObject>(double val) {
return v8::NumberObject::New(nan_isolate, val).As<v8::NumberObject>();
}
template<typename T>
NAN_INLINE v8::Local<v8::RegExp> NanNew(
v8::Handle<v8::String> pattern, v8::RegExp::Flags flags) {
return v8::RegExp::New(pattern, flags);
}
template<typename T>
NAN_INLINE v8::Local<v8::RegExp> NanNew(
v8::Local<v8::String> pattern, v8::RegExp::Flags flags) {
return v8::RegExp::New(pattern, flags);
}
template<typename T, typename P>
NAN_INLINE v8::Local<v8::RegExp> NanNew(
v8::Handle<v8::String> pattern, v8::RegExp::Flags flags) {
return v8::RegExp::New(pattern, flags);
}
template<typename T, typename P>
NAN_INLINE v8::Local<v8::RegExp> NanNew(
v8::Local<v8::String> pattern, v8::RegExp::Flags flags) {
return v8::RegExp::New(pattern, flags);
}
template<>
NAN_INLINE v8::Local<v8::Uint32> NanNew<v8::Uint32, int32_t>(int32_t val) {
return v8::Uint32::NewFromUnsigned(nan_isolate, val)->ToUint32();
}
template<>
NAN_INLINE v8::Local<v8::Uint32> NanNew<v8::Uint32, uint32_t>(uint32_t val) {
return v8::Uint32::NewFromUnsigned(nan_isolate, val)->ToUint32();
}
template<>
NAN_INLINE v8::Local<v8::Int32> NanNew<v8::Int32, int32_t>(int32_t val) {
return v8::Int32::New(nan_isolate, val)->ToInt32();
}
template<>
NAN_INLINE v8::Local<v8::Int32> NanNew<v8::Int32, uint32_t>(uint32_t val) {
return v8::Int32::New(nan_isolate, val)->ToInt32();
}
template<>
NAN_INLINE v8::Local<v8::String> NanNew<v8::String, char *>(
char *arg
, int length) {
return v8::String::NewFromUtf8(
nan_isolate
, arg
, v8::String::kNormalString
, length);
}
template<>
NAN_INLINE v8::Local<v8::String> NanNew<v8::String, const char *>(
const char *arg
, int length) {
return v8::String::NewFromUtf8(
nan_isolate
, arg
, v8::String::kNormalString
, length);
}
template<>
NAN_INLINE v8::Local<v8::String> NanNew<v8::String, char *>(char *arg) {
return v8::String::NewFromUtf8(nan_isolate, arg);
}
template<>
NAN_INLINE v8::Local<v8::String> NanNew<v8::String, const char *>(
const char *arg) {
return v8::String::NewFromUtf8(nan_isolate, arg);
}
template<>
NAN_INLINE v8::Local<v8::String> NanNew<v8::String, uint8_t *>(
uint8_t *arg
, int length) {
return v8::String::NewFromOneByte(
nan_isolate
, arg
, v8::String::kNormalString
, length);
}
template<>
NAN_INLINE v8::Local<v8::String> NanNew<v8::String, const uint8_t *>(
const uint8_t *arg
, int length) {
return v8::String::NewFromOneByte(
nan_isolate
, arg
, v8::String::kNormalString
, length);
}
template<>
NAN_INLINE v8::Local<v8::String> NanNew<v8::String, uint8_t *>(uint8_t *arg) {
return v8::String::NewFromOneByte(nan_isolate, arg);
}
template<>
NAN_INLINE v8::Local<v8::String> NanNew<v8::String, const uint8_t *>(
const uint8_t *arg) {
return v8::String::NewFromOneByte(nan_isolate, arg);
}
template<>
NAN_INLINE v8::Local<v8::String> NanNew<v8::String, uint16_t *>(
uint16_t *arg
, int length) {
return v8::String::NewFromTwoByte(
nan_isolate
, arg
, v8::String::kNormalString
, length);
}
template<>
NAN_INLINE v8::Local<v8::String> NanNew<v8::String, const uint16_t *>(
const uint16_t *arg
, int length) {
return v8::String::NewFromTwoByte(
nan_isolate
, arg
, v8::String::kNormalString
, length);
}
template<>
NAN_INLINE v8::Local<v8::String> NanNew<v8::String, uint16_t *>(
uint16_t *arg) {
return v8::String::NewFromTwoByte(nan_isolate, arg);
}
template<>
NAN_INLINE v8::Local<v8::String> NanNew<v8::String, const uint16_t *>(
const uint16_t *arg) {
return v8::String::NewFromTwoByte(nan_isolate, arg);
}
template<>
NAN_INLINE v8::Local<v8::String> NanNew<v8::String>() {
return v8::String::Empty(nan_isolate);
}
NAN_INLINE void NanAddGCEpilogueCallback(
v8::Isolate::GCEpilogueCallback callback
, v8::GCType gc_type_filter = v8::kGCTypeAll) {
nan_isolate->AddGCEpilogueCallback(callback, gc_type_filter);
}
NAN_INLINE void NanRemoveGCEpilogueCallback(
v8::Isolate::GCEpilogueCallback callback) {
nan_isolate->RemoveGCEpilogueCallback(callback);
}
NAN_INLINE void NanAddGCPrologueCallback(
v8::Isolate::GCPrologueCallback callback
, v8::GCType gc_type_filter = v8::kGCTypeAll) {
nan_isolate->AddGCPrologueCallback(callback, gc_type_filter);
}
NAN_INLINE void NanRemoveGCPrologueCallback(
v8::Isolate::GCPrologueCallback callback) {
nan_isolate->RemoveGCPrologueCallback(callback);
}
NAN_INLINE void NanGetHeapStatistics(
v8::HeapStatistics *heap_statistics) {
nan_isolate->GetHeapStatistics(heap_statistics);
}
# define NanSymbol(value) NanNew<v8::String>(value)
template<typename T>
NAN_INLINE void NanAssignPersistent(
v8::Persistent<T>& handle
, v8::Handle<T> obj) {
handle.Reset(nan_isolate, obj);
}
template<typename T>
NAN_INLINE void NanAssignPersistent(
v8::Persistent<T>& handle
, const v8::Persistent<T>& obj) {
handle.Reset(nan_isolate, obj);
}
template<typename T, typename P>
struct _NanWeakCallbackInfo {
typedef void (*Callback)(
const v8::WeakCallbackData<T, _NanWeakCallbackInfo<T, P> >& data);
_NanWeakCallbackInfo(v8::Handle<T> handle, P* param, Callback cb)
: parameter(param), callback(cb) {
NanAssignPersistent(persistent, handle);
}
~_NanWeakCallbackInfo() {
persistent.Reset();
}
P* const parameter;
Callback const callback;
v8::Persistent<T> persistent;
};
template<typename T, typename P>
class _NanWeakCallbackData {
public:
_NanWeakCallbackData(_NanWeakCallbackInfo<T, P> *info)
: info_(info) { }
NAN_INLINE v8::Local<T> GetValue() const {
return NanNew(info_->persistent);
}
NAN_INLINE P* GetParameter() const { return info_->parameter; }
NAN_INLINE void Revive() const {
info_->persistent.SetWeak(info_, info_->callback);
}
NAN_INLINE void Dispose() const {
delete info_;
}
private:
_NanWeakCallbackInfo<T, P>* info_;
};
// do not use for declaration
# define NAN_WEAK_CALLBACK(name) \
template<typename T, typename P> \
static void name( \
const v8::WeakCallbackData<T, _NanWeakCallbackInfo<T, P> > &data) { \
_NanWeakCallbackData<T, P> wcbd( \
data.GetParameter()); \
_Nan_Weak_Callback_ ## name(wcbd); \
} \
\
template<typename T, typename P> \
NAN_INLINE void _Nan_Weak_Callback_ ## name( \
const _NanWeakCallbackData<T, P> &data)
# define NanScope() v8::HandleScope scope(nan_isolate)
# define NanEscapableScope() v8::EscapableHandleScope scope(nan_isolate)
# define NanEscapeScope(val) scope.Escape(val)
# define NanLocker() v8::Locker locker(nan_isolate)

@@ -315,17 +701,16 @@ # define NanUnlocker() v8::Unlocker unlocker(nan_isolate)

# define NanReturnEmptyString() return args.GetReturnValue().SetEmptyString()
# define NanAssignPersistent(type, handle, obj) handle.Reset(nan_isolate, obj)
# define NanInitPersistent(type, name, obj) \
v8::Persistent<type> name(nan_isolate, obj)
# define NanObjectWrapHandle(obj) obj->handle()
//TODO: remove <0.11.8 support when 0.12 is released
#if NODE_VERSION_AT_LEAST(0, 11, 8)
# define NanMakeWeak(handle, parameter, callback) \
handle.MakeWeak(parameter, callback)
#else
# define NanMakeWeak(handle, parameter, callback) \
handle.MakeWeak(nan_isolate, parameter, callback)
#endif
template<typename T, typename P>
void NAN_INLINE NanMakeWeakPersistent(
v8::Handle<T> handle
, P* parameter
, typename _NanWeakCallbackInfo<T, P>::Callback callback) {
_NanWeakCallbackInfo<T, P> *cbinfo =
new _NanWeakCallbackInfo<T, P>(handle, parameter, callback);
cbinfo->persistent.SetWeak(cbinfo, callback);
}
# define _NAN_ERROR(fun, errmsg) fun(v8::String::New(errmsg))
# define _NAN_ERROR(fun, errmsg) fun(NanNew<v8::String>(errmsg))

@@ -335,82 +720,58 @@ # define _NAN_THROW_ERROR(fun, errmsg) \

NanScope(); \
v8::ThrowException(_NAN_ERROR(fun, errmsg)); \
nan_isolate->ThrowException(_NAN_ERROR(fun, errmsg)); \
} while (0);
template<class T> static NAN_INLINE(v8::Local<T> NanNewLocal(
v8::Handle<T> val
)) {
//TODO: remove <0.11.9 support when 0.12 is released
#if NODE_VERSION_AT_LEAST(0, 11, 9)
return v8::Local<T>::New(nan_isolate, val);
#else
return v8::Local<T>::New(val);
#endif
}
static NAN_INLINE(v8::Handle<v8::Value> NanError(const char* errmsg)) {
NAN_INLINE v8::Local<v8::Value> NanError(const char* errmsg) {
return _NAN_ERROR(v8::Exception::Error, errmsg);
}
static NAN_INLINE(void NanThrowError(const char* errmsg)) {
NAN_INLINE void NanThrowError(const char* errmsg) {
_NAN_THROW_ERROR(v8::Exception::Error, errmsg);
}
static NAN_INLINE(void NanThrowError(v8::Handle<v8::Value> error)) {
NAN_INLINE void NanThrowError(v8::Handle<v8::Value> error) {
NanScope();
v8::ThrowException(error);
nan_isolate->ThrowException(error);
}
static NAN_INLINE(v8::Handle<v8::Value> NanError(
NAN_INLINE v8::Local<v8::Value> NanError(
const char *msg
, const int errorNumber
)) {
v8::Local<v8::Value> err = v8::Exception::Error(v8::String::New(msg));
) {
v8::Local<v8::Value> err = v8::Exception::Error(NanNew<v8::String>(msg));
v8::Local<v8::Object> obj = err.As<v8::Object>();
obj->Set(v8::String::New("code"), v8::Int32::New(errorNumber));
obj->Set(NanSymbol("code"), NanNew<v8::Integer>(errorNumber));
return err;
}
static NAN_INLINE(void NanThrowError(
NAN_INLINE void NanThrowError(
const char *msg
, const int errorNumber
)) {
) {
NanThrowError(NanError(msg, errorNumber));
}
static NAN_INLINE(v8::Handle<v8::Value> NanTypeError(const char* errmsg)) {
NAN_INLINE v8::Local<v8::Value> NanTypeError(const char* errmsg) {
return _NAN_ERROR(v8::Exception::TypeError, errmsg);
}
static NAN_INLINE(void NanThrowTypeError(const char* errmsg)) {
NAN_INLINE void NanThrowTypeError(const char* errmsg) {
_NAN_THROW_ERROR(v8::Exception::TypeError, errmsg);
}
static NAN_INLINE(v8::Handle<v8::Value> NanRangeError(const char* errmsg)) {
NAN_INLINE v8::Local<v8::Value> NanRangeError(const char* errmsg) {
return _NAN_ERROR(v8::Exception::RangeError, errmsg);
}
static NAN_INLINE(void NanThrowRangeError(const char* errmsg)) {
NAN_INLINE void NanThrowRangeError(const char* errmsg) {
_NAN_THROW_ERROR(v8::Exception::RangeError, errmsg);
}
template<class T> static NAN_INLINE(void NanDisposePersistent(
template<typename T> NAN_INLINE void NanDisposePersistent(
v8::Persistent<T> &handle
)) {
//TODO: remove <0.11.8 support when 0.12 is released
# if NODE_VERSION_AT_LEAST(0, 11, 8)
) {
handle.Reset();
# else
handle.Dispose(nan_isolate);
# endif
handle.Clear();
}
template<class T> static NAN_DEPRECATED(void NanDispose(
v8::Persistent<T> &handle
)) {
NanDisposePersistent(handle);
}
static NAN_INLINE(v8::Local<v8::Object> NanNewBufferHandle (
NAN_INLINE v8::Local<v8::Object> NanNewBufferHandle (
char *data

@@ -420,43 +781,36 @@ , size_t length

, void *hint
)) {
return node::Buffer::New(data, length, callback, hint);
) {
return node::Buffer::New(nan_isolate, data, length, callback, hint);
}
static NAN_INLINE(v8::Local<v8::Object> NanNewBufferHandle (
char *data
NAN_INLINE v8::Local<v8::Object> NanNewBufferHandle (
const char *data
, uint32_t size
)) {
return node::Buffer::New(data, size);
) {
return node::Buffer::New(nan_isolate, data, size);
}
static NAN_INLINE(v8::Local<v8::Object> NanNewBufferHandle (uint32_t size)) {
return node::Buffer::New(size);
NAN_INLINE v8::Local<v8::Object> NanNewBufferHandle (uint32_t size) {
return node::Buffer::New(nan_isolate, size);
}
static NAN_INLINE(v8::Local<v8::Object> NanBufferUse(
NAN_INLINE v8::Local<v8::Object> NanBufferUse(
char* data
, uint32_t size
)) {
return node::Buffer::Use(data, size);
) {
return node::Buffer::Use(nan_isolate, data, size);
}
template <class TypeName>
static NAN_INLINE(v8::Local<TypeName> NanPersistentToLocal(
const v8::Persistent<TypeName>& persistent
)) {
return v8::Local<TypeName>::New(nan_isolate, persistent);
}
static NAN_INLINE(bool NanHasInstance(
NAN_INLINE bool NanHasInstance(
v8::Persistent<v8::FunctionTemplate>& function_template
, v8::Handle<v8::Value> value
)) {
return NanPersistentToLocal(function_template)->HasInstance(value);
) {
return NanNew(function_template)->HasInstance(value);
}
static NAN_INLINE(v8::Local<v8::Context> NanNewContextHandle(
NAN_INLINE v8::Local<v8::Context> NanNewContextHandle(
v8::ExtensionConfiguration* extensions = NULL
, v8::Handle<v8::ObjectTemplate> tmpl = v8::Handle<v8::ObjectTemplate>()
, v8::Handle<v8::Value> obj = v8::Handle<v8::Value>()
)) {
) {
return v8::Local<v8::Context>::New(

@@ -468,2 +822,29 @@ nan_isolate

NAN_INLINE v8::Local<NanBoundScript> NanCompileScript(
v8::Local<v8::String> s
, const v8::ScriptOrigin& origin
) {
v8::ScriptCompiler::Source source(s, origin);
return v8::ScriptCompiler::Compile(nan_isolate, &source);
}
NAN_INLINE v8::Local<NanBoundScript> NanCompileScript(
v8::Local<v8::String> s
) {
v8::ScriptCompiler::Source source(s);
return v8::ScriptCompiler::Compile(nan_isolate, &source);
}
NAN_INLINE v8::Local<v8::Value> NanRunScript(
v8::Local<NanUnboundScript> script
) {
return script->BindToCurrentContext()->Run();
}
NAN_INLINE v8::Local<v8::Value> NanRunScript(
v8::Local<NanBoundScript> script
) {
return script->Run();
}
#else

@@ -524,2 +905,313 @@ // Node 0.8 and 0.10

typedef v8::InvocationCallback NanFunctionCallback;
# define NanUndefined() v8::Undefined()
# define NanNull() v8::Null()
# define NanTrue() v8::True()
# define NanFalse() v8::False()
# define NanAdjustExternalMemory(amount) \
v8::V8::AdjustAmountOfExternalAllocatedMemory(amount)
# define NanSetTemplate(templ, name, value) templ->Set(name, value)
# define NanGetCurrentContext() v8::Context::GetCurrent()
# if NODE_VERSION_AT_LEAST(0, 8, 0)
# define NanMakeCallback(target, func, argc, argv) \
node::MakeCallback(target, func, argc, argv)
# else
# define NanMakeCallback(target, func, argc, argv) \
do { \
v8::TryCatch try_catch; \
func->Call(target, argc, argv); \
if (try_catch.HasCaught()) { \
v8::FatalException(try_catch); \
} \
} while (0)
# endif
# define NanSymbol(value) v8::String::NewSymbol(value)
template<typename T>
NAN_INLINE v8::Local<T> NanNew() {
return v8::Local<T>::New(T::New());
}
template<typename T>
NAN_INLINE v8::Local<T> NanNew(v8::Handle<T> arg) {
return v8::Local<T>::New(arg);
}
template<typename T>
NAN_INLINE v8::Local<v8::Signature> NanNew(
v8::Handle<v8::FunctionTemplate> receiver
, int argc
, v8::Handle<v8::FunctionTemplate> argv[] = 0) {
return v8::Signature::New(receiver, argc, argv);
}
template<typename T>
NAN_INLINE v8::Local<v8::FunctionTemplate> NanNew(
NanFunctionCallback callback
, v8::Handle<v8::Value> data = v8::Handle<v8::Value>()
, v8::Handle<v8::Signature> signature = v8::Handle<v8::Signature>()) {
return T::New(callback, data, signature);
}
template<typename T>
NAN_INLINE v8::Local<T> NanNew(const v8::Persistent<T> &arg) {
return v8::Local<T>::New(arg);
}
template<typename T, typename P>
NAN_INLINE v8::Local<T> NanNew(P arg) {
return v8::Local<T>::New(T::New(arg));
}
template<typename T, typename P>
NAN_INLINE v8::Local<T> NanNew(P arg, int length) {
return v8::Local<T>::New(T::New(arg, length));
}
template<typename T>
NAN_INLINE v8::Local<v8::RegExp> NanNew(
v8::Handle<v8::String> pattern, v8::RegExp::Flags flags) {
return v8::RegExp::New(pattern, flags);
}
template<typename T>
NAN_INLINE v8::Local<v8::RegExp> NanNew(
v8::Local<v8::String> pattern, v8::RegExp::Flags flags) {
return v8::RegExp::New(pattern, flags);
}
template<typename T, typename P>
NAN_INLINE v8::Local<v8::RegExp> NanNew(
v8::Handle<v8::String> pattern, v8::RegExp::Flags flags) {
return v8::RegExp::New(pattern, flags);
}
template<typename T, typename P>
NAN_INLINE v8::Local<v8::RegExp> NanNew(
v8::Local<v8::String> pattern, v8::RegExp::Flags flags) {
return v8::RegExp::New(pattern, flags);
}
template<>
NAN_INLINE v8::Local<v8::Array> NanNew<v8::Array>() {
return v8::Array::New();
}
template<>
NAN_INLINE v8::Local<v8::Array> NanNew<v8::Array>(int length) {
return v8::Array::New(length);
}
template<>
NAN_INLINE v8::Local<v8::Date> NanNew<v8::Date>(double time) {
return v8::Date::New(time).As<v8::Date>();
}
template<>
NAN_INLINE v8::Local<v8::Date> NanNew<v8::Date>(int time) {
return v8::Date::New(time).As<v8::Date>();
}
typedef v8::Script NanUnboundScript;
typedef v8::Script NanBoundScript;
template<typename T, typename P>
NAN_INLINE v8::Local<T> NanNew(
P s
, const v8::ScriptOrigin& origin
) {
return v8::Script::New(s, const_cast<v8::ScriptOrigin *>(&origin));
}
template<>
NAN_INLINE v8::Local<NanUnboundScript> NanNew<NanUnboundScript>(
v8::Local<v8::String> s
) {
return v8::Script::New(s);
}
NAN_INLINE v8::Local<v8::String> NanNew(
v8::String::ExternalStringResource *resource) {
return v8::String::NewExternal(resource);
}
NAN_INLINE v8::Local<v8::String> NanNew(
v8::String::ExternalAsciiStringResource *resource) {
return v8::String::NewExternal(resource);
}
template<>
NAN_INLINE v8::Local<v8::BooleanObject> NanNew(bool value) {
return v8::BooleanObject::New(value).As<v8::BooleanObject>();
}
template<>
NAN_INLINE v8::Local<v8::StringObject>
NanNew<v8::StringObject, v8::Local<v8::String> >(
v8::Local<v8::String> value) {
return v8::StringObject::New(value).As<v8::StringObject>();
}
template<>
NAN_INLINE v8::Local<v8::StringObject>
NanNew<v8::StringObject, v8::Handle<v8::String> >(
v8::Handle<v8::String> value) {
return v8::StringObject::New(value).As<v8::StringObject>();
}
template<>
NAN_INLINE v8::Local<v8::NumberObject> NanNew<v8::NumberObject>(double val) {
return v8::NumberObject::New(val).As<v8::NumberObject>();
}
template<>
NAN_INLINE v8::Local<v8::Uint32> NanNew<v8::Uint32, int32_t>(int32_t val) {
return v8::Uint32::NewFromUnsigned(val)->ToUint32();
}
template<>
NAN_INLINE v8::Local<v8::Uint32> NanNew<v8::Uint32, uint32_t>(uint32_t val) {
return v8::Uint32::NewFromUnsigned(val)->ToUint32();
}
template<>
NAN_INLINE v8::Local<v8::Int32> NanNew<v8::Int32, int32_t>(int32_t val) {
return v8::Int32::New(val)->ToInt32();
}
template<>
NAN_INLINE v8::Local<v8::Int32> NanNew<v8::Int32, uint32_t>(uint32_t val) {
return v8::Int32::New(val)->ToInt32();
}
template<>
NAN_INLINE v8::Local<v8::String> NanNew<v8::String, uint8_t *>(
uint8_t *arg
, int length) {
uint16_t *warg = new uint16_t[length];
for (int i = 0; i < length; i++) {
warg[i] = arg[i];
}
v8::Local<v8::String> retval = v8::String::New(warg, length);
delete[] warg;
return retval;
}
template<>
NAN_INLINE v8::Local<v8::String> NanNew<v8::String, const uint8_t *>(
const uint8_t *arg
, int length) {
uint16_t *warg = new uint16_t[length];
for (int i = 0; i < length; i++) {
warg[i] = arg[i];
}
v8::Local<v8::String> retval = v8::String::New(warg, length);
delete[] warg;
return retval;
}
template<>
NAN_INLINE v8::Local<v8::String> NanNew<v8::String, uint8_t *>(uint8_t *arg) {
int length = strlen(reinterpret_cast<char *>(arg));
uint16_t *warg = new uint16_t[length];
for (int i = 0; i < length; i++) {
warg[i] = arg[i];
}
v8::Local<v8::String> retval = v8::String::New(warg, length);
delete[] warg;
return retval;
}
template<>
NAN_INLINE v8::Local<v8::String> NanNew<v8::String, const uint8_t *>(
const uint8_t *arg) {
int length = strlen(reinterpret_cast<const char *>(arg));
uint16_t *warg = new uint16_t[length];
for (int i = 0; i < length; i++) {
warg[i] = arg[i];
}
v8::Local<v8::String> retval = v8::String::New(warg, length);
delete[] warg;
return retval;
}
template<>
NAN_INLINE v8::Local<v8::String> NanNew<v8::String>() {
return v8::String::Empty();
}
NAN_INLINE void NanAddGCEpilogueCallback(
v8::GCEpilogueCallback callback
, v8::GCType gc_type_filter = v8::kGCTypeAll) {
v8::V8::AddGCEpilogueCallback(callback, gc_type_filter);
}
NAN_INLINE void NanRemoveGCEpilogueCallback(
v8::GCEpilogueCallback callback) {
v8::V8::RemoveGCEpilogueCallback(callback);
}
NAN_INLINE void NanAddGCPrologueCallback(
v8::GCPrologueCallback callback
, v8::GCType gc_type_filter = v8::kGCTypeAll) {
v8::V8::AddGCPrologueCallback(callback, gc_type_filter);
}
NAN_INLINE void NanRemoveGCPrologueCallback(
v8::GCPrologueCallback callback) {
v8::V8::RemoveGCPrologueCallback(callback);
}
NAN_INLINE void NanGetHeapStatistics(
v8::HeapStatistics *heap_statistics) {
v8::V8::GetHeapStatistics(heap_statistics);
}
template<typename T>
NAN_INLINE void NanAssignPersistent(
v8::Persistent<T>& handle
, v8::Handle<T> obj) {
handle.Dispose();
handle = v8::Persistent<T>::New(obj);
}
template<typename T, typename P>
struct _NanWeakCallbackInfo {
typedef void (*Callback)(v8::Persistent<v8::Value> object, void* parameter);
_NanWeakCallbackInfo(v8::Handle<T> handle, P* param, Callback cb) :
parameter(param)
, callback(cb)
, persistent(v8::Persistent<T>::New(handle)) { }
~_NanWeakCallbackInfo() {
persistent.Dispose();
persistent.Clear();
}
P* const parameter;
Callback const callback;
v8::Persistent<T> persistent;
};
template<typename T, typename P>
class _NanWeakCallbackData {
public:
_NanWeakCallbackData(_NanWeakCallbackInfo<T, P> *info)
: info_(info) { }
NAN_INLINE v8::Local<T> GetValue() const {
return NanNew(info_->persistent);
}
NAN_INLINE P* GetParameter() const { return info_->parameter; }
NAN_INLINE void Revive() const {
info_->persistent.MakeWeak(info_, info_->callback);
}
NAN_INLINE void Dispose() const {
delete info_;
}
private:
_NanWeakCallbackInfo<T, P>* info_;
};
# define NanGetInternalFieldPointer(object, index) \

@@ -529,10 +1221,30 @@ object->GetPointerFromInternalField(index)

object->SetPointerInInternalField(index, value)
# define NAN_WEAK_CALLBACK(type, name) \
void name( \
v8::Persistent<v8::Value> object \
, void *data)
# define NAN_WEAK_CALLBACK_OBJECT object
# define NAN_WEAK_CALLBACK_DATA(type) ((type) data)
// do not use for declaration
# define NAN_WEAK_CALLBACK(name) \
template<typename T, typename P> \
static void name( \
v8::Persistent<v8::Value> object, void *data) { \
_NanWeakCallbackData<T, P> wcbd( \
static_cast<_NanWeakCallbackInfo<T, P>*>(data)); \
_Nan_Weak_Callback_ ## name(wcbd); \
} \
\
template<typename T, typename P> \
NAN_INLINE void _Nan_Weak_Callback_ ## name( \
const _NanWeakCallbackData<T, P> &data)
template<typename T, typename P>
NAN_INLINE void NanMakeWeakPersistent(
v8::Handle<T> handle
, P* parameter
, typename _NanWeakCallbackInfo<T, P>::Callback callback) {
_NanWeakCallbackInfo<T, P> *cbinfo =
new _NanWeakCallbackInfo<T, P>(handle, parameter, callback);
cbinfo->persistent.MakeWeak(cbinfo, callback);
}
# define NanScope() v8::HandleScope scope
# define NanEscapableScope() v8::HandleScope scope
# define NanEscapeScope(val) scope.Close(val)
# define NanLocker() v8::Locker locker

@@ -544,9 +1256,3 @@ # define NanUnlocker() v8::Unlocker unlocker

# define NanReturnEmptyString() return v8::String::Empty()
# define NanInitPersistent(type, name, obj) \
v8::Persistent<type> name = v8::Persistent<type>::New(obj)
# define NanAssignPersistent(type, handle, obj) \
handle = v8::Persistent<type>::New(obj)
# define NanObjectWrapHandle(obj) obj->handle_
# define NanMakeWeak(handle, parameters, callback) \
handle.MakeWeak(parameters, callback)
# define NanObjectWrapHandle(obj) v8::Local<v8::Object>::New(obj->handle_)

@@ -559,30 +1265,25 @@ # define _NAN_ERROR(fun, errmsg) \

NanScope(); \
return v8::ThrowException(_NAN_ERROR(fun, errmsg)); \
return v8::Local<v8::Value>::New( \
v8::ThrowException(_NAN_ERROR(fun, errmsg))); \
} while (0);
template<class T> static NAN_INLINE(v8::Local<T> NanNewLocal(
v8::Handle<T> val
)) {
return v8::Local<T>::New(val);
}
static NAN_INLINE(v8::Handle<v8::Value> NanError(const char* errmsg)) {
NAN_INLINE v8::Local<v8::Value> NanError(const char* errmsg) {
return _NAN_ERROR(v8::Exception::Error, errmsg);
}
static NAN_INLINE(v8::Handle<v8::Value> NanThrowError(const char* errmsg)) {
NAN_INLINE v8::Local<v8::Value> NanThrowError(const char* errmsg) {
_NAN_THROW_ERROR(v8::Exception::Error, errmsg);
}
static NAN_INLINE(v8::Handle<v8::Value> NanThrowError(
NAN_INLINE v8::Local<v8::Value> NanThrowError(
v8::Handle<v8::Value> error
)) {
) {
NanScope();
return v8::ThrowException(error);
return v8::Local<v8::Value>::New(v8::ThrowException(error));
}
static NAN_INLINE(v8::Handle<v8::Value> NanError(
NAN_INLINE v8::Local<v8::Value> NanError(
const char *msg
, const int errorNumber
)) {
) {
v8::Local<v8::Value> err = v8::Exception::Error(v8::String::New(msg));

@@ -594,34 +1295,34 @@ v8::Local<v8::Object> obj = err.As<v8::Object>();

static NAN_INLINE(v8::Handle<v8::Value> NanThrowError(
NAN_INLINE v8::Local<v8::Value> NanThrowError(
const char *msg
, const int errorNumber
)) {
) {
return NanThrowError(NanError(msg, errorNumber));
}
static NAN_INLINE(v8::Handle<v8::Value> NanTypeError(const char* errmsg)) {
NAN_INLINE v8::Local<v8::Value> NanTypeError(const char* errmsg) {
return _NAN_ERROR(v8::Exception::TypeError, errmsg);
}
static NAN_INLINE(v8::Handle<v8::Value> NanThrowTypeError(
NAN_INLINE v8::Local<v8::Value> NanThrowTypeError(
const char* errmsg
)) {
) {
_NAN_THROW_ERROR(v8::Exception::TypeError, errmsg);
}
static NAN_INLINE(v8::Handle<v8::Value> NanRangeError(
NAN_INLINE v8::Local<v8::Value> NanRangeError(
const char* errmsg
)) {
) {
return _NAN_ERROR(v8::Exception::RangeError, errmsg);
}
static NAN_INLINE(v8::Handle<v8::Value> NanThrowRangeError(
NAN_INLINE v8::Local<v8::Value> NanThrowRangeError(
const char* errmsg
)) {
) {
_NAN_THROW_ERROR(v8::Exception::RangeError, errmsg);
}
template<class T> static NAN_INLINE(void NanDisposePersistent(
v8::Persistent<T> &handle
)) {
template<typename T>
NAN_INLINE void NanDisposePersistent(
v8::Persistent<T> &handle) { // NOLINT(runtime/references)
handle.Dispose();

@@ -631,9 +1332,3 @@ handle.Clear();

template<class T> static NAN_DEPRECATED(void NanDispose(
v8::Persistent<T> &handle
)) {
NanDisposePersistent(handle);
}
static NAN_INLINE(v8::Local<v8::Object> NanNewBufferHandle (
NAN_INLINE v8::Local<v8::Object> NanNewBufferHandle (
char *data

@@ -643,51 +1338,49 @@ , size_t length

, void *hint
)) {
return NanNewLocal<v8::Object>(
) {
return NanNew<v8::Object>(
node::Buffer::New(data, length, callback, hint)->handle_);
}
static NAN_INLINE(v8::Local<v8::Object> NanNewBufferHandle (
char *data
NAN_INLINE v8::Local<v8::Object> NanNewBufferHandle (
const char *data
, uint32_t size
)) {
return NanNewLocal<v8::Object>(node::Buffer::New(data, size)->handle_);
) {
#if NODE_MODULE_VERSION >= 0x000B
return NanNew<v8::Object>(node::Buffer::New(data, size)->handle_);
#else
return NanNew<v8::Object>(
node::Buffer::New(const_cast<char*>(data), size)->handle_);
#endif
}
static NAN_INLINE(v8::Local<v8::Object> NanNewBufferHandle (uint32_t size)) {
return NanNewLocal<v8::Object>(node::Buffer::New(size)->handle_);
NAN_INLINE v8::Local<v8::Object> NanNewBufferHandle (uint32_t size) {
return NanNew<v8::Object>(node::Buffer::New(size)->handle_);
}
static NAN_INLINE(void FreeData(char *data, void *hint)) {
NAN_INLINE void FreeData(char *data, void *hint) {
delete[] data;
}
static NAN_INLINE(v8::Local<v8::Object> NanBufferUse(
NAN_INLINE v8::Local<v8::Object> NanBufferUse(
char* data
, uint32_t size
)) {
return NanNewLocal<v8::Object>(
) {
return NanNew<v8::Object>(
node::Buffer::New(data, size, FreeData, NULL)->handle_);
}
template <class TypeName>
static NAN_INLINE(v8::Local<TypeName> NanPersistentToLocal(
const v8::Persistent<TypeName>& persistent
)) {
return NanNewLocal<TypeName>(persistent);
}
static NAN_INLINE(bool NanHasInstance(
NAN_INLINE bool NanHasInstance(
v8::Persistent<v8::FunctionTemplate>& function_template
, v8::Handle<v8::Value> value
)) {
) {
return function_template->HasInstance(value);
}
static NAN_INLINE(v8::Local<v8::Context> NanNewContextHandle(
NAN_INLINE v8::Local<v8::Context> NanNewContextHandle(
v8::ExtensionConfiguration* extensions = NULL
, v8::Handle<v8::ObjectTemplate> tmpl = v8::Handle<v8::ObjectTemplate>()
, v8::Handle<v8::Value> obj = v8::Handle<v8::Value>()
)) {
) {
v8::Persistent<v8::Context> ctx = v8::Context::New(extensions, tmpl, obj);
v8::Local<v8::Context> lctx = NanNewLocal<v8::Context>(ctx);
v8::Local<v8::Context> lctx = NanNew<v8::Context>(ctx);
ctx.Dispose();

@@ -697,4 +1390,23 @@ return lctx;

#endif // node version
NAN_INLINE v8::Local<NanBoundScript> NanCompileScript(
v8::Local<v8::String> s
, const v8::ScriptOrigin& origin
) {
return v8::Script::Compile(s, const_cast<v8::ScriptOrigin *>(&origin));
}
NAN_INLINE v8::Local<NanBoundScript> NanCompileScript(
v8::Local<v8::String> s
) {
return v8::Script::Compile(s);
}
NAN_INLINE v8::Local<v8::Value> NanRunScript(v8::Local<v8::Script> script) {
return script->Run();
}
#endif // NODE_MODULE_VERSION
typedef void (*NanFreeCallback)(char *data, void *hint);
#define NAN_METHOD(name) _NAN_METHOD_RETURN_TYPE name(_NAN_METHOD_ARGS)

@@ -749,10 +1461,10 @@ #define NAN_GETTER(name) \

NanScope();
v8::Local<v8::Object> obj = v8::Object::New();
NanAssignPersistent(v8::Object, handle, obj);
v8::Local<v8::Object> obj = NanNew<v8::Object>();
NanAssignPersistent(handle, obj);
}
NanCallback(const v8::Handle<v8::Function> &fn) {
explicit NanCallback(const v8::Handle<v8::Function> &fn) {
NanScope();
v8::Local<v8::Object> obj = v8::Object::New();
NanAssignPersistent(v8::Object, handle, obj);
v8::Local<v8::Object> obj = NanNew<v8::Object>();
NanAssignPersistent(handle, obj);
SetFunction(fn);

@@ -763,13 +1475,12 @@ }

if (handle.IsEmpty()) return;
handle.Dispose();
handle.Clear();
NanDisposePersistent(handle);
}
NAN_INLINE(void SetFunction(const v8::Handle<v8::Function> &fn)) {
NAN_INLINE void SetFunction(const v8::Handle<v8::Function> &fn) {
NanScope();
NanPersistentToLocal(handle)->Set(NanSymbol("callback"), fn);
NanNew(handle)->Set(NanSymbol("callback"), fn);
}
NAN_INLINE(v8::Local<v8::Function> GetFunction ()) {
return NanPersistentToLocal(handle)->Get(NanSymbol("callback"))
NAN_INLINE v8::Local<v8::Function> GetFunction () {
return NanNew(handle)->Get(NanSymbol("callback"))
.As<v8::Function>();

@@ -780,5 +1491,15 @@ }

NanScope();
#if (NODE_MODULE_VERSION > 0x000B) // 0.11.12+
v8::Local<v8::Function> callback = NanNew(handle)->
Get(NanSymbol("callback")).As<v8::Function>();
node::MakeCallback(
nan_isolate
, nan_isolate->GetCurrentContext()->Global()
, callback
, argc
, argv
);
#else
#if NODE_VERSION_AT_LEAST(0, 8, 0)
v8::Local<v8::Function> callback = NanPersistentToLocal(handle)->
v8::Local<v8::Function> callback = NanNew(handle)->
Get(NanSymbol("callback")).As<v8::Function>();

@@ -794,2 +1515,3 @@ node::MakeCallback(

#endif
#endif
}

@@ -802,9 +1524,13 @@

/* abstract */ class NanAsyncWorker {
public:
NanAsyncWorker (NanCallback *callback) : callback(callback) {
public:
explicit NanAsyncWorker(NanCallback *callback) : callback(callback) {
request.data = this;
errmsg = NULL;
NanScope();
v8::Local<v8::Object> obj = NanNew<v8::Object>();
NanAssignPersistent(persistentHandle, obj);
}
virtual ~NanAsyncWorker () {
virtual ~NanAsyncWorker() {
NanScope();

@@ -820,3 +1546,3 @@

virtual void WorkComplete () {
virtual void WorkComplete() {
NanScope();

@@ -832,6 +1558,4 @@

void SavePersistent(const char *key, v8::Local<v8::Object> &obj) {
NanScope();
v8::Local<v8::Object> handle = NanPersistentToLocal(persistentHandle);
NAN_INLINE void SaveToPersistent(const char *key, v8::Local<v8::Object> &obj) {
v8::Local<v8::Object> handle = NanNew(persistentHandle);
handle->Set(NanSymbol(key), obj);

@@ -841,13 +1565,12 @@ }

v8::Local<v8::Object> GetFromPersistent(const char *key) {
NanScope();
v8::Local<v8::Object> handle = NanPersistentToLocal(persistentHandle);
return handle->Get(NanSymbol(key)).As<v8::Object>();
NanEscapableScope();
v8::Local<v8::Object> handle = NanNew(persistentHandle);
return NanEscapeScope(handle->Get(NanSymbol(key)).As<v8::Object>());
}
virtual void Execute () =0;
virtual void Execute() = 0;
uv_work_t request;
protected:
protected:
v8::Persistent<v8::Object> persistentHandle;

@@ -857,13 +1580,13 @@ NanCallback *callback;

virtual void HandleOKCallback () {
virtual void HandleOKCallback() {
NanScope();
callback->Call(0, NULL);
};
}
virtual void HandleErrorCallback () {
virtual void HandleErrorCallback() {
NanScope();
v8::Local<v8::Value> argv[] = {
v8::Exception::Error(v8::String::New(errmsg))
v8::Exception::Error(NanNew<v8::String>(errmsg))
};

@@ -874,3 +1597,3 @@ callback->Call(1, argv);

NAN_INLINE(void NanAsyncExecute (uv_work_t* req)) {
NAN_INLINE void NanAsyncExecute (uv_work_t* req) {
NanAsyncWorker *worker = static_cast<NanAsyncWorker*>(req->data);

@@ -880,3 +1603,3 @@ worker->Execute();

NAN_INLINE(void NanAsyncExecuteComplete (uv_work_t* req)) {
NAN_INLINE void NanAsyncExecuteComplete (uv_work_t* req) {
NanAsyncWorker* worker = static_cast<NanAsyncWorker*>(req->data);

@@ -887,3 +1610,3 @@ worker->WorkComplete();

NAN_INLINE(void NanAsyncQueueWorker (NanAsyncWorker* worker)) {
NAN_INLINE void NanAsyncQueueWorker (NanAsyncWorker* worker) {
uv_queue_work(

@@ -902,3 +1625,3 @@ uv_default_loop()

// Doesn't check for padding at the end. Can be 1-2 bytes over.
static NAN_INLINE(size_t _nan_base64_decoded_size_fast(size_t size)) {
NAN_INLINE size_t _nan_base64_decoded_size_fast(size_t size) {
size_t remainder = size % 4;

@@ -920,7 +1643,7 @@

template <typename TypeName>
static NAN_INLINE(size_t _nan_base64_decoded_size(
const TypeName* src
template<typename T>
NAN_INLINE size_t _nan_base64_decoded_size(
const T* src
, size_t size
)) {
) {
if (size == 0)

@@ -959,6 +1682,6 @@ return 0;

template <typename TypeName> static size_t _nan_base64_decode(
template<typename T> static size_t _nan_base64_decode(
char* buf
, size_t len
, const TypeName* src
, const T* src
, const size_t srcLen

@@ -968,6 +1691,6 @@ ) {

char* dstEnd = buf + len;
const TypeName* srcEnd = src + srcLen;
const T* srcEnd = src + srcLen;
while (src < srcEnd && dst < dstEnd) {
int remaining = srcEnd - src;
ptrdiff_t remaining = srcEnd - src;
char a, b, c, d;

@@ -1005,3 +1728,3 @@

template <typename TypeName> unsigned _nan_hex2bin(TypeName c) {
template<typename T> unsigned _nan_hex2bin(T c) {
if (c >= '0' && c <= '9') return c - '0';

@@ -1013,6 +1736,6 @@ if (c >= 'A' && c <= 'F') return 10 + (c - 'A');

template <typename TypeName> static size_t _nan_hex_decode(
template<typename T> static size_t _nan_hex_decode(
char* buf
, size_t len
, const TypeName* src
, const T* src
, const size_t srcLen

@@ -1043,3 +1766,3 @@ ) {

assert(val->IsString());
v8::Local<v8::String> str = NanNewLocal(val.As<v8::String>());
v8::Local<v8::String> str = NanNew<v8::String>(val.As<v8::String>());

@@ -1068,3 +1791,3 @@ if (str->IsExternalAscii()) {

static NAN_INLINE(void* NanRawString(
NAN_INLINE void* NanRawString(
v8::Handle<v8::Value> from

@@ -1076,3 +1799,3 @@ , enum Nan::Encoding encoding

, int flags
)) {
) {
NanScope();

@@ -1096,7 +1819,7 @@

char *to = (char*)buf;
char *to = static_cast<char *>(buf);
switch(encoding) {
switch (encoding) {
case Nan::ASCII:
#if NODE_MODULE_VERSION < 0x0C
#if NODE_MODULE_VERSION < 0x000C
sz_ = toStr->Length();

@@ -1110,3 +1833,3 @@ if (to == NULL) {

datalen
, toStr->WriteAscii(to, 0, sz_ + term_len, flags));
, toStr->WriteAscii(to, 0, static_cast<int>(sz_ + term_len), flags));
return to;

@@ -1122,9 +1845,8 @@ #endif

}
#if NODE_MODULE_VERSION < 0x0C
// TODO(isaacs): THIS IS AWFUL!!!
// AGREE(kkoopa)
#if NODE_MODULE_VERSION < 0x000C
{
uint16_t* twobytebuf = new uint16_t[sz_ + term_len];
size_t len = toStr->Write(twobytebuf, 0, sz_ + term_len, flags);
size_t len = toStr->Write(twobytebuf, 0,
static_cast<int>(sz_ + term_len), flags);

@@ -1147,3 +1869,3 @@ for (size_t i = 0; i < sz_ + term_len && i < len + term_len; i++) {

, 0
, sz_ + term_len
, static_cast<int>(sz_ + term_len)
, flags));

@@ -1161,3 +1883,5 @@ return to;

datalen
, toStr->WriteUtf8(to, sz_ + term_len, NULL, flags) - term_len);
, toStr->WriteUtf8(to, static_cast<int>(sz_ + term_len)
, NULL, flags)
- term_len);
return to;

@@ -1193,3 +1917,3 @@ case Nan::BASE64:

, 0
, sz_ + term_len
, static_cast<int>(sz_ + term_len)
, flags);

@@ -1223,16 +1947,4 @@ NanSetPointerSafe<size_t>(datalen, bc);

static NAN_INLINE(char* NanFromV8String(
NAN_INLINE char* NanCString(
v8::Handle<v8::Value> from
, enum Nan::Encoding encoding = Nan::UTF8
, size_t *datalen = NULL
, char *buf = NULL
, size_t buflen = 0
, int flags =
v8::String::NO_NULL_TERMINATION | v8::String::HINT_MANY_WRITES_EXPECTED
)) {
return (char *) NanRawString(from, encoding, datalen, buf, buflen, flags);
}
static NAN_INLINE(char* NanCString(
v8::Handle<v8::Value> from
, size_t *datalen

@@ -1242,6 +1954,8 @@ , char *buf = NULL

, int flags = v8::String::NO_OPTIONS
)) {
return (char *) NanRawString(from, Nan::UTF8, datalen, buf, buflen, flags);
) {
return static_cast<char *>(
NanRawString(from, Nan::UTF8, datalen, buf, buflen, flags)
);
}
#endif
#endif // NAN_H_
+1
-1
package.json
{
"name": "nan",
"version": "0.8.0",
"version": "1.0.0",
"description": "Native Abstractions for Node.js: C++ header for Node 0.8->0.12 compatibility",

@@ -5,0 +5,0 @@ "main": "include_dirs.js",

+214
-85
README.md

@@ -6,3 +6,3 @@ Native Abstractions for Node.js

***Current version: 0.8.0*** *(See [nan.h](https://github.com/rvagg/nan/blob/master/nan.h) for complete ChangeLog)*
***Current version: 1.0.0*** *(See [nan.h](https://github.com/rvagg/nan/blob/master/nan.h) for complete ChangeLog)*

@@ -23,2 +23,22 @@ [![NPM](https://nodei.co/npm/nan.png?downloads=true)](https://nodei.co/npm/nan/) [![NPM](https://nodei.co/npm-dl/nan.png?months=6)](https://nodei.co/npm/nan/)

### May-2013: Major changes for V8 3.25 / Node 0.11.13
Node 0.11.11 and 0.11.12 were both broken releases for native add-ons, you simply can't properly compile against either of them for different reasons. But we now have a 0.11.13 release that jumps a couple of versions of V8 ahead and includes some more, major (traumatic) API changes.
Because we are now nearing Node 0.12 and estimate that the version of V8 we are using in Node 0.11.13 will be close to the API we get for 0.12, we have taken the opportunity to not only *fix* NAN for 0.11.13 but make some major changes to improve the NAN API.
We have **removed support for Node 0.11 versions prior to 0.11.13**, (although our tests are still passing for 0.11.10). As usual, our tests are run against (and pass) the last 5 versions of Node 0.8 and Node 0.10. We also include Node 0.11.13 obviously.
The major change is something that [Benjamin Byholm](kkoopa) has put many hours in to. We now have a fantastic new `NanNew<T>(args)` interface for creating new `Local`s, this replaces `NanNewLocal()` and much more. If you look in [./nan.h](nan.h) you'll see a large number of overloaded versions of this method. In general you should be able to `NanNew<Type>(arguments)` for any type you want to make a `Local` from. This includes `Persistent` types, so we now have a `Local<T> NanNew(const Persistent<T> arg)` to replace `NanPersistentToLocal()`.
We also now have `NanUndefined()`, `NanNull()`, `NanTrue()` and `NanFalse()`. Mainly because of the new requirement for an `Isolate` argument for each of the native V8 versions of this.
V8 has now introduced an `EscapableHandleScope` from which you `scope.Escape(Local<T> value)` to *return* a value from a one scope to another. This replaces the standard `HandleScope` and `scope.Close(Local<T> value)`, although `HandleScope` still exists for when you don't need to return a handle to the caller. For NAN we are exposing it as `NanEscapableScope()` and `NanEscapeScope()`, while `NanScope()` is still how you create a new scope that doesn't need to return handles. For older versions of Node/V8, it'll still map to the older `HandleScope` functionality.
`NanFromV8String()` was deprecated and has now been removed. You should use `NanCString()` or `NanRawString()` instead.
Because `node::MakeCallback()` now takes an `Isolate`, and because it doesn't exist in older versions of Node, we've introduced `NanMakeCallabck()`. You should *always* use this when calling a JavaScript function from C++.
There's lots more, check out the Changelog in nan.h or look through [#86](https://github.com/rvagg/nan/pull/86) for all the gory details.
### Dec-2013: NanCString and NanRawString

@@ -47,3 +67,3 @@

Pull in the path to **NAN** in your *binding.gyp* so that you can use `#include "nan.h"` in your *.cpp* files:
Pull in the path to **NAN** in your *binding.gyp* so that you can use `#include <nan.h>` in your *.cpp* files:

@@ -72,13 +92,15 @@ ``` python

#include <node.h>
#include "nan.h"
#include <nan.h>
// ...
using namespace v8;
using v8::FunctionTemplate;
using v8::Handle;
using v8::Object;
void InitAll(Handle<Object> exports) {
exports->Set(NanSymbol("calculateSync"),
FunctionTemplate::New(CalculateSync)->GetFunction());
NanNew<FunctionTemplate>(CalculateSync)->GetFunction());
exports->Set(NanSymbol("calculateAsync"),
FunctionTemplate::New(CalculateAsync)->GetFunction());
NanNew<FunctionTemplate>(CalculateAsync)->GetFunction());
}

@@ -92,3 +114,3 @@

#include <node.h>
#include "nan.h"
#include <nan.h>

@@ -101,7 +123,7 @@ NAN_METHOD(CalculateSync);

#include <node.h>
#include "nan.h"
#include "sync.h"
#include <nan.h>
#include "./sync.h"
// ...
using namespace v8;
using v8::Number;

@@ -116,3 +138,3 @@ // Simple synchronous access to the `Estimate()` function

NanReturnValue(Number::New(est));
NanReturnValue(NanNew<Number>(est));
}

@@ -124,8 +146,12 @@ ```

#include <node.h>
#include "nan.h"
#include "async.h"
#include <nan.h>
#include "./async.h"
// ...
using namespace v8;
using v8::Function;
using v8::Local;
using v8::Null;
using v8::Number;
using v8::Value;

@@ -153,4 +179,4 @@ class PiWorker : public NanAsyncWorker {

Local<Value> argv[] = {
Local<Value>::New(Null())
, Number::New(estimate)
NanNew(NanNull())
, NanNew<Number>(estimate)
};

@@ -196,4 +222,8 @@

* <a href="#api_nan_deprecated"><b><code>NAN_DEPRECATED</code></b></a>
* <a href="#api_nan_inline"><b><code>NAN_INLINE</code></b></a>
* <a href="#api_nan_new_local"><b><code>NanNewLocal</code></b></a>
* <a href="#api_nan_inline"><b><code>NAN_INLINE</code></b></a>
* <a href="#api_nan_new"><b><code>NanNew</code></b></a>
* <a href="#api_nan_undefined"><b><code>NanUndefined</code></b></a>
* <a href="#api_nan_null"><b><code>NanNull</code></b></a>
* <a href="#api_nan_true"><b><code>NanTrue</code></b></a>
* <a href="#api_nan_false"><b><code>NanFalse</code></b></a>
* <a href="#api_nan_return_value"><b><code>NanReturnValue</code></b></a>

@@ -204,2 +234,4 @@ * <a href="#api_nan_return_undefined"><b><code>NanReturnUndefined</code></b></a>

* <a href="#api_nan_scope"><b><code>NanScope</code></b></a>
* <a href="#api_nan_escapable_scope"><b><code>NanEscapableScope</code></b></a>
* <a href="#api_nan_escape_scope"><b><code>NanEscapeScope</code></b></a>
* <a href="#api_nan_locker"><b><code>NanLocker</code></b></a>

@@ -210,3 +242,2 @@ * <a href="#api_nan_unlocker"><b><code>NanUnlocker</code></b></a>

* <a href="#api_nan_object_wrap_handle"><b><code>NanObjectWrapHandle</code></b></a>
* <a href="#api_nan_make_weak"><b><code>NanMakeWeak</code></b></a>
* <a href="#api_nan_symbol"><b><code>NanSymbol</code></b></a>

@@ -217,3 +248,2 @@ * <a href="#api_nan_get_pointer_safe"><b><code>NanGetPointerSafe</code></b></a>

* <a href="#api_nan_c_string"><b><code>NanCString</code></b></a>
* <a href="#api_nan_from_v8_string"><b><code>NanFromV8String</code></b></a>
* <a href="#api_nan_boolean_option_value"><b><code>NanBooleanOptionValue</code></b></a>

@@ -226,7 +256,17 @@ * <a href="#api_nan_uint32_option_value"><b><code>NanUInt32OptionValue</code></b></a>

* <a href="#api_nan_new_context_handle"><b><code>NanNewContextHandle</code></b></a>
* <a href="#api_nan_get_current_context"><b><code>NanGetCurrentContext</code></b></a>
* <a href="#api_nan_has_instance"><b><code>NanHasInstance</code></b></a>
* <a href="#api_nan_persistent_to_local"><b><code>NanPersistentToLocal</code></b></a>
* <a href="#api_nan_dispose_persistent"><b><code>NanDisposePersistent</code></b></a>
* <a href="#api_nan_assign_persistent"><b><code>NanAssignPersistent</code></b></a>
* <a href="#api_nan_init_persistent"><b><code>NanInitPersistent</code></b></a>
* <a href="#api_nan_make_weak_persistent"><b><code>NanMakeWeakPersistent</code></b></a>
* <a href="#api_nan_set_template"><b><code>NanSetTemplate</code></b></a>
* <a href="#api_nan_make_callback"><b><code>NanMakeCallback</code></b></a>
* <a href="#api_nan_compile_script"><b><code>NanCompileScript</code></b></a>
* <a href="#api_nan_run_script"><b><code>NanRunScript</code></b></a>
* <a href="#api_nan_adjust_external_memory"><b><code>NanAdjustExternalMemory</code></b></a>
* <a href="#api_nan_add_gc_epilogue_callback"><b><code>NanAddGCEpilogueCallback</code></b></a>
* <a href="#api_nan_add_gc_prologue_callback"><b><code>NanAddGCPrologueCallback</code></b></a>
* <a href="#api_nan_remove_gc_epilogue_callback"><b><code>NanRemoveGCEpilogueCallback</code></b></a>
* <a href="#api_nan_remove_gc_prologue_callback"><b><code>NanRemoveGCPrologueCallback</code></b></a>
* <a href="#api_nan_get_heap_statistics"><b><code>NanGetHeapStatistics</code></b></a>
* <a href="#api_nan_callback"><b><code>NanCallback</code></b></a>

@@ -342,13 +382,15 @@ * <a href="#api_nan_async_worker"><b><code>NanAsyncWorker</code></b></a>

<a name="api_nan_weak_callback"></a>
### NAN_WEAK_CALLBACK(type, cbname)
### NAN_WEAK_CALLBACK(cbname)
Use `NAN_WEAK_CALLBACK` to declare your V8 WeakReference callbacks. There is an object argument accessible through `NAN_WEAK_CALLBACK_OBJECT`. The `type` argument gives the type of the `data` argument, accessible through `NAN_WEAK_CALLBACK_DATA(type)`.
Use `NAN_WEAK_CALLBACK` to define your V8 WeakReference callbacks. Do not use for declaration. There is an argument object `const _NanWeakCallbackData<T, P> &data` allowing access to the weak object and the supplied parameter through its `GetValue` and `GetParameter` methods.
```c++
static NAN_WEAK_CALLBACK(BufferReference*, WeakCheck) {
if (NAN_WEAK_CALLBACK_DATA(BufferReference*)->noLongerNeeded_) {
delete NAN_WEAK_CALLBACK_DATA(BufferReference*);
NAN_WEAK_CALLBACK(weakCallback) {
int *parameter = data.GetParameter();
NanMakeCallback(NanGetCurrentContext()->Global(), data.GetValue(), 0, NULL);
if ((*parameter)++ == 0) {
data.Revive();
} else {
// Still in use, revive, prevent GC
NanMakeWeak(NAN_WEAK_CALLBACK_OBJECT, NAN_WEAK_CALLBACK_DATA(BufferReference*), &WeakCheck);
delete parameter;
data.Dispose();
}

@@ -359,7 +401,7 @@ }

<a name="api_nan_deprecated"></a>
### NAN_DEPRECATED(declarator)
Declares a function as deprecated. Identical to `V8_DEPRECATED`.
### NAN_DEPRECATED
Declares a function as deprecated.
```c++
static NAN_DEPRECATED(NAN_METHOD(foo)) {
static NAN_DEPRECATED NAN_METHOD(foo) {
...

@@ -370,7 +412,7 @@ }

<a name="api_nan_inline"></a>
### NAN_INLINE(declarator)
Inlines a function. Identical to `V8_INLINE`.
### NAN_INLINE
Inlines a function.
```c++
static NAN_INLINE(int foo(int bar)) {
NAN_INLINE int foo(int bar) {
...

@@ -380,12 +422,40 @@ }

<a name="api_nan_new_local"></a>
### NanNewLocal&lt;T&gt;(Handle&lt;Value&gt;)
<a name="api_nan_new"></a>
### Local&lt;T&gt; NanNew&lt;T&gt;( ... )
Use `NanNewLocal` in place of `v8::Local<T>::New(...)` as this function
requires an `isolate` argument in recent versions of V8 but not in older versions.
Use `NanNew` to construct almost all v8 objects and make new local handles.
```c++
NanNewLocal<v8::Value>(v8::Null())
Local<String> s = NanNew<String>("value");
...
Persistent<Object> o;
...
Local<Object> lo = NanNew(o);
```
<a name="api_nan_undefined"></a>
### Handle&lt;Primitive&gt; NanUndefined()
Use instead of `Undefined()`
<a name="api_nan_null"></a>
### Handle&lt;Primitive&gt; NanNull()
Use instead of `Null()`
<a name="api_nan_true"></a>
### Handle&lt;Primitive&gt; NanTrue()
Use instead of `True()`
<a name="api_nan_false"></a>
### Handle&lt;Primitive&gt; NanFalse()
Use instead of `False()`
<a name="api_nan_return_value"></a>

@@ -400,3 +470,3 @@ ### NanReturnValue(Handle&lt;Value&gt;)

NanReturnValue(String::New("FooBar!"));
NanReturnValue(NanNew<String>("FooBar!"));
}

@@ -455,6 +525,23 @@ ```

NanReturnValue(String::New("FooBar!"));
NanReturnValue(NanNew<String>("FooBar!"));
}
```
<a name="api_nan_escapable_scope"></a>
### NanEscapableScope()
The separation of handle scopes into escapable and inescapable scopes makes `NanEscapableScope()` necessary, use it in place of `HandleScope scope` when you later wish to `Close()` the scope:
```c++
Handle<String> Foo::Bar() {
NanEscapableScope();
return NanEscapeScope(NanNew<String>("FooBar!"));
}
```
<a name="api_nan_esacpe_scope"></a>
### Local&lt;T&gt; NanEscapeScope(Handle&lt;T&gt; value);
Use together with `NanEscapableScope` to escape the scope. Corresponds to `HandleScope::Close` or `EscapableHandleScope::Escape`.
<a name="api_nan_locker"></a>

@@ -514,14 +601,9 @@ ### NanLocker()

```c++
NanObjectWrapHandle(iterator)->Get(String::NewSymbol("end"))
NanObjectWrapHandle(iterator)->Get(NanSymbol("end"))
```
<a name="api_nan_make_weak"></a>
### NanMakeWeak(Persistent&lt;T&gt;, parameter, callback)
Make a persistent reference weak.
<a name="api_nan_symbol"></a>
### String NanSymbol(char *)
This isn't strictly about compatibility, it's just an easier way to create string symbol objects (i.e. `String::NewSymbol(x)`), for getting and setting object properties, or names of objects.
Use to create string symbol objects (i.e. `v8::String::NewSymbol(x)`), for getting and setting object properties, or names of objects.

@@ -553,3 +635,3 @@ ```c++

A helper for setting optional argument pointers. If the pointer is `NULL`, the function simply return `false`. Otherwise, the value is assigned to the variable the pointer points to.
A helper for setting optional argument pointers. If the pointer is `NULL`, the function simply returns `false`. Otherwise, the value is assigned to the variable the pointer points to.

@@ -592,12 +674,2 @@ ```c++

<a name="api_nan_from_v8_string"></a>
### char* NanFromV8String(Handle&lt;Value&gt;[, enum Nan::Encoding, size_t *, char *, size_t, int])
A convenience function that uses `NanRawString()` to convert a V8 `String` to a `char*`. Defaults to UTF8 encoding and no null-termination.
```c++
size_t count;
char* name = NanFromV8String(args[0]);
```
<a name="api_nan_boolean_option_value"></a>

@@ -659,3 +731,3 @@ ### bool NanBooleanOptionValue(Handle&lt;Value&gt;, Handle&lt;String&gt;[, bool])

Can also be supplied with a `NAN_WEAK_CALLBACK` and a hint for the garbage collector, when dealing with weak references.
Can also be supplied with a `NanFreeCallback` and a hint for the garbage collector.

@@ -679,13 +751,2 @@ <a name="api_nan_buffer_use"></a>

<a name="api_nan_persistent_to_local"></a>
### Local&lt;Type&gt; NanPersistentToLocal(Persistent&lt;Type&gt;&)
Aside from `FunctionCallbackInfo`, the biggest and most painful change to V8 in Node 0.11 is the many restrictions now placed on `Persistent` handles. They are difficult to assign and difficult to fetch the original value out of.
Use `NanPersistentToLocal` to convert a `Persistent` handle back to a `Local` handle.
```c++
Local<Object> handle = NanPersistentToLocal(persistentHandle);
```
<a href="#api_nan_new_context_handle">

@@ -696,3 +757,3 @@ ### Local&lt;Context&gt; NanNewContextHandle([ExtensionConfiguration*, Handle&lt;ObjectTemplate&gt;, Handle&lt;Value&gt;])

```c++
Local<FunctionTemplate> ftmpl = FunctionTemplate::New();
Local<FunctionTemplate> ftmpl = NanNew<FunctionTemplate>();
Local<ObjectTemplate> otmpl = ftmpl->InstanceTemplate();

@@ -702,2 +763,11 @@ Local<Context> ctx = NanNewContextHandle(NULL, otmpl);

<a href="#api_nan_get_current_context">
### Local<Context> NanGetCurrentContext()
Gets the current context.
```c++
Local<Context> ctx = NanGetCurrentContext();
```
<a name="api_nan_dispose_persistent"></a>

@@ -724,3 +794,3 @@ ### void NanDisposePersistent(Persistent&lt;T&gt; &)

Local<Object> obj = Object::New();
Local<Object> obj = NanNew<Object>();
obj->Set(NanSymbol("key"), keyHandle); // where keyHandle might be a Local<String>

@@ -730,13 +800,72 @@ NanAssignPersistent(Object, persistentHandle, obj)

<a name="api_nan_init_persistent"></a>
### NanInitPersistent(type, name, object)
<a name="api_nan_make_weak_persistent"></a>
### NanMakeWeakPersistent(Handle&lt;T&gt; handle, P* parameter, _NanWeakCallbackInfo&lt;T, P&gt;::Callback callback)
User `NanInitPersistent` to declare and initialize a new `Persistent` with the supplied object. The assignment operator for `Persistent` is no longer public in Node 0.11, so this macro makes it easier to declare and initializing a new `Persistent`. See <a href="#api_nan_assign_persistent"><b><code>NanAssignPersistent</code></b></a> for more information.
Creates a weak persistent handle with the supplied parameter and `NAN_WEAK_CALLBACK`. The callback has to be fully specialized to work on all versions of Node.
```c++
Local<Object> obj = Object::New();
obj->Set(NanSymbol("key"), keyHandle); // where keyHandle might be a Local<String>
NanInitPersistent(Object, persistentHandle, obj);
NAN_WEAK_CALLBACK(weakCallback) {
...
}
Local<Function> func;
...
int *parameter = new int(0);
NanMakeWeakPersistent(func, parameter, &weakCallback<Function, int>);
```
<a name="api_nan_set_template"></a>
### NanSetTemplate(templ, name, value)
Use to add properties on object and function templates.
<a name="api_nan_make_callback"></a>
### NanMakeCallback(target, func, argc, argv)
Use instead of `node::MakeCallback` to call javascript functions. This is the only proper way of calling functions.
<a name="api_nan_compile_script"></a>
### NanCompileScript(Handle<String> s [, const ScriptOrigin&amp; origin])
Use to create new scripts bound to the current context.
<a name="api_nan_run_script"></a>
### NanRunScript(script)
Use to run both bound and unbound scripts.
<a name="api_nan_adjust_external_memory"></a>
### NanAdjustExternalMemory(int change_in_bytes)
Simply does `AdjustAmountOfExternalAllocatedMemory`
<a name="api_nan_add_gc_epilogue_callback"></a>
### NanAddGCEpilogueCallback(GCEpilogueCallback callback, GCType gc_type_filter=kGCTypeAll)
Simply does `AddGCEpilogueCallback`
<a name="api_nan_add_gc_prologue_callback"></a>
### NanAddGCPrologueCallback(GCPrologueCallback callback, GCType gc_type_filter=kGCTypeAll)
Simply does `AddGCPrologueCallback`
<a name="api_nan_remove_gc_epilogue_callback"></a>
### NanRemoveGCEpilogueCallback(GCEpilogueCallback callback)
Simply does `RemoveGCEpilogueCallback`
<a name="api_nan_add_gc_prologue_callback"></a>
### NanRemoveGCPrologueCallback(GCPrologueCallback callback)
Simply does `RemoveGCPrologueCallback`
<a name="api_nan_get_heap_statistics"></a>
### NanGetHeapStatistics(HeapStatistics *heap_statistics)
Simply does `GetHeapStatistics`
<a name="api_nan_callback"></a>

@@ -762,3 +891,3 @@ ### NanCallback

Handle<Value> argv[] = {
Exception::Error(String::New("fail!"))
NanError(NanNew<String>("fail!"))
};

@@ -769,4 +898,4 @@ callback->Call(1, argv);

Handle<Value> argv[] = {
Null(),
String::New("w00t!")
NanNull(),
NanNew<String>("w00t!")
};

@@ -802,3 +931,3 @@ callback->Call(2, argv);

// You must implement this to do some async work. If there is an
// error then allocate `errmsg` to to a message and the callback will
// error then allocate `errmsg` to a message and the callback will
// be passed that string in an Error object

@@ -848,4 +977,4 @@ virtual void Execute ();

Copyright (c) 2013 NAN contributors (listed above).
Copyright (c) 2014 NAN contributors (listed above).
Native Abstractions for Node.js is licensed under an MIT +no-false-attribs license. All rights not explicitly granted in the MIT license are reserved. See the included LICENSE file for more details.
.dntrc

Sorry, the diff of this file is not supported yet