diff options
Diffstat (limited to 'signaling-server/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/node_modules/nan/nan.h')
| -rw-r--r-- | signaling-server/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/node_modules/nan/nan.h | 1910 |
1 files changed, 1910 insertions, 0 deletions
diff --git a/signaling-server/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/node_modules/nan/nan.h b/signaling-server/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/node_modules/nan/nan.h new file mode 100644 index 0000000..bc544f5 --- /dev/null +++ b/signaling-server/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/node_modules/nan/nan.h @@ -0,0 +1,1910 @@ +/********************************************************************************** + * NAN - Native Abstractions for Node.js + * + * Copyright (c) 2014 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> + * + * MIT +no-false-attribs License <https://github.com/rvagg/nan/blob/master/LICENSE> + * + * 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 + * - NanDispose -> NanDisposePersistent, deprecate NanDispose + * - Extract _NAN_*_RETURN_TYPE, pull up NAN_*() + * + * * 0.7.1 Jan 9 2014 + * - Fixes to work against debug builds of Node + * - Safer NanPersistentToLocal (avoid reinterpret_cast) + * - Speed up common NanRawString case by only extracting flattened string when necessary + * + * * 0.7.0 Dec 17 2013 + * - New no-arg form of NanCallback() constructor. + * - NanCallback#Call takes Handle rather than Local + * - Removed deprecated NanCallback#Run method, use NanCallback#Call instead + * - Split off _NAN_*_ARGS_TYPE from _NAN_*_ARGS + * - Restore (unofficial) Node 0.6 compatibility at NanCallback#Call() + * - Introduce NanRawString() for char* (or appropriate void*) from v8::String + * (replacement for NanFromV8String) + * - Introduce NanCString() for null-terminated char* from v8::String + * + * * 0.6.0 Nov 21 2013 + * - Introduce NanNewLocal<T>(v8::Handle<T> value) for use in place of + * v8::Local<T>::New(...) since v8 started requiring isolate in Node 0.11.9 + * + * * 0.5.2 Nov 16 2013 + * - Convert SavePersistent and GetFromPersistent in NanAsyncWorker from protected and public + * + * * 0.5.1 Nov 12 2013 + * - Use node::MakeCallback() instead of direct v8::Function::Call() + * + * * 0.5.0 Nov 11 2013 + * - Added @TooTallNate as collaborator + * - New, much simpler, "include_dirs" for binding.gyp + * - Added full range of NAN_INDEX_* macros to match NAN_PROPERTY_* macros + * + * * 0.4.4 Nov 2 2013 + * - Isolate argument from v8::Persistent::MakeWeak removed for 0.11.8+ + * + * * 0.4.3 Nov 2 2013 + * - Include node_object_wrap.h, removed from node.h for Node 0.11.8. + * + * * 0.4.2 Nov 2 2013 + * - Handle deprecation of v8::Persistent::Dispose(v8::Isolate* isolate)) for + * Node 0.11.8 release. + * + * * 0.4.1 Sep 16 2013 + * - Added explicit `#include <uv.h>` as it was removed from node.h for v0.11.8 + * + * * 0.4.0 Sep 2 2013 + * - Added NAN_INLINE and NAN_DEPRECATED and made use of them + * - Added NanError, NanTypeError and NanRangeError + * - Cleaned up code + * + * * 0.3.2 Aug 30 2013 + * - Fix missing scope declaration in GetFromPersistent() and SaveToPersistent + * in NanAsyncWorker + * + * * 0.3.1 Aug 20 2013 + * - fix "not all control paths return a value" compile warning on some platforms + * + * * 0.3.0 Aug 19 2013 + * - Made NAN work with NPM + * - Lots of fixes to NanFromV8String, pulling in features from new Node core + * - Changed node::encoding to Nan::Encoding in NanFromV8String to unify the API + * - Added optional error number argument for NanThrowError() + * - Added NanInitPersistent() + * - Added NanReturnNull() and NanReturnEmptyString() + * - Added NanLocker and NanUnlocker + * - Added missing scopes + * - Made sure to clear disposed Persistent handles + * - Changed NanAsyncWorker to allocate error messages on the heap + * - Changed NanThrowError(Local<Value>) to NanThrowError(Handle<Value>) + * - Fixed leak in NanAsyncWorker when errmsg is used + * + * * 0.2.2 Aug 5 2013 + * - Fixed usage of undefined variable with node::BASE64 in NanFromV8String() + * + * * 0.2.1 Aug 5 2013 + * - Fixed 0.8 breakage, node::BUFFER encoding type not available in 0.8 for + * NanFromV8String() + * + * * 0.2.0 Aug 5 2013 + * - Added NAN_PROPERTY_GETTER, NAN_PROPERTY_SETTER, NAN_PROPERTY_ENUMERATOR, + * NAN_PROPERTY_DELETER, NAN_PROPERTY_QUERY + * - Extracted _NAN_METHOD_ARGS, _NAN_GETTER_ARGS, _NAN_SETTER_ARGS, + * _NAN_PROPERTY_GETTER_ARGS, _NAN_PROPERTY_SETTER_ARGS, + * _NAN_PROPERTY_ENUMERATOR_ARGS, _NAN_PROPERTY_DELETER_ARGS, + * _NAN_PROPERTY_QUERY_ARGS + * - Added NanGetInternalFieldPointer, NanSetInternalFieldPointer + * - Added NAN_WEAK_CALLBACK, NAN_WEAK_CALLBACK_OBJECT, + * NAN_WEAK_CALLBACK_DATA, NanMakeWeak + * - Renamed THROW_ERROR to _NAN_THROW_ERROR + * - Added NanNewBufferHandle(char*, size_t, node::smalloc::FreeCallback, void*) + * - Added NanBufferUse(char*, uint32_t) + * - Added NanNewContextHandle(v8::ExtensionConfiguration*, + * v8::Handle<v8::ObjectTemplate>, v8::Handle<v8::Value>) + * - Fixed broken NanCallback#GetFunction() + * - Added optional encoding and size arguments to NanFromV8String() + * - Added NanGetPointerSafe() and NanSetPointerSafe() + * - Added initial test suite (to be expanded) + * - Allow NanUInt32OptionValue to convert any Number object + * + * * 0.1.0 Jul 21 2013 + * - Added `NAN_GETTER`, `NAN_SETTER` + * - Added `NanThrowError` with single Local<Value> argument + * - Added `NanNewBufferHandle` with single uint32_t argument + * - Added `NanHasInstance(Persistent<FunctionTemplate>&, Handle<Value>)` + * - Added `Local<Function> NanCallback#GetFunction()` + * - Added `NanCallback#Call(int, Local<Value>[])` + * - Deprecated `NanCallback#Run(int, Local<Value>[])` in favour of Call + * + * See https://github.com/rvagg/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 <string.h> + +#if defined(__GNUC__) && !defined(DEBUG) +# define NAN_INLINE inline __attribute__((always_inline)) +#elif defined(_MSC_VER) && !defined(DEBUG) +# define NAN_INLINE __forceinline +#else +# define NAN_INLINE inline +#endif + +#if defined(__GNUC__) && !V8_DISABLE_DEPRECATIONS +# define NAN_DEPRECATED __attribute__((deprecated)) +#elif defined(_MSC_VER) && !V8_DISABLE_DEPRECATIONS +# define NAN_DEPRECATED __declspec(deprecated) +#else +# define NAN_DEPRECATED +#endif + +// some generic helpers + +template<typename T> NAN_INLINE bool NanSetPointerSafe( + T *var + , T val +) { + if (var) { + *var = val; + return true; + } else { + return false; + } +} + +template<typename T> NAN_INLINE T NanGetPointerSafe( + T *var + , T fallback = reinterpret_cast<T>(0) +) { + if (var) { + return *var; + } else { + return fallback; + } +} + +NAN_INLINE bool NanBooleanOptionValue( + v8::Local<v8::Object> optionsObj + , v8::Handle<v8::String> opt, bool def +) { + if (def) { + return optionsObj.IsEmpty() + || !optionsObj->Has(opt) + || optionsObj->Get(opt)->BooleanValue(); + } else { + return !optionsObj.IsEmpty() + && optionsObj->Has(opt) + && optionsObj->Get(opt)->BooleanValue(); + } +} + +NAN_INLINE bool NanBooleanOptionValue( + v8::Local<v8::Object> optionsObj + , v8::Handle<v8::String> opt +) { + return NanBooleanOptionValue(optionsObj, opt, false); +} + +NAN_INLINE uint32_t NanUInt32OptionValue( + v8::Local<v8::Object> optionsObj + , v8::Handle<v8::String> opt + , uint32_t def +) { + return !optionsObj.IsEmpty() + && optionsObj->Has(opt) + && optionsObj->Get(opt)->IsNumber() + ? optionsObj->Get(opt)->Uint32Value() + : def; +} + +#if (NODE_MODULE_VERSION > 0x000B) +// Node 0.11+ (0.11.3 and below won't compile with these) + +# define _NAN_METHOD_ARGS_TYPE const v8::FunctionCallbackInfo<v8::Value>& +# define _NAN_METHOD_ARGS _NAN_METHOD_ARGS_TYPE args +# define _NAN_METHOD_RETURN_TYPE void + +# define _NAN_GETTER_ARGS_TYPE const v8::PropertyCallbackInfo<v8::Value>& +# define _NAN_GETTER_ARGS _NAN_GETTER_ARGS_TYPE args +# define _NAN_GETTER_RETURN_TYPE void + +# define _NAN_SETTER_ARGS_TYPE const v8::PropertyCallbackInfo<void>& +# define _NAN_SETTER_ARGS _NAN_SETTER_ARGS_TYPE args +# define _NAN_SETTER_RETURN_TYPE void + +# define _NAN_PROPERTY_GETTER_ARGS_TYPE \ + const v8::PropertyCallbackInfo<v8::Value>& +# define _NAN_PROPERTY_GETTER_ARGS _NAN_PROPERTY_GETTER_ARGS_TYPE args +# define _NAN_PROPERTY_GETTER_RETURN_TYPE void + +# define _NAN_PROPERTY_SETTER_ARGS_TYPE \ + const v8::PropertyCallbackInfo<v8::Value>& +# define _NAN_PROPERTY_SETTER_ARGS _NAN_PROPERTY_SETTER_ARGS_TYPE args +# define _NAN_PROPERTY_SETTER_RETURN_TYPE void + +# define _NAN_PROPERTY_ENUMERATOR_ARGS_TYPE \ + const v8::PropertyCallbackInfo<v8::Array>& +# define _NAN_PROPERTY_ENUMERATOR_ARGS _NAN_PROPERTY_ENUMERATOR_ARGS_TYPE args +# define _NAN_PROPERTY_ENUMERATOR_RETURN_TYPE void + +# define _NAN_PROPERTY_DELETER_ARGS_TYPE \ + const v8::PropertyCallbackInfo<v8::Boolean>& +# define _NAN_PROPERTY_DELETER_ARGS \ + _NAN_PROPERTY_DELETER_ARGS_TYPE args +# define _NAN_PROPERTY_DELETER_RETURN_TYPE void + +# define _NAN_PROPERTY_QUERY_ARGS_TYPE \ + const v8::PropertyCallbackInfo<v8::Integer>& +# define _NAN_PROPERTY_QUERY_ARGS _NAN_PROPERTY_QUERY_ARGS_TYPE args +# define _NAN_PROPERTY_QUERY_RETURN_TYPE void + +# define _NAN_INDEX_GETTER_ARGS_TYPE \ + const v8::PropertyCallbackInfo<v8::Value>& +# define _NAN_INDEX_GETTER_ARGS _NAN_INDEX_GETTER_ARGS_TYPE args +# define _NAN_INDEX_GETTER_RETURN_TYPE void + +# define _NAN_INDEX_SETTER_ARGS_TYPE \ + const v8::PropertyCallbackInfo<v8::Value>& +# define _NAN_INDEX_SETTER_ARGS _NAN_INDEX_SETTER_ARGS_TYPE args +# define _NAN_INDEX_SETTER_RETURN_TYPE void + +# define _NAN_INDEX_ENUMERATOR_ARGS_TYPE \ + const v8::PropertyCallbackInfo<v8::Array>& +# define _NAN_INDEX_ENUMERATOR_ARGS _NAN_INDEX_ENUMERATOR_ARGS_TYPE args +# define _NAN_INDEX_ENUMERATOR_RETURN_TYPE void + +# define _NAN_INDEX_DELETER_ARGS_TYPE \ + const v8::PropertyCallbackInfo<v8::Boolean>& +# define _NAN_INDEX_DELETER_ARGS _NAN_INDEX_DELETER_ARGS_TYPE args +# define _NAN_INDEX_DELETER_RETURN_TYPE void + +# define _NAN_INDEX_QUERY_ARGS_TYPE \ + const v8::PropertyCallbackInfo<v8::Integer>& +# define _NAN_INDEX_QUERY_ARGS _NAN_INDEX_QUERY_ARGS_TYPE args +# define _NAN_INDEX_QUERY_RETURN_TYPE void + +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) \ + object->GetAlignedPointerFromInternalField(index) +# define NanSetInternalFieldPointer(object, index, value) \ + object->SetAlignedPointerInInternalField(index, value) + + 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) +# define NanUnlocker() v8::Unlocker unlocker(nan_isolate) +# define NanReturnValue(value) return args.GetReturnValue().Set(value) +# define NanReturnUndefined() return +# define NanReturnNull() return args.GetReturnValue().SetNull() +# define NanReturnEmptyString() return args.GetReturnValue().SetEmptyString() + +# define NanObjectWrapHandle(obj) obj->handle() + +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(NanNew<v8::String>(errmsg)) + +# define _NAN_THROW_ERROR(fun, errmsg) \ + do { \ + NanScope(); \ + nan_isolate->ThrowException(_NAN_ERROR(fun, errmsg)); \ + } while (0); + + NAN_INLINE v8::Local<v8::Value> NanError(const char* errmsg) { + return _NAN_ERROR(v8::Exception::Error, errmsg); + } + + NAN_INLINE void NanThrowError(const char* errmsg) { + _NAN_THROW_ERROR(v8::Exception::Error, errmsg); + } + + NAN_INLINE void NanThrowError(v8::Handle<v8::Value> error) { + NanScope(); + nan_isolate->ThrowException(error); + } + + NAN_INLINE v8::Local<v8::Value> NanError( + const char *msg + , const int errorNumber + ) { + v8::Local<v8::Value> err = v8::Exception::Error(NanNew<v8::String>(msg)); + v8::Local<v8::Object> obj = err.As<v8::Object>(); + obj->Set(NanSymbol("code"), NanNew<v8::Integer>(errorNumber)); + return err; + } + + NAN_INLINE void NanThrowError( + const char *msg + , const int errorNumber + ) { + NanThrowError(NanError(msg, errorNumber)); + } + + NAN_INLINE v8::Local<v8::Value> NanTypeError(const char* errmsg) { + return _NAN_ERROR(v8::Exception::TypeError, errmsg); + } + + NAN_INLINE void NanThrowTypeError(const char* errmsg) { + _NAN_THROW_ERROR(v8::Exception::TypeError, errmsg); + } + + NAN_INLINE v8::Local<v8::Value> NanRangeError(const char* errmsg) { + return _NAN_ERROR(v8::Exception::RangeError, errmsg); + } + + NAN_INLINE void NanThrowRangeError(const char* errmsg) { + _NAN_THROW_ERROR(v8::Exception::RangeError, errmsg); + } + + template<typename T> NAN_INLINE void NanDisposePersistent( + v8::Persistent<T> &handle + ) { + handle.Reset(); + } + + NAN_INLINE v8::Local<v8::Object> NanNewBufferHandle ( + char *data + , size_t length + , node::smalloc::FreeCallback callback + , void *hint + ) { + return node::Buffer::New(nan_isolate, data, length, callback, hint); + } + + NAN_INLINE v8::Local<v8::Object> NanNewBufferHandle ( + const char *data + , uint32_t size + ) { + return node::Buffer::New(nan_isolate, data, size); + } + + NAN_INLINE v8::Local<v8::Object> NanNewBufferHandle (uint32_t size) { + return node::Buffer::New(nan_isolate, size); + } + + NAN_INLINE v8::Local<v8::Object> NanBufferUse( + char* data + , uint32_t size + ) { + return node::Buffer::Use(nan_isolate, data, size); + } + + NAN_INLINE bool NanHasInstance( + v8::Persistent<v8::FunctionTemplate>& function_template + , v8::Handle<v8::Value> value + ) { + return NanNew(function_template)->HasInstance(value); + } + + 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( + nan_isolate + , v8::Context::New(nan_isolate, extensions, tmpl, obj) + ); + } + + 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 +// Node 0.8 and 0.10 + +# define _NAN_METHOD_ARGS_TYPE const v8::Arguments& +# define _NAN_METHOD_ARGS _NAN_METHOD_ARGS_TYPE args +# define _NAN_METHOD_RETURN_TYPE v8::Handle<v8::Value> + +# define _NAN_GETTER_ARGS_TYPE const v8::AccessorInfo & +# define _NAN_GETTER_ARGS _NAN_GETTER_ARGS_TYPE args +# define _NAN_GETTER_RETURN_TYPE v8::Handle<v8::Value> + +# define _NAN_SETTER_ARGS_TYPE const v8::AccessorInfo & +# define _NAN_SETTER_ARGS _NAN_SETTER_ARGS_TYPE args +# define _NAN_SETTER_RETURN_TYPE void + +# define _NAN_PROPERTY_GETTER_ARGS_TYPE const v8::AccessorInfo& +# define _NAN_PROPERTY_GETTER_ARGS _NAN_PROPERTY_GETTER_ARGS_TYPE args +# define _NAN_PROPERTY_GETTER_RETURN_TYPE v8::Handle<v8::Value> + +# define _NAN_PROPERTY_SETTER_ARGS_TYPE const v8::AccessorInfo& +# define _NAN_PROPERTY_SETTER_ARGS _NAN_PROPERTY_SETTER_ARGS_TYPE args +# define _NAN_PROPERTY_SETTER_RETURN_TYPE v8::Handle<v8::Value> + +# define _NAN_PROPERTY_ENUMERATOR_ARGS_TYPE const v8::AccessorInfo& +# define _NAN_PROPERTY_ENUMERATOR_ARGS _NAN_PROPERTY_ENUMERATOR_ARGS_TYPE args +# define _NAN_PROPERTY_ENUMERATOR_RETURN_TYPE v8::Handle<v8::Array> + +# define _NAN_PROPERTY_DELETER_ARGS_TYPE const v8::AccessorInfo& +# define _NAN_PROPERTY_DELETER_ARGS _NAN_PROPERTY_DELETER_ARGS_TYPE args +# define _NAN_PROPERTY_DELETER_RETURN_TYPE v8::Handle<v8::Boolean> + +# define _NAN_PROPERTY_QUERY_ARGS_TYPE const v8::AccessorInfo& +# define _NAN_PROPERTY_QUERY_ARGS _NAN_PROPERTY_QUERY_ARGS_TYPE args +# define _NAN_PROPERTY_QUERY_RETURN_TYPE v8::Handle<v8::Integer> + +# define _NAN_INDEX_GETTER_ARGS_TYPE const v8::AccessorInfo& +# define _NAN_INDEX_GETTER_ARGS _NAN_INDEX_GETTER_ARGS_TYPE args +# define _NAN_INDEX_GETTER_RETURN_TYPE v8::Handle<v8::Value> + +# define _NAN_INDEX_SETTER_ARGS_TYPE const v8::AccessorInfo& +# define _NAN_INDEX_SETTER_ARGS _NAN_INDEX_SETTER_ARGS_TYPE args +# define _NAN_INDEX_SETTER_RETURN_TYPE v8::Handle<v8::Value> + +# define _NAN_INDEX_ENUMERATOR_ARGS_TYPE const v8::AccessorInfo& +# define _NAN_INDEX_ENUMERATOR_ARGS _NAN_INDEX_ENUMERATOR_ARGS_TYPE args +# define _NAN_INDEX_ENUMERATOR_RETURN_TYPE v8::Handle<v8::Array> + +# define _NAN_INDEX_DELETER_ARGS_TYPE const v8::AccessorInfo& +# define _NAN_INDEX_DELETER_ARGS _NAN_INDEX_DELETER_ARGS_TYPE args +# define _NAN_INDEX_DELETER_RETURN_TYPE v8::Handle<v8::Boolean> + +# define _NAN_INDEX_QUERY_ARGS_TYPE const v8::AccessorInfo& +# define _NAN_INDEX_QUERY_ARGS _NAN_INDEX_QUERY_ARGS_TYPE args +# define _NAN_INDEX_QUERY_RETURN_TYPE v8::Handle<v8::Integer> + +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) \ + object->GetPointerFromInternalField(index) +# define NanSetInternalFieldPointer(object, index, value) \ + object->SetPointerInInternalField(index, value) + +// 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 +# define NanUnlocker() v8::Unlocker unlocker +# define NanReturnValue(value) return scope.Close(value) +# define NanReturnUndefined() return v8::Undefined() +# define NanReturnNull() return v8::Null() +# define NanReturnEmptyString() return v8::String::Empty() +# define NanObjectWrapHandle(obj) v8::Local<v8::Object>::New(obj->handle_) + +# define _NAN_ERROR(fun, errmsg) \ + fun(v8::String::New(errmsg)) + +# define _NAN_THROW_ERROR(fun, errmsg) \ + do { \ + NanScope(); \ + return v8::Local<v8::Value>::New( \ + v8::ThrowException(_NAN_ERROR(fun, errmsg))); \ + } while (0); + + NAN_INLINE v8::Local<v8::Value> NanError(const char* errmsg) { + return _NAN_ERROR(v8::Exception::Error, errmsg); + } + + NAN_INLINE v8::Local<v8::Value> NanThrowError(const char* errmsg) { + _NAN_THROW_ERROR(v8::Exception::Error, errmsg); + } + + NAN_INLINE v8::Local<v8::Value> NanThrowError( + v8::Handle<v8::Value> error + ) { + NanScope(); + return v8::Local<v8::Value>::New(v8::ThrowException(error)); + } + + 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::Object> obj = err.As<v8::Object>(); + obj->Set(v8::String::New("code"), v8::Int32::New(errorNumber)); + return err; + } + + NAN_INLINE v8::Local<v8::Value> NanThrowError( + const char *msg + , const int errorNumber + ) { + return NanThrowError(NanError(msg, errorNumber)); + } + + NAN_INLINE v8::Local<v8::Value> NanTypeError(const char* errmsg) { + return _NAN_ERROR(v8::Exception::TypeError, errmsg); + } + + NAN_INLINE v8::Local<v8::Value> NanThrowTypeError( + const char* errmsg + ) { + _NAN_THROW_ERROR(v8::Exception::TypeError, errmsg); + } + + NAN_INLINE v8::Local<v8::Value> NanRangeError( + const char* errmsg + ) { + return _NAN_ERROR(v8::Exception::RangeError, errmsg); + } + + NAN_INLINE v8::Local<v8::Value> NanThrowRangeError( + const char* errmsg + ) { + _NAN_THROW_ERROR(v8::Exception::RangeError, errmsg); + } + + template<typename T> + NAN_INLINE void NanDisposePersistent( + v8::Persistent<T> &handle) { // NOLINT(runtime/references) + handle.Dispose(); + handle.Clear(); + } + + NAN_INLINE v8::Local<v8::Object> NanNewBufferHandle ( + char *data + , size_t length + , node::Buffer::free_callback callback + , void *hint + ) { + return NanNew<v8::Object>( + node::Buffer::New(data, length, callback, hint)->handle_); + } + + NAN_INLINE v8::Local<v8::Object> NanNewBufferHandle ( + const char *data + , uint32_t size + ) { +#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 + } + + NAN_INLINE v8::Local<v8::Object> NanNewBufferHandle (uint32_t size) { + return NanNew<v8::Object>(node::Buffer::New(size)->handle_); + } + + NAN_INLINE void FreeData(char *data, void *hint) { + delete[] data; + } + + NAN_INLINE v8::Local<v8::Object> NanBufferUse( + char* data + , uint32_t size + ) { + return NanNew<v8::Object>( + node::Buffer::New(data, size, FreeData, NULL)->handle_); + } + + NAN_INLINE bool NanHasInstance( + v8::Persistent<v8::FunctionTemplate>& function_template + , v8::Handle<v8::Value> value + ) { + return function_template->HasInstance(value); + } + + 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 = NanNew<v8::Context>(ctx); + ctx.Dispose(); + return lctx; + } + + 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) +#define NAN_GETTER(name) \ + _NAN_GETTER_RETURN_TYPE name( \ + v8::Local<v8::String> property \ + , _NAN_GETTER_ARGS) +#define NAN_SETTER(name) \ + _NAN_SETTER_RETURN_TYPE name( \ + v8::Local<v8::String> property \ + , v8::Local<v8::Value> value \ + , _NAN_SETTER_ARGS) +#define NAN_PROPERTY_GETTER(name) \ + _NAN_PROPERTY_GETTER_RETURN_TYPE name( \ + v8::Local<v8::String> property \ + , _NAN_PROPERTY_GETTER_ARGS) +#define NAN_PROPERTY_SETTER(name) \ + _NAN_PROPERTY_SETTER_RETURN_TYPE name( \ + v8::Local<v8::String> property \ + , v8::Local<v8::Value> value \ + , _NAN_PROPERTY_SETTER_ARGS) +#define NAN_PROPERTY_ENUMERATOR(name) \ + _NAN_PROPERTY_ENUMERATOR_RETURN_TYPE name(_NAN_PROPERTY_ENUMERATOR_ARGS) +#define NAN_PROPERTY_DELETER(name) \ + _NAN_PROPERTY_DELETER_RETURN_TYPE name( \ + v8::Local<v8::String> property \ + , _NAN_PROPERTY_DELETER_ARGS) +#define NAN_PROPERTY_QUERY(name) \ + _NAN_PROPERTY_QUERY_RETURN_TYPE name( \ + v8::Local<v8::String> property \ + , _NAN_PROPERTY_QUERY_ARGS) +# define NAN_INDEX_GETTER(name) \ + _NAN_INDEX_GETTER_RETURN_TYPE name(uint32_t index, _NAN_INDEX_GETTER_ARGS) +#define NAN_INDEX_SETTER(name) \ + _NAN_INDEX_SETTER_RETURN_TYPE name( \ + uint32_t index \ + , v8::Local<v8::Value> value \ + , _NAN_INDEX_SETTER_ARGS) +#define NAN_INDEX_ENUMERATOR(name) \ + _NAN_INDEX_ENUMERATOR_RETURN_TYPE name(_NAN_INDEX_ENUMERATOR_ARGS) +#define NAN_INDEX_DELETER(name) \ + _NAN_INDEX_DELETER_RETURN_TYPE name( \ + uint32_t index \ + , _NAN_INDEX_DELETER_ARGS) +#define NAN_INDEX_QUERY(name) \ + _NAN_INDEX_QUERY_RETURN_TYPE name(uint32_t index, _NAN_INDEX_QUERY_ARGS) + +class NanCallback { + public: + NanCallback() { + NanScope(); + v8::Local<v8::Object> obj = NanNew<v8::Object>(); + NanAssignPersistent(handle, obj); + } + + explicit NanCallback(const v8::Handle<v8::Function> &fn) { + NanScope(); + v8::Local<v8::Object> obj = NanNew<v8::Object>(); + NanAssignPersistent(handle, obj); + SetFunction(fn); + } + + ~NanCallback() { + if (handle.IsEmpty()) return; + NanDisposePersistent(handle); + } + + NAN_INLINE void SetFunction(const v8::Handle<v8::Function> &fn) { + NanScope(); + NanNew(handle)->Set(NanSymbol("callback"), fn); + } + + NAN_INLINE v8::Local<v8::Function> GetFunction () { + return NanNew(handle)->Get(NanSymbol("callback")) + .As<v8::Function>(); + } + + void Call(int argc, v8::Handle<v8::Value> argv[]) { + 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 = NanNew(handle)-> + Get(NanSymbol("callback")).As<v8::Function>(); + node::MakeCallback( + v8::Context::GetCurrent()->Global() + , callback + , argc + , argv + ); +#else + node::MakeCallback(handle, "callback", argc, argv); +#endif +#endif + } + + private: + v8::Persistent<v8::Object> handle; +}; + +/* abstract */ class NanAsyncWorker { + 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() { + NanScope(); + + if (!persistentHandle.IsEmpty()) + NanDisposePersistent(persistentHandle); + if (callback) + delete callback; + if (errmsg) + delete errmsg; + } + + virtual void WorkComplete() { + NanScope(); + + if (errmsg == NULL) + HandleOKCallback(); + else + HandleErrorCallback(); + delete callback; + callback = NULL; + } + + NAN_INLINE void SaveToPersistent(const char *key, v8::Local<v8::Object> &obj) { + v8::Local<v8::Object> handle = NanNew(persistentHandle); + handle->Set(NanSymbol(key), obj); + } + + v8::Local<v8::Object> GetFromPersistent(const char *key) { + NanEscapableScope(); + v8::Local<v8::Object> handle = NanNew(persistentHandle); + return NanEscapeScope(handle->Get(NanSymbol(key)).As<v8::Object>()); + } + + virtual void Execute() = 0; + + uv_work_t request; + + protected: + v8::Persistent<v8::Object> persistentHandle; + NanCallback *callback; + const char *errmsg; + + virtual void HandleOKCallback() { + NanScope(); + + callback->Call(0, NULL); + } + + virtual void HandleErrorCallback() { + NanScope(); + + v8::Local<v8::Value> argv[] = { + v8::Exception::Error(NanNew<v8::String>(errmsg)) + }; + callback->Call(1, argv); + } +}; + +NAN_INLINE void NanAsyncExecute (uv_work_t* req) { + NanAsyncWorker *worker = static_cast<NanAsyncWorker*>(req->data); + worker->Execute(); +} + +NAN_INLINE void NanAsyncExecuteComplete (uv_work_t* req) { + NanAsyncWorker* worker = static_cast<NanAsyncWorker*>(req->data); + worker->WorkComplete(); + delete worker; +} + +NAN_INLINE void NanAsyncQueueWorker (NanAsyncWorker* worker) { + uv_queue_work( + uv_default_loop() + , &worker->request + , NanAsyncExecute + , (uv_after_work_cb)NanAsyncExecuteComplete + ); +} + +//// Base 64 //// + +#define _nan_base64_encoded_size(size) ((size + 2 - ((size + 2) % 3)) / 3 * 4) + +// Doesn't check for padding at the end. Can be 1-2 bytes over. +NAN_INLINE size_t _nan_base64_decoded_size_fast(size_t size) { + size_t remainder = size % 4; + + size = (size / 4) * 3; + if (remainder) { + if (size == 0 && remainder == 1) { + // special case: 1-byte input cannot be decoded + size = 0; + } else { + // non-padded input, add 1 or 2 extra bytes + size += 1 + (remainder == 3); + } + } + + return size; +} + +template<typename T> +NAN_INLINE size_t _nan_base64_decoded_size( + const T* src + , size_t size +) { + if (size == 0) + return 0; + + if (src[size - 1] == '=') + size--; + if (size > 0 && src[size - 1] == '=') + size--; + + return _nan_base64_decoded_size_fast(size); +} + +// supports regular and URL-safe base64 +static const int _nan_unbase64_table[] = { + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -2, -1, -1, -2, -1, -1 + , -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 + , -2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, 62, -1, 63 + , 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1 + , -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14 + , 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, 63 + , -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40 + , 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1 + , -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 + , -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 + , -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 + , -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 + , -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 + , -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 + , -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 + , -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 +}; + +#define _nan_unbase64(x) _nan_unbase64_table[(uint8_t)(x)] + +template<typename T> static size_t _nan_base64_decode( + char* buf + , size_t len + , const T* src + , const size_t srcLen +) { + char* dst = buf; + char* dstEnd = buf + len; + const T* srcEnd = src + srcLen; + + while (src < srcEnd && dst < dstEnd) { + ptrdiff_t remaining = srcEnd - src; + char a, b, c, d; + + while (_nan_unbase64(*src) < 0 && src < srcEnd) src++, remaining--; + if (remaining == 0 || *src == '=') break; + a = _nan_unbase64(*src++); + + while (_nan_unbase64(*src) < 0 && src < srcEnd) src++, remaining--; + if (remaining <= 1 || *src == '=') break; + b = _nan_unbase64(*src++); + + *dst++ = (a << 2) | ((b & 0x30) >> 4); + if (dst == dstEnd) break; + + while (_nan_unbase64(*src) < 0 && src < srcEnd) src++, remaining--; + if (remaining <= 2 || *src == '=') break; + c = _nan_unbase64(*src++); + + *dst++ = ((b & 0x0F) << 4) | ((c & 0x3C) >> 2); + if (dst == dstEnd) break; + + while (_nan_unbase64(*src) < 0 && src < srcEnd) src++, remaining--; + if (remaining <= 3 || *src == '=') break; + d = _nan_unbase64(*src++); + + *dst++ = ((c & 0x03) << 6) | (d & 0x3F); + } + + return dst - buf; +} + +//// HEX //// + +template<typename T> unsigned _nan_hex2bin(T c) { + if (c >= '0' && c <= '9') return c - '0'; + if (c >= 'A' && c <= 'F') return 10 + (c - 'A'); + if (c >= 'a' && c <= 'f') return 10 + (c - 'a'); + return static_cast<unsigned>(-1); +} + +template<typename T> static size_t _nan_hex_decode( + char* buf + , size_t len + , const T* src + , const size_t srcLen +) { + size_t i; + for (i = 0; i < len && i * 2 + 1 < srcLen; ++i) { + unsigned a = _nan_hex2bin(src[i * 2 + 0]); + unsigned b = _nan_hex2bin(src[i * 2 + 1]); + if (!~a || !~b) return i; + buf[i] = a * 16 + b; + } + + return i; +} + +static bool _NanGetExternalParts( + v8::Handle<v8::Value> val + , const char** data + , size_t* len +) { + if (node::Buffer::HasInstance(val)) { + *data = node::Buffer::Data(val.As<v8::Object>()); + *len = node::Buffer::Length(val.As<v8::Object>()); + return true; + } + + assert(val->IsString()); + v8::Local<v8::String> str = NanNew<v8::String>(val.As<v8::String>()); + + if (str->IsExternalAscii()) { + const v8::String::ExternalAsciiStringResource* ext; + ext = str->GetExternalAsciiStringResource(); + *data = ext->data(); + *len = ext->length(); + return true; + + } else if (str->IsExternal()) { + const v8::String::ExternalStringResource* ext; + ext = str->GetExternalStringResource(); + *data = reinterpret_cast<const char*>(ext->data()); + *len = ext->length(); + return true; + } + + return false; +} + +namespace Nan { + enum Encoding {ASCII, UTF8, BASE64, UCS2, BINARY, HEX, BUFFER}; +} + +NAN_INLINE void* NanRawString( + v8::Handle<v8::Value> from + , enum Nan::Encoding encoding + , size_t *datalen + , void *buf + , size_t buflen + , int flags +) { + NanScope(); + + size_t sz_; + size_t term_len = !(flags & v8::String::NO_NULL_TERMINATION); + char *data = NULL; + size_t len; + bool is_extern = _NanGetExternalParts( + from + , const_cast<const char**>(&data) + , &len); + + if (is_extern && !term_len) { + NanSetPointerSafe(datalen, len); + return data; + } + + v8::Local<v8::String> toStr = from->ToString(); + + char *to = static_cast<char *>(buf); + + switch (encoding) { + case Nan::ASCII: +#if NODE_MODULE_VERSION < 0x000C + sz_ = toStr->Length(); + if (to == NULL) { + to = new char[sz_ + term_len]; + } else { + assert(buflen >= sz_ + term_len && "too small buffer"); + } + NanSetPointerSafe<size_t>( + datalen + , toStr->WriteAscii(to, 0, static_cast<int>(sz_ + term_len), flags)); + return to; +#endif + case Nan::BINARY: + case Nan::BUFFER: + sz_ = toStr->Length(); + if (to == NULL) { + to = new char[sz_ + term_len]; + } else { + assert(buflen >= sz_ + term_len && "too small buffer"); + } +#if NODE_MODULE_VERSION < 0x000C + { + uint16_t* twobytebuf = new uint16_t[sz_ + term_len]; + + size_t len = toStr->Write(twobytebuf, 0, + static_cast<int>(sz_ + term_len), flags); + + for (size_t i = 0; i < sz_ + term_len && i < len + term_len; i++) { + unsigned char *b = reinterpret_cast<unsigned char*>(&twobytebuf[i]); + to[i] = *b; + } + + NanSetPointerSafe<size_t>(datalen, len); + + delete[] twobytebuf; + return to; + } +#else + NanSetPointerSafe<size_t>( + datalen, + toStr->WriteOneByte( + reinterpret_cast<uint8_t *>(to) + , 0 + , static_cast<int>(sz_ + term_len) + , flags)); + return to; +#endif + case Nan::UTF8: + sz_ = toStr->Utf8Length(); + if (to == NULL) { + to = new char[sz_ + term_len]; + } else { + assert(buflen >= sz_ + term_len && "too small buffer"); + } + NanSetPointerSafe<size_t>( + datalen + , toStr->WriteUtf8(to, static_cast<int>(sz_ + term_len) + , NULL, flags) + - term_len); + return to; + case Nan::BASE64: + { + v8::String::Value value(toStr); + sz_ = _nan_base64_decoded_size(*value, value.length()); + if (to == NULL) { + to = new char[sz_ + term_len]; + } else { + assert(buflen >= sz_ + term_len); + } + NanSetPointerSafe<size_t>( + datalen + , _nan_base64_decode(to, sz_, *value, value.length())); + if (term_len) { + to[sz_] = '\0'; + } + return to; + } + case Nan::UCS2: + { + sz_ = toStr->Length(); + if (to == NULL) { + to = new char[(sz_ + term_len) * 2]; + } else { + assert(buflen >= (sz_ + term_len) * 2 && "too small buffer"); + } + + int bc = 2 * toStr->Write( + reinterpret_cast<uint16_t *>(to) + , 0 + , static_cast<int>(sz_ + term_len) + , flags); + NanSetPointerSafe<size_t>(datalen, bc); + return to; + } + case Nan::HEX: + { + v8::String::Value value(toStr); + sz_ = value.length(); + assert(!(sz_ & 1) && "bad hex data"); + if (to == NULL) { + to = new char[sz_ / 2 + term_len]; + } else { + assert(buflen >= sz_ / 2 + term_len && "too small buffer"); + } + NanSetPointerSafe<size_t>( + datalen + , _nan_hex_decode(to, sz_ / 2, *value, value.length())); + } + if (term_len) { + to[sz_ / 2] = '\0'; + } + return to; + default: + assert(0 && "unknown encoding"); + } + return to; +} + +NAN_INLINE char* NanCString( + v8::Handle<v8::Value> from + , size_t *datalen + , char *buf = NULL + , size_t buflen = 0 + , int flags = v8::String::NO_OPTIONS +) { + return static_cast<char *>( + NanRawString(from, Nan::UTF8, datalen, buf, buflen, flags) + ); +} + +#endif // NAN_H_ |