vnfmarket/src/main/webapp/vnfmarket/node_modules/nan/nan.h

   1 /**********************************************************************************
   2  * NAN - Native Abstractions for Node.js
   3  *
   4  * Copyright (c) 2014 NAN contributors:
   5  *   - Rod Vagg <https://github.com/rvagg>
   6  *   - Benjamin Byholm <https://github.com/kkoopa>
   7  *   - Trevor Norris <https://github.com/trevnorris>
   8  *   - Nathan Rajlich <https://github.com/TooTallNate>
   9  *   - Brett Lawson <https://github.com/brett19>
  10  *   - Ben Noordhuis <https://github.com/bnoordhuis>
  11  *
  12  * MIT +no-false-attribs License <https://github.com/rvagg/nan/blob/master/LICENSE>
  13  *
  14  * Version 1.0.0 (current Node unstable: 0.11.13, Node stable: 0.10.28)
  15  *
  16  * ChangeLog:
  17  *  * 1.0.0 May 4 2014
  18  *    - Heavy API changes for V8 3.25 / Node 0.11.13
  19  *    - Use cpplint.py
  20  *    - Removed NanInitPersistent
  21  *    - Removed NanPersistentToLocal
  22  *    - Removed NanFromV8String
  23  *    - Removed NanMakeWeak
  24  *    - Removed NanNewLocal
  25  *    - Removed NAN_WEAK_CALLBACK_OBJECT
  26  *    - Removed NAN_WEAK_CALLBACK_DATA
  27  *    - Introduce NanNew, replaces NanNewLocal, NanPersistentToLocal, adds many overloaded typed versions
  28  *    - Introduce NanUndefined, NanNull, NanTrue and NanFalse
  29  *    - Introduce NanEscapableScope and NanEscapeScope
  30  *    - Introduce NanMakeWeakPersistent (requires a special callback to work on both old and new node)
  31  *    - Introduce NanMakeCallback for node::MakeCallback
  32  *    - Introduce NanSetTemplate
  33  *    - Introduce NanGetCurrentContext
  34  *    - Introduce NanCompileScript and NanRunScript
  35  *    - Introduce NanAdjustExternalMemory
  36  *    - Introduce NanAddGCEpilogueCallback, NanAddGCPrologueCallback, NanRemoveGCEpilogueCallback, NanRemoveGCPrologueCallback
  37  *    - Introduce NanGetHeapStatistics
  38  *    - Rename NanAsyncWorker#SavePersistent() to SaveToPersistent()
  39  *
  40  *  * 0.8.0 Jan 9 2014
  41  *    - NanDispose -> NanDisposePersistent, deprecate NanDispose
  42  *    - Extract _NAN_*_RETURN_TYPE, pull up NAN_*()
  43  *
  44  *  * 0.7.1 Jan 9 2014
  45  *    - Fixes to work against debug builds of Node
  46  *    - Safer NanPersistentToLocal (avoid reinterpret_cast)
  47  *    - Speed up common NanRawString case by only extracting flattened string when necessary
  48  *
  49  *  * 0.7.0 Dec 17 2013
  50  *    - New no-arg form of NanCallback() constructor.
  51  *    - NanCallback#Call takes Handle rather than Local
  52  *    - Removed deprecated NanCallback#Run method, use NanCallback#Call instead
  53  *    - Split off _NAN_*_ARGS_TYPE from _NAN_*_ARGS
  54  *    - Restore (unofficial) Node 0.6 compatibility at NanCallback#Call()
  55  *    - Introduce NanRawString() for char* (or appropriate void*) from v8::String
  56  *      (replacement for NanFromV8String)
  57  *    - Introduce NanCString() for null-terminated char* from v8::String
  58  *
  59  *  * 0.6.0 Nov 21 2013
  60  *    - Introduce NanNewLocal<T>(v8::Handle<T> value) for use in place of
  61  *      v8::Local<T>::New(...) since v8 started requiring isolate in Node 0.11.9
  62  *
  63  *  * 0.5.2 Nov 16 2013
  64  *    - Convert SavePersistent and GetFromPersistent in NanAsyncWorker from protected and public
  65  *
  66  *  * 0.5.1 Nov 12 2013
  67  *    - Use node::MakeCallback() instead of direct v8::Function::Call()
  68  *
  69  *  * 0.5.0 Nov 11 2013
  70  *    - Added @TooTallNate as collaborator
  71  *    - New, much simpler, "include_dirs" for binding.gyp
  72  *    - Added full range of NAN_INDEX_* macros to match NAN_PROPERTY_* macros
  73  *
  74  *  * 0.4.4 Nov 2 2013
  75  *    - Isolate argument from v8::Persistent::MakeWeak removed for 0.11.8+
  76  *
  77  *  * 0.4.3 Nov 2 2013
  78  *    - Include node_object_wrap.h, removed from node.h for Node 0.11.8.
  79  *
  80  *  * 0.4.2 Nov 2 2013
  81  *    - Handle deprecation of v8::Persistent::Dispose(v8::Isolate* isolate)) for
  82  *      Node 0.11.8 release.
  83  *
  84  *  * 0.4.1 Sep 16 2013
  85  *    - Added explicit `#include <uv.h>` as it was removed from node.h for v0.11.8
  86  *
  87  *  * 0.4.0 Sep 2 2013
  88  *    - Added NAN_INLINE and NAN_DEPRECATED and made use of them
  89  *    - Added NanError, NanTypeError and NanRangeError
  90  *    - Cleaned up code
  91  *
  92  *  * 0.3.2 Aug 30 2013
  93  *    - Fix missing scope declaration in GetFromPersistent() and SaveToPersistent
  94  *      in NanAsyncWorker
  95  *
  96  *  * 0.3.1 Aug 20 2013
  97  *    - fix "not all control paths return a value" compile warning on some platforms
  98  *
  99  *  * 0.3.0 Aug 19 2013
 100  *    - Made NAN work with NPM
 101  *    - Lots of fixes to NanFromV8String, pulling in features from new Node core
 102  *    - Changed node::encoding to Nan::Encoding in NanFromV8String to unify the API
 103  *    - Added optional error number argument for NanThrowError()
 104  *    - Added NanInitPersistent()
 105  *    - Added NanReturnNull() and NanReturnEmptyString()
 106  *    - Added NanLocker and NanUnlocker
 107  *    - Added missing scopes
 108  *    - Made sure to clear disposed Persistent handles
 109  *    - Changed NanAsyncWorker to allocate error messages on the heap
 110  *    - Changed NanThrowError(Local<Value>) to NanThrowError(Handle<Value>)
 111  *    - Fixed leak in NanAsyncWorker when errmsg is used
 112  *
 113  *  * 0.2.2 Aug 5 2013
 114  *    - Fixed usage of undefined variable with node::BASE64 in NanFromV8String()
 115  *
 116  *  * 0.2.1 Aug 5 2013
 117  *    - Fixed 0.8 breakage, node::BUFFER encoding type not available in 0.8 for
 118  *      NanFromV8String()
 119  *
 120  *  * 0.2.0 Aug 5 2013
 121  *    - Added NAN_PROPERTY_GETTER, NAN_PROPERTY_SETTER, NAN_PROPERTY_ENUMERATOR,
 122  *      NAN_PROPERTY_DELETER, NAN_PROPERTY_QUERY
 123  *    - Extracted _NAN_METHOD_ARGS, _NAN_GETTER_ARGS, _NAN_SETTER_ARGS,
 124  *      _NAN_PROPERTY_GETTER_ARGS, _NAN_PROPERTY_SETTER_ARGS,
 125  *      _NAN_PROPERTY_ENUMERATOR_ARGS, _NAN_PROPERTY_DELETER_ARGS,
 126  *      _NAN_PROPERTY_QUERY_ARGS
 127  *    - Added NanGetInternalFieldPointer, NanSetInternalFieldPointer
 128  *    - Added NAN_WEAK_CALLBACK, NAN_WEAK_CALLBACK_OBJECT,
 129  *      NAN_WEAK_CALLBACK_DATA, NanMakeWeak
 130  *    - Renamed THROW_ERROR to _NAN_THROW_ERROR
 131  *    - Added NanNewBufferHandle(char*, size_t, node::smalloc::FreeCallback, void*)
 132  *    - Added NanBufferUse(char*, uint32_t)
 133  *    - Added NanNewContextHandle(v8::ExtensionConfiguration*,
 134  *        v8::Handle<v8::ObjectTemplate>, v8::Handle<v8::Value>)
 135  *    - Fixed broken NanCallback#GetFunction()
 136  *    - Added optional encoding and size arguments to NanFromV8String()
 137  *    - Added NanGetPointerSafe() and NanSetPointerSafe()
 138  *    - Added initial test suite (to be expanded)
 139  *    - Allow NanUInt32OptionValue to convert any Number object
 140  *
 141  *  * 0.1.0 Jul 21 2013
 142  *    - Added `NAN_GETTER`, `NAN_SETTER`
 143  *    - Added `NanThrowError` with single Local<Value> argument
 144  *    - Added `NanNewBufferHandle` with single uint32_t argument
 145  *    - Added `NanHasInstance(Persistent<FunctionTemplate>&, Handle<Value>)`
 146  *    - Added `Local<Function> NanCallback#GetFunction()`
 147  *    - Added `NanCallback#Call(int, Local<Value>[])`
 148  *    - Deprecated `NanCallback#Run(int, Local<Value>[])` in favour of Call
 149  *
 150  * See https://github.com/rvagg/nan for the latest update to this file
 151  **********************************************************************************/
 152
 153 #ifndef NAN_H_
 154 #define NAN_H_
 155
 156 #include <uv.h>
 157 #include <node.h>
 158 #include <node_buffer.h>
 159 #include <node_version.h>
 160 #include <node_object_wrap.h>
 161 #include <string.h>
 162
 163 #if defined(__GNUC__) && !defined(DEBUG)
 164 # define NAN_INLINE inline __attribute__((always_inline))
 165 #elif defined(_MSC_VER) && !defined(DEBUG)
 166 # define NAN_INLINE __forceinline
 167 #else
 168 # define NAN_INLINE inline
 169 #endif
 170
 171 #if defined(__GNUC__) && !V8_DISABLE_DEPRECATIONS
 172 # define NAN_DEPRECATED __attribute__((deprecated))
 173 #elif defined(_MSC_VER) && !V8_DISABLE_DEPRECATIONS
 174 # define NAN_DEPRECATED __declspec(deprecated)
 175 #else
 176 # define NAN_DEPRECATED
 177 #endif
 178
 179 // some generic helpers
 180
 181 template<typename T> NAN_INLINE bool NanSetPointerSafe(
 182     T *var
 183   , T val
 184 ) {
 185   if (var) {
 186     *var = val;
 187     return true;
 188   } else {
 189     return false;
 190   }
 191 }
 192
 193 template<typename T> NAN_INLINE T NanGetPointerSafe(
 194     T *var
 195   , T fallback = reinterpret_cast<T>(0)
 196 ) {
 197   if (var) {
 198     return *var;
 199   } else {
 200     return fallback;
 201   }
 202 }
 203
 204 NAN_INLINE bool NanBooleanOptionValue(
 205     v8::Local<v8::Object> optionsObj
 206   , v8::Handle<v8::String> opt, bool def
 207 ) {
 208   if (def) {
 209     return optionsObj.IsEmpty()
 210       || !optionsObj->Has(opt)
 211       || optionsObj->Get(opt)->BooleanValue();
 212   } else {
 213     return !optionsObj.IsEmpty()
 214       && optionsObj->Has(opt)
 215       && optionsObj->Get(opt)->BooleanValue();
 216   }
 217 }
 218
 219 NAN_INLINE bool NanBooleanOptionValue(
 220     v8::Local<v8::Object> optionsObj
 221   , v8::Handle<v8::String> opt
 222 ) {
 223   return NanBooleanOptionValue(optionsObj, opt, false);
 224 }
 225
 226 NAN_INLINE uint32_t NanUInt32OptionValue(
 227     v8::Local<v8::Object> optionsObj
 228   , v8::Handle<v8::String> opt
 229   , uint32_t def
 230 ) {
 231   return !optionsObj.IsEmpty()
 232     && optionsObj->Has(opt)
 233     && optionsObj->Get(opt)->IsNumber()
 234       ? optionsObj->Get(opt)->Uint32Value()
 235       : def;
 236 }
 237
 238 #if (NODE_MODULE_VERSION > 0x000B)
 239 // Node 0.11+ (0.11.3 and below won't compile with these)
 240
 241 # define _NAN_METHOD_ARGS_TYPE const v8::FunctionCallbackInfo<v8::Value>&
 242 # define _NAN_METHOD_ARGS _NAN_METHOD_ARGS_TYPE args
 243 # define _NAN_METHOD_RETURN_TYPE void
 244
 245 # define _NAN_GETTER_ARGS_TYPE const v8::PropertyCallbackInfo<v8::Value>&
 246 # define _NAN_GETTER_ARGS _NAN_GETTER_ARGS_TYPE args
 247 # define _NAN_GETTER_RETURN_TYPE void
 248
 249 # define _NAN_SETTER_ARGS_TYPE const v8::PropertyCallbackInfo<void>&
 250 # define _NAN_SETTER_ARGS _NAN_SETTER_ARGS_TYPE args
 251 # define _NAN_SETTER_RETURN_TYPE void
 252
 253 # define _NAN_PROPERTY_GETTER_ARGS_TYPE                                        \
 254     const v8::PropertyCallbackInfo<v8::Value>&
 255 # define _NAN_PROPERTY_GETTER_ARGS _NAN_PROPERTY_GETTER_ARGS_TYPE args
 256 # define _NAN_PROPERTY_GETTER_RETURN_TYPE void
 257
 258 # define _NAN_PROPERTY_SETTER_ARGS_TYPE                                        \
 259     const v8::PropertyCallbackInfo<v8::Value>&
 260 # define _NAN_PROPERTY_SETTER_ARGS _NAN_PROPERTY_SETTER_ARGS_TYPE args
 261 # define _NAN_PROPERTY_SETTER_RETURN_TYPE void
 262
 263 # define _NAN_PROPERTY_ENUMERATOR_ARGS_TYPE                                    \
 264     const v8::PropertyCallbackInfo<v8::Array>&
 265 # define _NAN_PROPERTY_ENUMERATOR_ARGS _NAN_PROPERTY_ENUMERATOR_ARGS_TYPE args
 266 # define _NAN_PROPERTY_ENUMERATOR_RETURN_TYPE void
 267
 268 # define _NAN_PROPERTY_DELETER_ARGS_TYPE                                       \
 269     const v8::PropertyCallbackInfo<v8::Boolean>&
 270 # define _NAN_PROPERTY_DELETER_ARGS                                            \
 271     _NAN_PROPERTY_DELETER_ARGS_TYPE args
 272 # define _NAN_PROPERTY_DELETER_RETURN_TYPE void
 273
 274 # define _NAN_PROPERTY_QUERY_ARGS_TYPE                                         \
 275     const v8::PropertyCallbackInfo<v8::Integer>&
 276 # define _NAN_PROPERTY_QUERY_ARGS _NAN_PROPERTY_QUERY_ARGS_TYPE args
 277 # define _NAN_PROPERTY_QUERY_RETURN_TYPE void
 278
 279 # define _NAN_INDEX_GETTER_ARGS_TYPE                                           \
 280     const v8::PropertyCallbackInfo<v8::Value>&
 281 # define _NAN_INDEX_GETTER_ARGS _NAN_INDEX_GETTER_ARGS_TYPE args
 282 # define _NAN_INDEX_GETTER_RETURN_TYPE void
 283
 284 # define _NAN_INDEX_SETTER_ARGS_TYPE                                           \
 285     const v8::PropertyCallbackInfo<v8::Value>&
 286 # define _NAN_INDEX_SETTER_ARGS _NAN_INDEX_SETTER_ARGS_TYPE args
 287 # define _NAN_INDEX_SETTER_RETURN_TYPE void
 288
 289 # define _NAN_INDEX_ENUMERATOR_ARGS_TYPE                                       \
 290     const v8::PropertyCallbackInfo<v8::Array>&
 291 # define _NAN_INDEX_ENUMERATOR_ARGS _NAN_INDEX_ENUMERATOR_ARGS_TYPE args
 292 # define _NAN_INDEX_ENUMERATOR_RETURN_TYPE void
 293
 294 # define _NAN_INDEX_DELETER_ARGS_TYPE                                          \
 295     const v8::PropertyCallbackInfo<v8::Boolean>&
 296 # define _NAN_INDEX_DELETER_ARGS _NAN_INDEX_DELETER_ARGS_TYPE args
 297 # define _NAN_INDEX_DELETER_RETURN_TYPE void
 298
 299 # define _NAN_INDEX_QUERY_ARGS_TYPE                                            \
 300     const v8::PropertyCallbackInfo<v8::Integer>&
 301 # define _NAN_INDEX_QUERY_ARGS _NAN_INDEX_QUERY_ARGS_TYPE args
 302 # define _NAN_INDEX_QUERY_RETURN_TYPE void
 303
 304 typedef v8::FunctionCallback NanFunctionCallback;
 305 static v8::Isolate* nan_isolate = v8::Isolate::GetCurrent();
 306
 307 # define NanUndefined() v8::Undefined(nan_isolate)
 308 # define NanNull() v8::Null(nan_isolate)
 309 # define NanTrue() v8::True(nan_isolate)
 310 # define NanFalse() v8::False(nan_isolate)
 311 # define NanAdjustExternalMemory(amount)                                       \
 312     nan_isolate->AdjustAmountOfExternalAllocatedMemory(amount)
 313 # define NanSetTemplate(templ, name, value) templ->Set(nan_isolate, name, value)
 314 # define NanGetCurrentContext() nan_isolate->GetCurrentContext()
 315 # define NanMakeCallback(target, func, argc, argv)                             \
 316     node::MakeCallback(nan_isolate, target, func, argc, argv)
 317 # define NanGetInternalFieldPointer(object, index)                             \
 318     object->GetAlignedPointerFromInternalField(index)
 319 # define NanSetInternalFieldPointer(object, index, value)                      \
 320     object->SetAlignedPointerInInternalField(index, value)
 321
 322   template<typename T>
 323   NAN_INLINE v8::Local<T> NanNew() {
 324     return T::New(nan_isolate);
 325   }
 326
 327   template<typename T, typename P>
 328   NAN_INLINE v8::Local<T> NanNew(P arg1) {
 329     return T::New(nan_isolate, arg1);
 330   }
 331
 332   template<typename T>
 333   NAN_INLINE v8::Local<v8::Signature> NanNew(
 334       v8::Handle<v8::FunctionTemplate> receiver
 335     , int argc
 336     , v8::Handle<v8::FunctionTemplate> argv[] = 0) {
 337     return v8::Signature::New(nan_isolate, receiver, argc, argv);
 338   }
 339
 340   template<typename T>
 341   NAN_INLINE v8::Local<v8::FunctionTemplate> NanNew(
 342       NanFunctionCallback callback
 343     , v8::Handle<v8::Value> data = v8::Handle<v8::Value>()
 344     , v8::Handle<v8::Signature> signature = v8::Handle<v8::Signature>()) {
 345     return T::New(nan_isolate, callback, data, signature);
 346   }
 347
 348   template<typename T>
 349   NAN_INLINE v8::Local<T> NanNew(v8::Handle<T> arg1) {
 350     return v8::Local<T>::New(nan_isolate, arg1);
 351   }
 352
 353   template<typename T>
 354   NAN_INLINE v8::Local<T> NanNew(const v8::Persistent<T> &arg1) {
 355     return v8::Local<T>::New(nan_isolate, arg1);
 356   }
 357
 358   template<typename T, typename P>
 359   NAN_INLINE v8::Local<T> NanNew(P arg1, int arg2) {
 360     return T::New(nan_isolate, arg1, arg2);
 361   }
 362
 363   template<>
 364   NAN_INLINE v8::Local<v8::Array> NanNew<v8::Array>() {
 365     return v8::Array::New(nan_isolate);
 366   }
 367
 368   template<>
 369   NAN_INLINE v8::Local<v8::Array> NanNew<v8::Array>(int length) {
 370     return v8::Array::New(nan_isolate, length);
 371   }
 372
 373   template<>
 374   NAN_INLINE v8::Local<v8::Date> NanNew<v8::Date>(double time) {
 375     return v8::Date::New(nan_isolate, time).As<v8::Date>();
 376   }
 377
 378   template<>
 379   NAN_INLINE v8::Local<v8::Date> NanNew<v8::Date>(int time) {
 380     return v8::Date::New(nan_isolate, time).As<v8::Date>();
 381   }
 382
 383   typedef v8::UnboundScript NanUnboundScript;
 384   typedef v8::Script NanBoundScript;
 385
 386   template<typename T, typename P>
 387   NAN_INLINE v8::Local<T> NanNew(
 388       P s
 389     , const v8::ScriptOrigin& origin
 390   ) {
 391     v8::ScriptCompiler::Source source(s, origin);
 392     return v8::ScriptCompiler::CompileUnbound(nan_isolate, &source);
 393   }
 394
 395   template<>
 396   NAN_INLINE v8::Local<NanUnboundScript> NanNew<NanUnboundScript>(
 397       v8::Local<v8::String> s
 398   ) {
 399     v8::ScriptCompiler::Source source(s);
 400     return v8::ScriptCompiler::CompileUnbound(nan_isolate, &source);
 401   }
 402
 403   NAN_INLINE v8::Local<v8::String> NanNew(
 404       v8::String::ExternalStringResource *resource) {
 405     return v8::String::NewExternal(nan_isolate, resource);
 406   }
 407
 408   NAN_INLINE v8::Local<v8::String> NanNew(
 409       v8::String::ExternalAsciiStringResource *resource) {
 410     return v8::String::NewExternal(nan_isolate, resource);
 411   }
 412
 413   template<>
 414   NAN_INLINE v8::Local<v8::BooleanObject> NanNew(bool value) {
 415     return v8::BooleanObject::New(value).As<v8::BooleanObject>();
 416   }
 417
 418   template<>
 419   NAN_INLINE v8::Local<v8::StringObject>
 420   NanNew<v8::StringObject, v8::Local<v8::String> >(
 421       v8::Local<v8::String> value) {
 422     return v8::StringObject::New(value).As<v8::StringObject>();
 423   }
 424
 425   template<>
 426   NAN_INLINE v8::Local<v8::StringObject>
 427   NanNew<v8::StringObject, v8::Handle<v8::String> >(
 428       v8::Handle<v8::String> value) {
 429     return v8::StringObject::New(value).As<v8::StringObject>();
 430   }
 431
 432   template<>
 433   NAN_INLINE v8::Local<v8::NumberObject> NanNew<v8::NumberObject>(double val) {
 434     return v8::NumberObject::New(nan_isolate, val).As<v8::NumberObject>();
 435   }
 436
 437   template<typename T>
 438   NAN_INLINE v8::Local<v8::RegExp> NanNew(
 439       v8::Handle<v8::String> pattern, v8::RegExp::Flags flags) {
 440     return v8::RegExp::New(pattern, flags);
 441   }
 442
 443   template<typename T>
 444   NAN_INLINE v8::Local<v8::RegExp> NanNew(
 445       v8::Local<v8::String> pattern, v8::RegExp::Flags flags) {
 446     return v8::RegExp::New(pattern, flags);
 447   }
 448
 449   template<typename T, typename P>
 450   NAN_INLINE v8::Local<v8::RegExp> NanNew(
 451       v8::Handle<v8::String> pattern, v8::RegExp::Flags flags) {
 452     return v8::RegExp::New(pattern, flags);
 453   }
 454
 455   template<typename T, typename P>
 456   NAN_INLINE v8::Local<v8::RegExp> NanNew(
 457       v8::Local<v8::String> pattern, v8::RegExp::Flags flags) {
 458     return v8::RegExp::New(pattern, flags);
 459   }
 460
 461   template<>
 462   NAN_INLINE v8::Local<v8::Uint32> NanNew<v8::Uint32, int32_t>(int32_t val) {
 463     return v8::Uint32::NewFromUnsigned(nan_isolate, val)->ToUint32();
 464   }
 465
 466   template<>
 467   NAN_INLINE v8::Local<v8::Uint32> NanNew<v8::Uint32, uint32_t>(uint32_t val) {
 468     return v8::Uint32::NewFromUnsigned(nan_isolate, val)->ToUint32();
 469   }
 470
 471   template<>
 472   NAN_INLINE v8::Local<v8::Int32> NanNew<v8::Int32, int32_t>(int32_t val) {
 473     return v8::Int32::New(nan_isolate, val)->ToInt32();
 474   }
 475
 476   template<>
 477   NAN_INLINE v8::Local<v8::Int32> NanNew<v8::Int32, uint32_t>(uint32_t val) {
 478     return v8::Int32::New(nan_isolate, val)->ToInt32();
 479   }
 480
 481   template<>
 482   NAN_INLINE v8::Local<v8::String> NanNew<v8::String, char *>(
 483       char *arg
 484     , int length) {
 485     return v8::String::NewFromUtf8(
 486         nan_isolate
 487       , arg
 488       , v8::String::kNormalString
 489       , length);
 490   }
 491
 492   template<>
 493   NAN_INLINE v8::Local<v8::String> NanNew<v8::String, const char *>(
 494       const char *arg
 495     , int length) {
 496     return v8::String::NewFromUtf8(
 497         nan_isolate
 498       , arg
 499       , v8::String::kNormalString
 500       , length);
 501   }
 502
 503   template<>
 504   NAN_INLINE v8::Local<v8::String> NanNew<v8::String, char *>(char *arg) {
 505     return v8::String::NewFromUtf8(nan_isolate, arg);
 506   }
 507
 508   template<>
 509   NAN_INLINE v8::Local<v8::String> NanNew<v8::String, const char *>(
 510       const char *arg) {
 511     return v8::String::NewFromUtf8(nan_isolate, arg);
 512   }
 513
 514   template<>
 515   NAN_INLINE v8::Local<v8::String> NanNew<v8::String, uint8_t *>(
 516       uint8_t *arg
 517     , int length) {
 518     return v8::String::NewFromOneByte(
 519         nan_isolate
 520       , arg
 521       , v8::String::kNormalString
 522       , length);
 523   }
 524
 525   template<>
 526   NAN_INLINE v8::Local<v8::String> NanNew<v8::String, const uint8_t *>(
 527       const uint8_t *arg
 528     , int length) {
 529     return v8::String::NewFromOneByte(
 530         nan_isolate
 531       , arg
 532       , v8::String::kNormalString
 533       , length);
 534   }
 535
 536   template<>
 537   NAN_INLINE v8::Local<v8::String> NanNew<v8::String, uint8_t *>(uint8_t *arg) {
 538     return v8::String::NewFromOneByte(nan_isolate, arg);
 539   }
 540
 541   template<>
 542   NAN_INLINE v8::Local<v8::String> NanNew<v8::String, const uint8_t *>(
 543       const uint8_t *arg) {
 544     return v8::String::NewFromOneByte(nan_isolate, arg);
 545   }
 546
 547   template<>
 548   NAN_INLINE v8::Local<v8::String> NanNew<v8::String, uint16_t *>(
 549       uint16_t *arg
 550     , int length) {
 551     return v8::String::NewFromTwoByte(
 552         nan_isolate
 553       , arg
 554       , v8::String::kNormalString
 555       , length);
 556   }
 557
 558   template<>
 559   NAN_INLINE v8::Local<v8::String> NanNew<v8::String, const uint16_t *>(
 560       const uint16_t *arg
 561     , int length) {
 562     return v8::String::NewFromTwoByte(
 563         nan_isolate
 564       , arg
 565       , v8::String::kNormalString
 566       , length);
 567   }
 568   template<>
 569   NAN_INLINE v8::Local<v8::String> NanNew<v8::String, uint16_t *>(
 570       uint16_t *arg) {
 571     return v8::String::NewFromTwoByte(nan_isolate, arg);
 572   }
 573
 574   template<>
 575   NAN_INLINE v8::Local<v8::String> NanNew<v8::String, const uint16_t *>(
 576       const uint16_t *arg) {
 577     return v8::String::NewFromTwoByte(nan_isolate, arg);
 578   }
 579
 580   template<>
 581   NAN_INLINE v8::Local<v8::String> NanNew<v8::String>() {
 582     return v8::String::Empty(nan_isolate);
 583   }
 584
 585   NAN_INLINE void NanAddGCEpilogueCallback(
 586       v8::Isolate::GCEpilogueCallback callback
 587     , v8::GCType gc_type_filter = v8::kGCTypeAll) {
 588     nan_isolate->AddGCEpilogueCallback(callback, gc_type_filter);
 589   }
 590
 591   NAN_INLINE void NanRemoveGCEpilogueCallback(
 592       v8::Isolate::GCEpilogueCallback callback) {
 593     nan_isolate->RemoveGCEpilogueCallback(callback);
 594   }
 595
 596   NAN_INLINE void NanAddGCPrologueCallback(
 597       v8::Isolate::GCPrologueCallback callback
 598     , v8::GCType gc_type_filter = v8::kGCTypeAll) {
 599     nan_isolate->AddGCPrologueCallback(callback, gc_type_filter);
 600   }
 601
 602   NAN_INLINE void NanRemoveGCPrologueCallback(
 603       v8::Isolate::GCPrologueCallback callback) {
 604     nan_isolate->RemoveGCPrologueCallback(callback);
 605   }
 606
 607   NAN_INLINE void NanGetHeapStatistics(
 608       v8::HeapStatistics *heap_statistics) {
 609     nan_isolate->GetHeapStatistics(heap_statistics);
 610   }
 611
 612 # define NanSymbol(value) NanNew<v8::String>(value)
 613
 614   template<typename T>
 615   NAN_INLINE void NanAssignPersistent(
 616       v8::Persistent<T>& handle
 617     , v8::Handle<T> obj) {
 618       handle.Reset(nan_isolate, obj);
 619   }
 620
 621   template<typename T>
 622   NAN_INLINE void NanAssignPersistent(
 623       v8::Persistent<T>& handle
 624     , const v8::Persistent<T>& obj) {
 625       handle.Reset(nan_isolate, obj);
 626   }
 627
 628   template<typename T, typename P>
 629   struct _NanWeakCallbackInfo {
 630     typedef void (*Callback)(
 631       const v8::WeakCallbackData<T, _NanWeakCallbackInfo<T, P> >& data);
 632     _NanWeakCallbackInfo(v8::Handle<T> handle, P* param, Callback cb)
 633       : parameter(param), callback(cb) {
 634        NanAssignPersistent(persistent, handle);
 635     }
 636
 637     ~_NanWeakCallbackInfo() {
 638       persistent.Reset();
 639     }
 640
 641     P* const parameter;
 642     Callback const callback;
 643     v8::Persistent<T> persistent;
 644   };
 645
 646   template<typename T, typename P>
 647   class _NanWeakCallbackData {
 648    public:
 649     _NanWeakCallbackData(_NanWeakCallbackInfo<T, P> *info)
 650       : info_(info) { }
 651
 652     NAN_INLINE v8::Local<T> GetValue() const {
 653       return NanNew(info_->persistent);
 654     }
 655     NAN_INLINE P* GetParameter() const { return info_->parameter; }
 656     NAN_INLINE void Revive() const {
 657       info_->persistent.SetWeak(info_, info_->callback);
 658     }
 659
 660     NAN_INLINE void Dispose() const {
 661       delete info_;
 662     }
 663
 664    private:
 665     _NanWeakCallbackInfo<T, P>* info_;
 666   };
 667
 668 // do not use for declaration
 669 # define NAN_WEAK_CALLBACK(name)                                               \
 670     template<typename T, typename P>                                           \
 671     static void name(                                                          \
 672       const v8::WeakCallbackData<T, _NanWeakCallbackInfo<T, P> > &data) {      \
 673         _NanWeakCallbackData<T, P> wcbd(                                       \
 674            data.GetParameter());                                               \
 675         _Nan_Weak_Callback_ ## name(wcbd);                                     \
 676     }                                                                          \
 677                                                                                \
 678     template<typename T, typename P>                                           \
 679     NAN_INLINE void _Nan_Weak_Callback_ ## name(                               \
 680         const _NanWeakCallbackData<T, P> &data)
 681
 682 # define NanScope() v8::HandleScope scope(nan_isolate)
 683 # define NanEscapableScope() v8::EscapableHandleScope scope(nan_isolate)
 684 # define NanEscapeScope(val) scope.Escape(val)
 685 # define NanLocker() v8::Locker locker(nan_isolate)
 686 # define NanUnlocker() v8::Unlocker unlocker(nan_isolate)
 687 # define NanReturnValue(value) return args.GetReturnValue().Set(value)
 688 # define NanReturnUndefined() return
 689 # define NanReturnNull() return args.GetReturnValue().SetNull()
 690 # define NanReturnEmptyString() return args.GetReturnValue().SetEmptyString()
 691
 692 # define NanObjectWrapHandle(obj) obj->handle()
 693
 694 template<typename T, typename P>
 695 void NAN_INLINE NanMakeWeakPersistent(
 696     v8::Handle<T> handle
 697   , P* parameter
 698   , typename _NanWeakCallbackInfo<T, P>::Callback callback) {
 699     _NanWeakCallbackInfo<T, P> *cbinfo =
 700      new _NanWeakCallbackInfo<T, P>(handle, parameter, callback);
 701     cbinfo->persistent.SetWeak(cbinfo, callback);
 702 }
 703
 704 # define _NAN_ERROR(fun, errmsg) fun(NanNew<v8::String>(errmsg))
 705
 706 # define _NAN_THROW_ERROR(fun, errmsg)                                         \
 707     do {                                                                       \
 708       NanScope();                                                              \
 709       nan_isolate->ThrowException(_NAN_ERROR(fun, errmsg));                    \
 710     } while (0);
 711
 712   NAN_INLINE v8::Local<v8::Value> NanError(const char* errmsg) {
 713     return  _NAN_ERROR(v8::Exception::Error, errmsg);
 714   }
 715
 716   NAN_INLINE void NanThrowError(const char* errmsg) {
 717     _NAN_THROW_ERROR(v8::Exception::Error, errmsg);
 718   }
 719
 720   NAN_INLINE void NanThrowError(v8::Handle<v8::Value> error) {
 721     NanScope();
 722     nan_isolate->ThrowException(error);
 723   }
 724
 725   NAN_INLINE v8::Local<v8::Value> NanError(
 726       const char *msg
 727     , const int errorNumber
 728   ) {
 729     v8::Local<v8::Value> err = v8::Exception::Error(NanNew<v8::String>(msg));
 730     v8::Local<v8::Object> obj = err.As<v8::Object>();
 731     obj->Set(NanSymbol("code"), NanNew<v8::Integer>(errorNumber));
 732     return err;
 733   }
 734
 735   NAN_INLINE void NanThrowError(
 736       const char *msg
 737     , const int errorNumber
 738   ) {
 739     NanThrowError(NanError(msg, errorNumber));
 740   }
 741
 742   NAN_INLINE v8::Local<v8::Value> NanTypeError(const char* errmsg) {
 743     return _NAN_ERROR(v8::Exception::TypeError, errmsg);
 744   }
 745
 746   NAN_INLINE void NanThrowTypeError(const char* errmsg) {
 747     _NAN_THROW_ERROR(v8::Exception::TypeError, errmsg);
 748   }
 749
 750   NAN_INLINE v8::Local<v8::Value> NanRangeError(const char* errmsg) {
 751     return _NAN_ERROR(v8::Exception::RangeError, errmsg);
 752   }
 753
 754   NAN_INLINE void NanThrowRangeError(const char* errmsg) {
 755     _NAN_THROW_ERROR(v8::Exception::RangeError, errmsg);
 756   }
 757
 758   template<typename T> NAN_INLINE void NanDisposePersistent(
 759       v8::Persistent<T> &handle
 760   ) {
 761     handle.Reset();
 762   }
 763
 764   NAN_INLINE v8::Local<v8::Object> NanNewBufferHandle (
 765       char *data
 766     , size_t length
 767     , node::smalloc::FreeCallback callback
 768     , void *hint
 769   ) {
 770     return node::Buffer::New(nan_isolate, data, length, callback, hint);
 771   }
 772
 773   NAN_INLINE v8::Local<v8::Object> NanNewBufferHandle (
 774       const char *data
 775     , uint32_t size
 776   ) {
 777     return node::Buffer::New(nan_isolate, data, size);
 778   }
 779
 780   NAN_INLINE v8::Local<v8::Object> NanNewBufferHandle (uint32_t size) {
 781     return node::Buffer::New(nan_isolate, size);
 782   }
 783
 784   NAN_INLINE v8::Local<v8::Object> NanBufferUse(
 785       char* data
 786     , uint32_t size
 787   ) {
 788     return node::Buffer::Use(nan_isolate, data, size);
 789   }
 790
 791   NAN_INLINE bool NanHasInstance(
 792       v8::Persistent<v8::FunctionTemplate>& function_template
 793     , v8::Handle<v8::Value> value
 794   ) {
 795     return NanNew(function_template)->HasInstance(value);
 796   }
 797
 798   NAN_INLINE v8::Local<v8::Context> NanNewContextHandle(
 799       v8::ExtensionConfiguration* extensions = NULL
 800     , v8::Handle<v8::ObjectTemplate> tmpl = v8::Handle<v8::ObjectTemplate>()
 801     , v8::Handle<v8::Value> obj = v8::Handle<v8::Value>()
 802   ) {
 803     return v8::Local<v8::Context>::New(
 804         nan_isolate
 805       , v8::Context::New(nan_isolate, extensions, tmpl, obj)
 806     );
 807   }
 808
 809   NAN_INLINE v8::Local<NanBoundScript> NanCompileScript(
 810       v8::Local<v8::String> s
 811     , const v8::ScriptOrigin& origin
 812   ) {
 813     v8::ScriptCompiler::Source source(s, origin);
 814     return v8::ScriptCompiler::Compile(nan_isolate, &source);
 815   }
 816
 817   NAN_INLINE v8::Local<NanBoundScript> NanCompileScript(
 818       v8::Local<v8::String> s
 819   ) {
 820     v8::ScriptCompiler::Source source(s);
 821     return v8::ScriptCompiler::Compile(nan_isolate, &source);
 822   }
 823
 824   NAN_INLINE v8::Local<v8::Value> NanRunScript(
 825       v8::Local<NanUnboundScript> script
 826   ) {
 827     return script->BindToCurrentContext()->Run();
 828   }
 829
 830   NAN_INLINE v8::Local<v8::Value> NanRunScript(
 831       v8::Local<NanBoundScript> script
 832   ) {
 833     return script->Run();
 834   }
 835
 836 #else
 837 // Node 0.8 and 0.10
 838
 839 # define _NAN_METHOD_ARGS_TYPE const v8::Arguments&
 840 # define _NAN_METHOD_ARGS _NAN_METHOD_ARGS_TYPE args
 841 # define _NAN_METHOD_RETURN_TYPE v8::Handle<v8::Value>
 842
 843 # define _NAN_GETTER_ARGS_TYPE const v8::AccessorInfo &
 844 # define _NAN_GETTER_ARGS _NAN_GETTER_ARGS_TYPE args
 845 # define _NAN_GETTER_RETURN_TYPE v8::Handle<v8::Value>
 846
 847 # define _NAN_SETTER_ARGS_TYPE const v8::AccessorInfo &
 848 # define _NAN_SETTER_ARGS _NAN_SETTER_ARGS_TYPE args
 849 # define _NAN_SETTER_RETURN_TYPE void
 850
 851 # define _NAN_PROPERTY_GETTER_ARGS_TYPE const v8::AccessorInfo&
 852 # define _NAN_PROPERTY_GETTER_ARGS _NAN_PROPERTY_GETTER_ARGS_TYPE args
 853 # define _NAN_PROPERTY_GETTER_RETURN_TYPE v8::Handle<v8::Value>
 854
 855 # define _NAN_PROPERTY_SETTER_ARGS_TYPE const v8::AccessorInfo&
 856 # define _NAN_PROPERTY_SETTER_ARGS _NAN_PROPERTY_SETTER_ARGS_TYPE args
 857 # define _NAN_PROPERTY_SETTER_RETURN_TYPE v8::Handle<v8::Value>
 858
 859 # define _NAN_PROPERTY_ENUMERATOR_ARGS_TYPE const v8::AccessorInfo&
 860 # define _NAN_PROPERTY_ENUMERATOR_ARGS _NAN_PROPERTY_ENUMERATOR_ARGS_TYPE args
 861 # define _NAN_PROPERTY_ENUMERATOR_RETURN_TYPE v8::Handle<v8::Array>
 862
 863 # define _NAN_PROPERTY_DELETER_ARGS_TYPE const v8::AccessorInfo&
 864 # define _NAN_PROPERTY_DELETER_ARGS _NAN_PROPERTY_DELETER_ARGS_TYPE args
 865 # define _NAN_PROPERTY_DELETER_RETURN_TYPE v8::Handle<v8::Boolean>
 866
 867 # define _NAN_PROPERTY_QUERY_ARGS_TYPE const v8::AccessorInfo&
 868 # define _NAN_PROPERTY_QUERY_ARGS _NAN_PROPERTY_QUERY_ARGS_TYPE args
 869 # define _NAN_PROPERTY_QUERY_RETURN_TYPE v8::Handle<v8::Integer>
 870
 871 # define _NAN_INDEX_GETTER_ARGS_TYPE const v8::AccessorInfo&
 872 # define _NAN_INDEX_GETTER_ARGS _NAN_INDEX_GETTER_ARGS_TYPE args
 873 # define _NAN_INDEX_GETTER_RETURN_TYPE v8::Handle<v8::Value>
 874
 875 # define _NAN_INDEX_SETTER_ARGS_TYPE const v8::AccessorInfo&
 876 # define _NAN_INDEX_SETTER_ARGS _NAN_INDEX_SETTER_ARGS_TYPE args
 877 # define _NAN_INDEX_SETTER_RETURN_TYPE v8::Handle<v8::Value>
 878
 879 # define _NAN_INDEX_ENUMERATOR_ARGS_TYPE const v8::AccessorInfo&
 880 # define _NAN_INDEX_ENUMERATOR_ARGS _NAN_INDEX_ENUMERATOR_ARGS_TYPE args
 881 # define _NAN_INDEX_ENUMERATOR_RETURN_TYPE v8::Handle<v8::Array>
 882
 883 # define _NAN_INDEX_DELETER_ARGS_TYPE const v8::AccessorInfo&
 884 # define _NAN_INDEX_DELETER_ARGS _NAN_INDEX_DELETER_ARGS_TYPE args
 885 # define _NAN_INDEX_DELETER_RETURN_TYPE v8::Handle<v8::Boolean>
 886
 887 # define _NAN_INDEX_QUERY_ARGS_TYPE const v8::AccessorInfo&
 888 # define _NAN_INDEX_QUERY_ARGS _NAN_INDEX_QUERY_ARGS_TYPE args
 889 # define _NAN_INDEX_QUERY_RETURN_TYPE v8::Handle<v8::Integer>
 890
 891 typedef v8::InvocationCallback NanFunctionCallback;
 892
 893 # define NanUndefined() v8::Undefined()
 894 # define NanNull() v8::Null()
 895 # define NanTrue() v8::True()
 896 # define NanFalse() v8::False()
 897 # define NanAdjustExternalMemory(amount)                                       \
 898     v8::V8::AdjustAmountOfExternalAllocatedMemory(amount)
 899 # define NanSetTemplate(templ, name, value) templ->Set(name, value)
 900 # define NanGetCurrentContext() v8::Context::GetCurrent()
 901 # if NODE_VERSION_AT_LEAST(0, 8, 0)
 902 #  define NanMakeCallback(target, func, argc, argv)                            \
 903     node::MakeCallback(target, func, argc, argv)
 904 # else
 905 #  define NanMakeCallback(target, func, argc, argv)                            \
 906     do {                                                                       \
 907       v8::TryCatch try_catch;                                                  \
 908       func->Call(target, argc, argv);                                          \
 909       if (try_catch.HasCaught()) {                                             \
 910           v8::FatalException(try_catch);                                       \
 911       }                                                                        \
 912     } while (0)
 913 # endif
 914
 915 # define NanSymbol(value) v8::String::NewSymbol(value)
 916
 917   template<typename T>
 918   NAN_INLINE v8::Local<T> NanNew() {
 919     return v8::Local<T>::New(T::New());
 920   }
 921
 922   template<typename T>
 923   NAN_INLINE v8::Local<T> NanNew(v8::Handle<T> arg) {
 924     return v8::Local<T>::New(arg);
 925   }
 926
 927   template<typename T>
 928   NAN_INLINE v8::Local<v8::Signature> NanNew(
 929       v8::Handle<v8::FunctionTemplate> receiver
 930     , int argc
 931     , v8::Handle<v8::FunctionTemplate> argv[] = 0) {
 932     return v8::Signature::New(receiver, argc, argv);
 933   }
 934
 935   template<typename T>
 936   NAN_INLINE v8::Local<v8::FunctionTemplate> NanNew(
 937       NanFunctionCallback callback
 938     , v8::Handle<v8::Value> data = v8::Handle<v8::Value>()
 939     , v8::Handle<v8::Signature> signature = v8::Handle<v8::Signature>()) {
 940     return T::New(callback, data, signature);
 941   }
 942
 943   template<typename T>
 944   NAN_INLINE v8::Local<T> NanNew(const v8::Persistent<T> &arg) {
 945     return v8::Local<T>::New(arg);
 946   }
 947
 948   template<typename T, typename P>
 949   NAN_INLINE v8::Local<T> NanNew(P arg) {
 950     return v8::Local<T>::New(T::New(arg));
 951   }
 952
 953   template<typename T, typename P>
 954   NAN_INLINE v8::Local<T> NanNew(P arg, int length) {
 955     return v8::Local<T>::New(T::New(arg, length));
 956   }
 957
 958   template<typename T>
 959   NAN_INLINE v8::Local<v8::RegExp> NanNew(
 960       v8::Handle<v8::String> pattern, v8::RegExp::Flags flags) {
 961     return v8::RegExp::New(pattern, flags);
 962   }
 963
 964   template<typename T>
 965   NAN_INLINE v8::Local<v8::RegExp> NanNew(
 966       v8::Local<v8::String> pattern, v8::RegExp::Flags flags) {
 967     return v8::RegExp::New(pattern, flags);
 968   }
 969
 970   template<typename T, typename P>
 971   NAN_INLINE v8::Local<v8::RegExp> NanNew(
 972       v8::Handle<v8::String> pattern, v8::RegExp::Flags flags) {
 973     return v8::RegExp::New(pattern, flags);
 974   }
 975
 976   template<typename T, typename P>
 977   NAN_INLINE v8::Local<v8::RegExp> NanNew(
 978       v8::Local<v8::String> pattern, v8::RegExp::Flags flags) {
 979     return v8::RegExp::New(pattern, flags);
 980   }
 981
 982   template<>
 983   NAN_INLINE v8::Local<v8::Array> NanNew<v8::Array>() {
 984     return v8::Array::New();
 985   }
 986
 987   template<>
 988   NAN_INLINE v8::Local<v8::Array> NanNew<v8::Array>(int length) {
 989     return v8::Array::New(length);
 990   }
 991
 992
 993   template<>
 994   NAN_INLINE v8::Local<v8::Date> NanNew<v8::Date>(double time) {
 995     return v8::Date::New(time).As<v8::Date>();
 996   }
 997
 998   template<>
 999   NAN_INLINE v8::Local<v8::Date> NanNew<v8::Date>(int time) {
1000     return v8::Date::New(time).As<v8::Date>();
1001   }
1002
1003   typedef v8::Script NanUnboundScript;
1004   typedef v8::Script NanBoundScript;
1005
1006   template<typename T, typename P>
1007   NAN_INLINE v8::Local<T> NanNew(
1008       P s
1009     , const v8::ScriptOrigin& origin
1010   ) {
1011     return v8::Script::New(s, const_cast<v8::ScriptOrigin *>(&origin));
1012   }
1013
1014   template<>
1015   NAN_INLINE v8::Local<NanUnboundScript> NanNew<NanUnboundScript>(
1016       v8::Local<v8::String> s
1017   ) {
1018     return v8::Script::New(s);
1019   }
1020
1021   NAN_INLINE v8::Local<v8::String> NanNew(
1022       v8::String::ExternalStringResource *resource) {
1023     return v8::String::NewExternal(resource);
1024   }
1025
1026   NAN_INLINE v8::Local<v8::String> NanNew(
1027       v8::String::ExternalAsciiStringResource *resource) {
1028     return v8::String::NewExternal(resource);
1029   }
1030
1031   template<>
1032   NAN_INLINE v8::Local<v8::BooleanObject> NanNew(bool value) {
1033     return v8::BooleanObject::New(value).As<v8::BooleanObject>();
1034   }
1035
1036   template<>
1037   NAN_INLINE v8::Local<v8::StringObject>
1038   NanNew<v8::StringObject, v8::Local<v8::String> >(
1039       v8::Local<v8::String> value) {
1040     return v8::StringObject::New(value).As<v8::StringObject>();
1041   }
1042
1043   template<>
1044   NAN_INLINE v8::Local<v8::StringObject>
1045   NanNew<v8::StringObject, v8::Handle<v8::String> >(
1046       v8::Handle<v8::String> value) {
1047     return v8::StringObject::New(value).As<v8::StringObject>();
1048   }
1049
1050   template<>
1051   NAN_INLINE v8::Local<v8::NumberObject> NanNew<v8::NumberObject>(double val) {
1052     return v8::NumberObject::New(val).As<v8::NumberObject>();
1053   }
1054
1055   template<>
1056   NAN_INLINE v8::Local<v8::Uint32> NanNew<v8::Uint32, int32_t>(int32_t val) {
1057     return v8::Uint32::NewFromUnsigned(val)->ToUint32();
1058   }
1059
1060   template<>
1061   NAN_INLINE v8::Local<v8::Uint32> NanNew<v8::Uint32, uint32_t>(uint32_t val) {
1062     return v8::Uint32::NewFromUnsigned(val)->ToUint32();
1063   }
1064
1065   template<>
1066   NAN_INLINE v8::Local<v8::Int32> NanNew<v8::Int32, int32_t>(int32_t val) {
1067     return v8::Int32::New(val)->ToInt32();
1068   }
1069
1070   template<>
1071   NAN_INLINE v8::Local<v8::Int32> NanNew<v8::Int32, uint32_t>(uint32_t val) {
1072     return v8::Int32::New(val)->ToInt32();
1073   }
1074
1075   template<>
1076   NAN_INLINE v8::Local<v8::String> NanNew<v8::String, uint8_t *>(
1077       uint8_t *arg
1078     , int length) {
1079     uint16_t *warg = new uint16_t[length];
1080     for (int i = 0; i < length; i++) {
1081       warg[i] = arg[i];
1082     }
1083     v8::Local<v8::String> retval = v8::String::New(warg, length);
1084     delete[] warg;
1085     return retval;
1086   }
1087
1088   template<>
1089   NAN_INLINE v8::Local<v8::String> NanNew<v8::String, const uint8_t *>(
1090       const uint8_t *arg
1091     , int length) {
1092     uint16_t *warg = new uint16_t[length];
1093     for (int i = 0; i < length; i++) {
1094       warg[i] = arg[i];
1095     }
1096     v8::Local<v8::String> retval = v8::String::New(warg, length);
1097     delete[] warg;
1098     return retval;
1099   }
1100
1101   template<>
1102   NAN_INLINE v8::Local<v8::String> NanNew<v8::String, uint8_t *>(uint8_t *arg) {
1103     int length = strlen(reinterpret_cast<char *>(arg));
1104     uint16_t *warg = new uint16_t[length];
1105     for (int i = 0; i < length; i++) {
1106       warg[i] = arg[i];
1107     }
1108
1109     v8::Local<v8::String> retval = v8::String::New(warg, length);
1110     delete[] warg;
1111     return retval;
1112   }
1113
1114   template<>
1115   NAN_INLINE v8::Local<v8::String> NanNew<v8::String, const uint8_t *>(
1116       const uint8_t *arg) {
1117     int length = strlen(reinterpret_cast<const char *>(arg));
1118     uint16_t *warg = new uint16_t[length];
1119     for (int i = 0; i < length; i++) {
1120       warg[i] = arg[i];
1121     }
1122     v8::Local<v8::String> retval = v8::String::New(warg, length);
1123     delete[] warg;
1124     return retval;
1125   }
1126
1127   template<>
1128   NAN_INLINE v8::Local<v8::String> NanNew<v8::String>() {
1129     return v8::String::Empty();
1130   }
1131
1132   NAN_INLINE void NanAddGCEpilogueCallback(
1133     v8::GCEpilogueCallback callback
1134   , v8::GCType gc_type_filter = v8::kGCTypeAll) {
1135     v8::V8::AddGCEpilogueCallback(callback, gc_type_filter);
1136   }
1137   NAN_INLINE void NanRemoveGCEpilogueCallback(
1138     v8::GCEpilogueCallback callback) {
1139     v8::V8::RemoveGCEpilogueCallback(callback);
1140   }
1141   NAN_INLINE void NanAddGCPrologueCallback(
1142     v8::GCPrologueCallback callback
1143   , v8::GCType gc_type_filter = v8::kGCTypeAll) {
1144     v8::V8::AddGCPrologueCallback(callback, gc_type_filter);
1145   }
1146   NAN_INLINE void NanRemoveGCPrologueCallback(
1147     v8::GCPrologueCallback callback) {
1148     v8::V8::RemoveGCPrologueCallback(callback);
1149   }
1150   NAN_INLINE void NanGetHeapStatistics(
1151     v8::HeapStatistics *heap_statistics) {
1152     v8::V8::GetHeapStatistics(heap_statistics);
1153   }
1154
1155   template<typename T>
1156   NAN_INLINE void NanAssignPersistent(
1157       v8::Persistent<T>& handle
1158     , v8::Handle<T> obj) {
1159       handle.Dispose();
1160       handle = v8::Persistent<T>::New(obj);
1161   }
1162
1163   template<typename T, typename P>
1164   struct _NanWeakCallbackInfo {
1165     typedef void (*Callback)(v8::Persistent<v8::Value> object, void* parameter);
1166     _NanWeakCallbackInfo(v8::Handle<T> handle, P* param, Callback cb) :
1167         parameter(param)
1168       , callback(cb)
1169       , persistent(v8::Persistent<T>::New(handle)) { }
1170
1171     ~_NanWeakCallbackInfo() {
1172       persistent.Dispose();
1173       persistent.Clear();
1174     }
1175
1176     P* const parameter;
1177     Callback const callback;
1178     v8::Persistent<T> persistent;
1179   };
1180
1181   template<typename T, typename P>
1182   class _NanWeakCallbackData {
1183    public:
1184     _NanWeakCallbackData(_NanWeakCallbackInfo<T, P> *info)
1185       : info_(info) { }
1186
1187     NAN_INLINE v8::Local<T> GetValue() const {
1188       return NanNew(info_->persistent);
1189     }
1190     NAN_INLINE P* GetParameter() const { return info_->parameter; }
1191     NAN_INLINE void Revive() const {
1192       info_->persistent.MakeWeak(info_, info_->callback);
1193     }
1194     NAN_INLINE void Dispose() const {
1195       delete info_;
1196     }
1197
1198    private:
1199     _NanWeakCallbackInfo<T, P>* info_;
1200   };
1201
1202 # define NanGetInternalFieldPointer(object, index)                             \
1203     object->GetPointerFromInternalField(index)
1204 # define NanSetInternalFieldPointer(object, index, value)                      \
1205     object->SetPointerInInternalField(index, value)
1206
1207 // do not use for declaration
1208 # define NAN_WEAK_CALLBACK(name)                                               \
1209     template<typename T, typename P>                                           \
1210     static void name(                                                          \
1211       v8::Persistent<v8::Value> object, void *data) {                          \
1212         _NanWeakCallbackData<T, P> wcbd(                                       \
1213            static_cast<_NanWeakCallbackInfo<T, P>*>(data));                    \
1214         _Nan_Weak_Callback_ ## name(wcbd);                                     \
1215     }                                                                          \
1216                                                                                \
1217     template<typename T, typename P>                                           \
1218     NAN_INLINE void _Nan_Weak_Callback_ ## name(                               \
1219         const _NanWeakCallbackData<T, P> &data)
1220
1221   template<typename T, typename P>
1222   NAN_INLINE void NanMakeWeakPersistent(
1223     v8::Handle<T> handle
1224   , P* parameter
1225   , typename _NanWeakCallbackInfo<T, P>::Callback callback) {
1226       _NanWeakCallbackInfo<T, P> *cbinfo =
1227         new _NanWeakCallbackInfo<T, P>(handle, parameter, callback);
1228       cbinfo->persistent.MakeWeak(cbinfo, callback);
1229   }
1230
1231 # define NanScope() v8::HandleScope scope
1232 # define NanEscapableScope() v8::HandleScope scope
1233 # define NanEscapeScope(val) scope.Close(val)
1234 # define NanLocker() v8::Locker locker
1235 # define NanUnlocker() v8::Unlocker unlocker
1236 # define NanReturnValue(value) return scope.Close(value)
1237 # define NanReturnUndefined() return v8::Undefined()
1238 # define NanReturnNull() return v8::Null()
1239 # define NanReturnEmptyString() return v8::String::Empty()
1240 # define NanObjectWrapHandle(obj) v8::Local<v8::Object>::New(obj->handle_)
1241
1242 # define _NAN_ERROR(fun, errmsg)                                               \
1243     fun(v8::String::New(errmsg))
1244
1245 # define _NAN_THROW_ERROR(fun, errmsg)                                         \
1246     do {                                                                       \
1247       NanScope();                                                              \
1248       return v8::Local<v8::Value>::New(                                        \
1249         v8::ThrowException(_NAN_ERROR(fun, errmsg)));                          \
1250     } while (0);
1251
1252   NAN_INLINE v8::Local<v8::Value> NanError(const char* errmsg) {
1253     return _NAN_ERROR(v8::Exception::Error, errmsg);
1254   }
1255
1256   NAN_INLINE v8::Local<v8::Value> NanThrowError(const char* errmsg) {
1257     _NAN_THROW_ERROR(v8::Exception::Error, errmsg);
1258   }
1259
1260   NAN_INLINE v8::Local<v8::Value> NanThrowError(
1261       v8::Handle<v8::Value> error
1262   ) {
1263     NanScope();
1264     return v8::Local<v8::Value>::New(v8::ThrowException(error));
1265   }
1266
1267   NAN_INLINE v8::Local<v8::Value> NanError(
1268       const char *msg
1269     , const int errorNumber
1270   ) {
1271     v8::Local<v8::Value> err = v8::Exception::Error(v8::String::New(msg));
1272     v8::Local<v8::Object> obj = err.As<v8::Object>();
1273     obj->Set(v8::String::New("code"), v8::Int32::New(errorNumber));
1274     return err;
1275   }
1276
1277   NAN_INLINE v8::Local<v8::Value> NanThrowError(
1278       const char *msg
1279     , const int errorNumber
1280   ) {
1281     return NanThrowError(NanError(msg, errorNumber));
1282   }
1283
1284   NAN_INLINE v8::Local<v8::Value> NanTypeError(const char* errmsg) {
1285     return _NAN_ERROR(v8::Exception::TypeError, errmsg);
1286   }
1287
1288   NAN_INLINE v8::Local<v8::Value> NanThrowTypeError(
1289       const char* errmsg
1290   ) {
1291     _NAN_THROW_ERROR(v8::Exception::TypeError, errmsg);
1292   }
1293
1294   NAN_INLINE v8::Local<v8::Value> NanRangeError(
1295       const char* errmsg
1296   ) {
1297     return _NAN_ERROR(v8::Exception::RangeError, errmsg);
1298   }
1299
1300   NAN_INLINE v8::Local<v8::Value> NanThrowRangeError(
1301       const char* errmsg
1302   ) {
1303     _NAN_THROW_ERROR(v8::Exception::RangeError, errmsg);
1304   }
1305
1306   template<typename T>
1307   NAN_INLINE void NanDisposePersistent(
1308       v8::Persistent<T> &handle) {  // NOLINT(runtime/references)
1309     handle.Dispose();
1310     handle.Clear();
1311   }
1312
1313   NAN_INLINE v8::Local<v8::Object> NanNewBufferHandle (
1314       char *data
1315     , size_t length
1316     , node::Buffer::free_callback callback
1317     , void *hint
1318   ) {
1319     return NanNew<v8::Object>(
1320         node::Buffer::New(data, length, callback, hint)->handle_);
1321   }
1322
1323   NAN_INLINE v8::Local<v8::Object> NanNewBufferHandle (
1324       const char *data
1325     , uint32_t size
1326   ) {
1327 #if NODE_MODULE_VERSION >= 0x000B
1328     return NanNew<v8::Object>(node::Buffer::New(data, size)->handle_);
1329 #else
1330     return NanNew<v8::Object>(
1331       node::Buffer::New(const_cast<char*>(data), size)->handle_);
1332 #endif
1333   }
1334
1335   NAN_INLINE v8::Local<v8::Object> NanNewBufferHandle (uint32_t size) {
1336     return NanNew<v8::Object>(node::Buffer::New(size)->handle_);
1337   }
1338
1339   NAN_INLINE void FreeData(char *data, void *hint) {
1340     delete[] data;
1341   }
1342
1343   NAN_INLINE v8::Local<v8::Object> NanBufferUse(
1344       char* data
1345     , uint32_t size
1346   ) {
1347     return NanNew<v8::Object>(
1348         node::Buffer::New(data, size, FreeData, NULL)->handle_);
1349   }
1350
1351   NAN_INLINE bool NanHasInstance(
1352       v8::Persistent<v8::FunctionTemplate>& function_template
1353     , v8::Handle<v8::Value> value
1354   ) {
1355     return function_template->HasInstance(value);
1356   }
1357
1358   NAN_INLINE v8::Local<v8::Context> NanNewContextHandle(
1359       v8::ExtensionConfiguration* extensions = NULL
1360     , v8::Handle<v8::ObjectTemplate> tmpl = v8::Handle<v8::ObjectTemplate>()
1361     , v8::Handle<v8::Value> obj = v8::Handle<v8::Value>()
1362   ) {
1363     v8::Persistent<v8::Context> ctx = v8::Context::New(extensions, tmpl, obj);
1364     v8::Local<v8::Context> lctx = NanNew<v8::Context>(ctx);
1365     ctx.Dispose();
1366     return lctx;
1367   }
1368
1369   NAN_INLINE v8::Local<NanBoundScript> NanCompileScript(
1370       v8::Local<v8::String> s
1371     , const v8::ScriptOrigin& origin
1372   ) {
1373     return v8::Script::Compile(s, const_cast<v8::ScriptOrigin *>(&origin));
1374   }
1375
1376   NAN_INLINE v8::Local<NanBoundScript> NanCompileScript(
1377     v8::Local<v8::String> s
1378   ) {
1379     return v8::Script::Compile(s);
1380   }
1381
1382   NAN_INLINE v8::Local<v8::Value> NanRunScript(v8::Local<v8::Script> script) {
1383     return script->Run();
1384   }
1385
1386 #endif  // NODE_MODULE_VERSION
1387
1388 typedef void (*NanFreeCallback)(char *data, void *hint);
1389
1390 #define NAN_METHOD(name) _NAN_METHOD_RETURN_TYPE name(_NAN_METHOD_ARGS)
1391 #define NAN_GETTER(name)                                                       \
1392     _NAN_GETTER_RETURN_TYPE name(                                              \
1393         v8::Local<v8::String> property                                         \
1394       , _NAN_GETTER_ARGS)
1395 #define NAN_SETTER(name)                                                       \
1396     _NAN_SETTER_RETURN_TYPE name(                                              \
1397         v8::Local<v8::String> property                                         \
1398       , v8::Local<v8::Value> value                                             \
1399       , _NAN_SETTER_ARGS)
1400 #define NAN_PROPERTY_GETTER(name)                                              \
1401     _NAN_PROPERTY_GETTER_RETURN_TYPE name(                                     \
1402         v8::Local<v8::String> property                                         \
1403       , _NAN_PROPERTY_GETTER_ARGS)
1404 #define NAN_PROPERTY_SETTER(name)                                              \
1405     _NAN_PROPERTY_SETTER_RETURN_TYPE name(                                     \
1406         v8::Local<v8::String> property                                         \
1407       , v8::Local<v8::Value> value                                             \
1408       , _NAN_PROPERTY_SETTER_ARGS)
1409 #define NAN_PROPERTY_ENUMERATOR(name)                                          \
1410     _NAN_PROPERTY_ENUMERATOR_RETURN_TYPE name(_NAN_PROPERTY_ENUMERATOR_ARGS)
1411 #define NAN_PROPERTY_DELETER(name)                                             \
1412     _NAN_PROPERTY_DELETER_RETURN_TYPE name(                                    \
1413         v8::Local<v8::String> property                                         \
1414       , _NAN_PROPERTY_DELETER_ARGS)
1415 #define NAN_PROPERTY_QUERY(name)                                               \
1416     _NAN_PROPERTY_QUERY_RETURN_TYPE name(                                      \
1417         v8::Local<v8::String> property                                         \
1418       , _NAN_PROPERTY_QUERY_ARGS)
1419 # define NAN_INDEX_GETTER(name)                                                \
1420     _NAN_INDEX_GETTER_RETURN_TYPE name(uint32_t index, _NAN_INDEX_GETTER_ARGS)
1421 #define NAN_INDEX_SETTER(name)                                                 \
1422     _NAN_INDEX_SETTER_RETURN_TYPE name(                                        \
1423         uint32_t index                                                         \
1424       , v8::Local<v8::Value> value                                             \
1425       , _NAN_INDEX_SETTER_ARGS)
1426 #define NAN_INDEX_ENUMERATOR(name)                                             \
1427     _NAN_INDEX_ENUMERATOR_RETURN_TYPE name(_NAN_INDEX_ENUMERATOR_ARGS)
1428 #define NAN_INDEX_DELETER(name)                                                \
1429     _NAN_INDEX_DELETER_RETURN_TYPE name(                                       \
1430         uint32_t index                                                         \
1431       , _NAN_INDEX_DELETER_ARGS)
1432 #define NAN_INDEX_QUERY(name)                                                  \
1433     _NAN_INDEX_QUERY_RETURN_TYPE name(uint32_t index, _NAN_INDEX_QUERY_ARGS)
1434
1435 class NanCallback {
1436  public:
1437   NanCallback() {
1438     NanScope();
1439     v8::Local<v8::Object> obj = NanNew<v8::Object>();
1440     NanAssignPersistent(handle, obj);
1441   }
1442
1443   explicit NanCallback(const v8::Handle<v8::Function> &fn) {
1444     NanScope();
1445     v8::Local<v8::Object> obj = NanNew<v8::Object>();
1446     NanAssignPersistent(handle, obj);
1447     SetFunction(fn);
1448   }
1449
1450   ~NanCallback() {
1451     if (handle.IsEmpty()) return;
1452     NanDisposePersistent(handle);
1453   }
1454
1455   NAN_INLINE void SetFunction(const v8::Handle<v8::Function> &fn) {
1456     NanScope();
1457     NanNew(handle)->Set(NanSymbol("callback"), fn);
1458   }
1459
1460   NAN_INLINE v8::Local<v8::Function> GetFunction () {
1461     return NanNew(handle)->Get(NanSymbol("callback"))
1462         .As<v8::Function>();
1463   }
1464
1465   void Call(int argc, v8::Handle<v8::Value> argv[]) {
1466     NanScope();
1467 #if (NODE_MODULE_VERSION > 0x000B)  // 0.11.12+
1468     v8::Local<v8::Function> callback = NanNew(handle)->
1469         Get(NanSymbol("callback")).As<v8::Function>();
1470     node::MakeCallback(
1471         nan_isolate
1472       , nan_isolate->GetCurrentContext()->Global()
1473       , callback
1474       , argc
1475       , argv
1476     );
1477 #else
1478 #if NODE_VERSION_AT_LEAST(0, 8, 0)
1479     v8::Local<v8::Function> callback = NanNew(handle)->
1480         Get(NanSymbol("callback")).As<v8::Function>();
1481     node::MakeCallback(
1482         v8::Context::GetCurrent()->Global()
1483       , callback
1484       , argc
1485       , argv
1486     );
1487 #else
1488     node::MakeCallback(handle, "callback", argc, argv);
1489 #endif
1490 #endif
1491   }
1492
1493  private:
1494   v8::Persistent<v8::Object> handle;
1495 };
1496
1497 /* abstract */ class NanAsyncWorker {
1498  public:
1499   explicit NanAsyncWorker(NanCallback *callback) : callback(callback) {
1500     request.data = this;
1501     errmsg = NULL;
1502
1503     NanScope();
1504     v8::Local<v8::Object> obj = NanNew<v8::Object>();
1505     NanAssignPersistent(persistentHandle, obj);
1506   }
1507
1508   virtual ~NanAsyncWorker() {
1509     NanScope();
1510
1511     if (!persistentHandle.IsEmpty())
1512       NanDisposePersistent(persistentHandle);
1513     if (callback)
1514       delete callback;
1515     if (errmsg)
1516       delete errmsg;
1517   }
1518
1519   virtual void WorkComplete() {
1520     NanScope();
1521
1522     if (errmsg == NULL)
1523       HandleOKCallback();
1524     else
1525       HandleErrorCallback();
1526     delete callback;
1527     callback = NULL;
1528   }
1529
1530   NAN_INLINE void SaveToPersistent(const char *key, v8::Local<v8::Object> &obj) {
1531     v8::Local<v8::Object> handle = NanNew(persistentHandle);
1532     handle->Set(NanSymbol(key), obj);
1533   }
1534
1535   v8::Local<v8::Object> GetFromPersistent(const char *key) {
1536     NanEscapableScope();
1537     v8::Local<v8::Object> handle = NanNew(persistentHandle);
1538     return NanEscapeScope(handle->Get(NanSymbol(key)).As<v8::Object>());
1539   }
1540
1541   virtual void Execute() = 0;
1542
1543   uv_work_t request;
1544
1545  protected:
1546   v8::Persistent<v8::Object> persistentHandle;
1547   NanCallback *callback;
1548   const char *errmsg;
1549
1550   virtual void HandleOKCallback() {
1551     NanScope();
1552
1553     callback->Call(0, NULL);
1554   }
1555
1556   virtual void HandleErrorCallback() {
1557     NanScope();
1558
1559     v8::Local<v8::Value> argv[] = {
1560         v8::Exception::Error(NanNew<v8::String>(errmsg))
1561     };
1562     callback->Call(1, argv);
1563   }
1564 };
1565
1566 NAN_INLINE void NanAsyncExecute (uv_work_t* req) {
1567   NanAsyncWorker *worker = static_cast<NanAsyncWorker*>(req->data);
1568   worker->Execute();
1569 }
1570
1571 NAN_INLINE void NanAsyncExecuteComplete (uv_work_t* req) {
1572   NanAsyncWorker* worker = static_cast<NanAsyncWorker*>(req->data);
1573   worker->WorkComplete();
1574   delete worker;
1575 }
1576
1577 NAN_INLINE void NanAsyncQueueWorker (NanAsyncWorker* worker) {
1578   uv_queue_work(
1579       uv_default_loop()
1580     , &worker->request
1581     , NanAsyncExecute
1582     , (uv_after_work_cb)NanAsyncExecuteComplete
1583   );
1584 }
1585
1586 //// Base 64 ////
1587
1588 #define _nan_base64_encoded_size(size) ((size + 2 - ((size + 2) % 3)) / 3 * 4)
1589
1590 // Doesn't check for padding at the end.  Can be 1-2 bytes over.
1591 NAN_INLINE size_t _nan_base64_decoded_size_fast(size_t size) {
1592   size_t remainder = size % 4;
1593
1594   size = (size / 4) * 3;
1595   if (remainder) {
1596     if (size == 0 && remainder == 1) {
1597       // special case: 1-byte input cannot be decoded
1598       size = 0;
1599     } else {
1600       // non-padded input, add 1 or 2 extra bytes
1601       size += 1 + (remainder == 3);
1602     }
1603   }
1604
1605   return size;
1606 }
1607
1608 template<typename T>
1609 NAN_INLINE size_t _nan_base64_decoded_size(
1610     const T* src
1611   , size_t size
1612 ) {
1613   if (size == 0)
1614     return 0;
1615
1616   if (src[size - 1] == '=')
1617     size--;
1618   if (size > 0 && src[size - 1] == '=')
1619     size--;
1620
1621   return _nan_base64_decoded_size_fast(size);
1622 }
1623
1624 // supports regular and URL-safe base64
1625 static const int _nan_unbase64_table[] = {
1626     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -2, -1, -1, -2, -1, -1
1627   , -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
1628   , -2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, 62, -1, 63
1629   , 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1
1630   , -1,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14
1631   , 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, 63
1632   , -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40
1633   , 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1
1634   , -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
1635   , -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
1636   , -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
1637   , -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
1638   , -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
1639   , -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
1640   , -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
1641   , -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
1642 };
1643
1644 #define _nan_unbase64(x) _nan_unbase64_table[(uint8_t)(x)]
1645
1646 template<typename T> static size_t _nan_base64_decode(
1647     char* buf
1648   , size_t len
1649   , const T* src
1650   , const size_t srcLen
1651 ) {
1652   char* dst = buf;
1653   char* dstEnd = buf + len;
1654   const T* srcEnd = src + srcLen;
1655
1656   while (src < srcEnd && dst < dstEnd) {
1657     ptrdiff_t remaining = srcEnd - src;
1658     char a, b, c, d;
1659
1660     while (_nan_unbase64(*src) < 0 && src < srcEnd) src++, remaining--;
1661     if (remaining == 0 || *src == '=') break;
1662     a = _nan_unbase64(*src++);
1663
1664     while (_nan_unbase64(*src) < 0 && src < srcEnd) src++, remaining--;
1665     if (remaining <= 1 || *src == '=') break;
1666     b = _nan_unbase64(*src++);
1667
1668     *dst++ = (a << 2) | ((b & 0x30) >> 4);
1669     if (dst == dstEnd) break;
1670
1671     while (_nan_unbase64(*src) < 0 && src < srcEnd) src++, remaining--;
1672     if (remaining <= 2 || *src == '=') break;
1673     c = _nan_unbase64(*src++);
1674
1675     *dst++ = ((b & 0x0F) << 4) | ((c & 0x3C) >> 2);
1676     if (dst == dstEnd) break;
1677
1678     while (_nan_unbase64(*src) < 0 && src < srcEnd) src++, remaining--;
1679     if (remaining <= 3 || *src == '=') break;
1680     d = _nan_unbase64(*src++);
1681
1682     *dst++ = ((c & 0x03) << 6) | (d & 0x3F);
1683   }
1684
1685   return dst - buf;
1686 }
1687
1688 //// HEX ////
1689
1690 template<typename T> unsigned _nan_hex2bin(T c) {
1691   if (c >= '0' && c <= '9') return c - '0';
1692   if (c >= 'A' && c <= 'F') return 10 + (c - 'A');
1693   if (c >= 'a' && c <= 'f') return 10 + (c - 'a');
1694   return static_cast<unsigned>(-1);
1695 }
1696
1697 template<typename T> static size_t _nan_hex_decode(
1698     char* buf
1699   , size_t len
1700   , const T* src
1701   , const size_t srcLen
1702 ) {
1703   size_t i;
1704   for (i = 0; i < len && i * 2 + 1 < srcLen; ++i) {
1705     unsigned a = _nan_hex2bin(src[i * 2 + 0]);
1706     unsigned b = _nan_hex2bin(src[i * 2 + 1]);
1707     if (!~a || !~b) return i;
1708     buf[i] = a * 16 + b;
1709   }
1710
1711   return i;
1712 }
1713
1714 static bool _NanGetExternalParts(
1715     v8::Handle<v8::Value> val
1716   , const char** data
1717   , size_t* len
1718 ) {
1719   if (node::Buffer::HasInstance(val)) {
1720     *data = node::Buffer::Data(val.As<v8::Object>());
1721     *len = node::Buffer::Length(val.As<v8::Object>());
1722     return true;
1723   }
1724
1725   assert(val->IsString());
1726   v8::Local<v8::String> str = NanNew<v8::String>(val.As<v8::String>());
1727
1728   if (str->IsExternalAscii()) {
1729     const v8::String::ExternalAsciiStringResource* ext;
1730     ext = str->GetExternalAsciiStringResource();
1731     *data = ext->data();
1732     *len = ext->length();
1733     return true;
1734
1735   } else if (str->IsExternal()) {
1736     const v8::String::ExternalStringResource* ext;
1737     ext = str->GetExternalStringResource();
1738     *data = reinterpret_cast<const char*>(ext->data());
1739     *len = ext->length();
1740     return true;
1741   }
1742
1743   return false;
1744 }
1745
1746 namespace Nan {
1747   enum Encoding {ASCII, UTF8, BASE64, UCS2, BINARY, HEX, BUFFER};
1748 }
1749
1750 NAN_INLINE void* NanRawString(
1751     v8::Handle<v8::Value> from
1752   , enum Nan::Encoding encoding
1753   , size_t *datalen
1754   , void *buf
1755   , size_t buflen
1756   , int flags
1757 ) {
1758   NanScope();
1759
1760   size_t sz_;
1761   size_t term_len = !(flags & v8::String::NO_NULL_TERMINATION);
1762   char *data = NULL;
1763   size_t len;
1764   bool is_extern = _NanGetExternalParts(
1765       from
1766     , const_cast<const char**>(&data)
1767     , &len);
1768
1769   if (is_extern && !term_len) {
1770     NanSetPointerSafe(datalen, len);
1771     return data;
1772   }
1773
1774   v8::Local<v8::String> toStr = from->ToString();
1775
1776   char *to = static_cast<char *>(buf);
1777
1778   switch (encoding) {
1779     case Nan::ASCII:
1780 #if NODE_MODULE_VERSION < 0x000C
1781       sz_ = toStr->Length();
1782       if (to == NULL) {
1783         to = new char[sz_ + term_len];
1784       } else {
1785         assert(buflen >= sz_ + term_len && "too small buffer");
1786       }
1787       NanSetPointerSafe<size_t>(
1788           datalen
1789         , toStr->WriteAscii(to, 0, static_cast<int>(sz_ + term_len), flags));
1790       return to;
1791 #endif
1792     case Nan::BINARY:
1793     case Nan::BUFFER:
1794       sz_ = toStr->Length();
1795       if (to == NULL) {
1796         to = new char[sz_ + term_len];
1797       } else {
1798         assert(buflen >= sz_ + term_len && "too small buffer");
1799       }
1800 #if NODE_MODULE_VERSION < 0x000C
1801       {
1802         uint16_t* twobytebuf = new uint16_t[sz_ + term_len];
1803
1804         size_t len = toStr->Write(twobytebuf, 0,
1805           static_cast<int>(sz_ + term_len), flags);
1806
1807         for (size_t i = 0; i < sz_ + term_len && i < len + term_len; i++) {
1808           unsigned char *b = reinterpret_cast<unsigned char*>(&twobytebuf[i]);
1809           to[i] = *b;
1810         }
1811
1812         NanSetPointerSafe<size_t>(datalen, len);
1813
1814         delete[] twobytebuf;
1815         return to;
1816       }
1817 #else
1818       NanSetPointerSafe<size_t>(
1819         datalen,
1820         toStr->WriteOneByte(
1821             reinterpret_cast<uint8_t *>(to)
1822           , 0
1823           , static_cast<int>(sz_ + term_len)
1824           , flags));
1825       return to;
1826 #endif
1827     case Nan::UTF8:
1828       sz_ = toStr->Utf8Length();
1829       if (to == NULL) {
1830         to = new char[sz_ + term_len];
1831       } else {
1832         assert(buflen >= sz_ + term_len && "too small buffer");
1833       }
1834       NanSetPointerSafe<size_t>(
1835           datalen
1836         , toStr->WriteUtf8(to, static_cast<int>(sz_ + term_len)
1837             , NULL, flags)
1838           - term_len);
1839       return to;
1840     case Nan::BASE64:
1841       {
1842         v8::String::Value value(toStr);
1843         sz_ = _nan_base64_decoded_size(*value, value.length());
1844         if (to == NULL) {
1845           to = new char[sz_ + term_len];
1846         } else {
1847           assert(buflen >= sz_ + term_len);
1848         }
1849         NanSetPointerSafe<size_t>(
1850             datalen
1851           , _nan_base64_decode(to, sz_, *value, value.length()));
1852         if (term_len) {
1853           to[sz_] = '\0';
1854         }
1855         return to;
1856       }
1857     case Nan::UCS2:
1858       {
1859         sz_ = toStr->Length();
1860         if (to == NULL) {
1861           to = new char[(sz_ + term_len) * 2];
1862         } else {
1863           assert(buflen >= (sz_ + term_len) * 2 && "too small buffer");
1864         }
1865
1866         int bc = 2 * toStr->Write(
1867             reinterpret_cast<uint16_t *>(to)
1868           , 0
1869           , static_cast<int>(sz_ + term_len)
1870           , flags);
1871         NanSetPointerSafe<size_t>(datalen, bc);
1872         return to;
1873       }
1874     case Nan::HEX:
1875       {
1876         v8::String::Value value(toStr);
1877         sz_ = value.length();
1878         assert(!(sz_ & 1) && "bad hex data");
1879         if (to == NULL) {
1880           to = new char[sz_ / 2 + term_len];
1881         } else {
1882           assert(buflen >= sz_ / 2 + term_len && "too small buffer");
1883         }
1884         NanSetPointerSafe<size_t>(
1885             datalen
1886           , _nan_hex_decode(to, sz_ / 2, *value, value.length()));
1887       }
1888       if (term_len) {
1889         to[sz_ / 2] = '\0';
1890       }
1891       return to;
1892     default:
1893       assert(0 && "unknown encoding");
1894   }
1895   return to;
1896 }
1897
1898 NAN_INLINE char* NanCString(
1899     v8::Handle<v8::Value> from
1900   , size_t *datalen
1901   , char *buf = NULL
1902   , size_t buflen = 0
1903   , int flags = v8::String::NO_OPTIONS
1904 ) {
1905     return static_cast<char *>(
1906       NanRawString(from, Nan::UTF8, datalen, buf, buflen, flags)
1907     );
1908 }
1909
1910 #endif  // NAN_H_