/node_modules/nan/nan.h

https://bitbucket.org/coleman333/smartsite · C Header · 2276 lines · 1858 code · 351 blank · 67 comment · 112 complexity · 9bcfcae8fb1e8dbc12a0ba1f743edced MD5 · raw file

Large files are truncated click here to view the full file

  1. /*********************************************************************
  2. * NAN - Native Abstractions for Node.js
  3. *
  4. * Copyright (c) 2016 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. * - David Siegel <https://github.com/agnat>
  12. *
  13. * MIT License <https://github.com/nodejs/nan/blob/master/LICENSE.md>
  14. *
  15. * Version 2.3.5: current Node 6.2.0, Node 12: 0.12.14, Node 10: 0.10.45, iojs: 3.3.1
  16. *
  17. * See https://github.com/nodejs/nan for the latest update to this file
  18. **********************************************************************************/
  19. #ifndef NAN_H_
  20. #define NAN_H_
  21. #include <node_version.h>
  22. #define NODE_0_10_MODULE_VERSION 11
  23. #define NODE_0_12_MODULE_VERSION 14
  24. #define ATOM_0_21_MODULE_VERSION 41
  25. #define IOJS_1_0_MODULE_VERSION 42
  26. #define IOJS_1_1_MODULE_VERSION 43
  27. #define IOJS_2_0_MODULE_VERSION 44
  28. #define IOJS_3_0_MODULE_VERSION 45
  29. #define NODE_4_0_MODULE_VERSION 46
  30. #define NODE_5_0_MODULE_VERSION 47
  31. #define NODE_6_0_MODULE_VERSION 48
  32. #ifdef _MSC_VER
  33. # define NAN_HAS_CPLUSPLUS_11 (_MSC_VER >= 1800)
  34. #else
  35. # define NAN_HAS_CPLUSPLUS_11 (__cplusplus >= 201103L)
  36. #endif
  37. #if NODE_MODULE_VERSION >= IOJS_3_0_MODULE_VERSION && !NAN_HAS_CPLUSPLUS_11
  38. # error This version of node/NAN/v8 requires a C++11 compiler
  39. #endif
  40. #include <uv.h>
  41. #include <node.h>
  42. #include <node_buffer.h>
  43. #include <node_object_wrap.h>
  44. #include <algorithm>
  45. #include <cstring>
  46. #include <climits>
  47. #include <cstdlib>
  48. #if defined(_MSC_VER)
  49. # pragma warning( push )
  50. # pragma warning( disable : 4530 )
  51. # include <string>
  52. # include <vector>
  53. # pragma warning( pop )
  54. #else
  55. # include <string>
  56. # include <vector>
  57. #endif
  58. // uv helpers
  59. #ifdef UV_VERSION_MAJOR
  60. # ifndef UV_VERSION_PATCH
  61. # define UV_VERSION_PATCH 0
  62. # endif
  63. # define NAUV_UVVERSION ((UV_VERSION_MAJOR << 16) | \
  64. (UV_VERSION_MINOR << 8) | \
  65. (UV_VERSION_PATCH))
  66. #else
  67. # define NAUV_UVVERSION 0x000b00
  68. #endif
  69. #if NAUV_UVVERSION < 0x000b0b
  70. # ifdef WIN32
  71. # include <windows.h>
  72. # else
  73. # include <pthread.h>
  74. # endif
  75. #endif
  76. namespace Nan {
  77. #define NAN_INLINE inline // TODO(bnoordhuis) Remove in v3.0.0.
  78. #if defined(__GNUC__) && \
  79. !(defined(V8_DISABLE_DEPRECATIONS) && V8_DISABLE_DEPRECATIONS)
  80. # define NAN_DEPRECATED __attribute__((deprecated))
  81. #elif defined(_MSC_VER) && \
  82. !(defined(V8_DISABLE_DEPRECATIONS) && V8_DISABLE_DEPRECATIONS)
  83. # define NAN_DEPRECATED __declspec(deprecated)
  84. #else
  85. # define NAN_DEPRECATED
  86. #endif
  87. #if NAN_HAS_CPLUSPLUS_11
  88. # define NAN_DISALLOW_ASSIGN(CLASS) void operator=(const CLASS&) = delete;
  89. # define NAN_DISALLOW_COPY(CLASS) CLASS(const CLASS&) = delete;
  90. # define NAN_DISALLOW_MOVE(CLASS) \
  91. CLASS(CLASS&&) = delete; /* NOLINT(build/c++11) */ \
  92. void operator=(CLASS&&) = delete;
  93. #else
  94. # define NAN_DISALLOW_ASSIGN(CLASS) void operator=(const CLASS&);
  95. # define NAN_DISALLOW_COPY(CLASS) CLASS(const CLASS&);
  96. # define NAN_DISALLOW_MOVE(CLASS)
  97. #endif
  98. #define NAN_DISALLOW_ASSIGN_COPY(CLASS) \
  99. NAN_DISALLOW_ASSIGN(CLASS) \
  100. NAN_DISALLOW_COPY(CLASS)
  101. #define NAN_DISALLOW_ASSIGN_MOVE(CLASS) \
  102. NAN_DISALLOW_ASSIGN(CLASS) \
  103. NAN_DISALLOW_MOVE(CLASS)
  104. #define NAN_DISALLOW_COPY_MOVE(CLASS) \
  105. NAN_DISALLOW_COPY(CLASS) \
  106. NAN_DISALLOW_MOVE(CLASS)
  107. #define NAN_DISALLOW_ASSIGN_COPY_MOVE(CLASS) \
  108. NAN_DISALLOW_ASSIGN(CLASS) \
  109. NAN_DISALLOW_COPY(CLASS) \
  110. NAN_DISALLOW_MOVE(CLASS)
  111. #define TYPE_CHECK(T, S) \
  112. while (false) { \
  113. *(static_cast<T *volatile *>(0)) = static_cast<S*>(0); \
  114. }
  115. //=== RegistrationFunction =====================================================
  116. #if NODE_MODULE_VERSION < IOJS_3_0_MODULE_VERSION
  117. typedef v8::Handle<v8::Object> ADDON_REGISTER_FUNCTION_ARGS_TYPE;
  118. #else
  119. typedef v8::Local<v8::Object> ADDON_REGISTER_FUNCTION_ARGS_TYPE;
  120. #endif
  121. #define NAN_MODULE_INIT(name) \
  122. void name(Nan::ADDON_REGISTER_FUNCTION_ARGS_TYPE target)
  123. //=== CallbackInfo =============================================================
  124. #include "nan_callbacks.h" // NOLINT(build/include)
  125. //==============================================================================
  126. #if (NODE_MODULE_VERSION < NODE_0_12_MODULE_VERSION)
  127. typedef v8::Script UnboundScript;
  128. typedef v8::Script BoundScript;
  129. #else
  130. typedef v8::UnboundScript UnboundScript;
  131. typedef v8::Script BoundScript;
  132. #endif
  133. #if (NODE_MODULE_VERSION < ATOM_0_21_MODULE_VERSION)
  134. typedef v8::String::ExternalAsciiStringResource
  135. ExternalOneByteStringResource;
  136. #else
  137. typedef v8::String::ExternalOneByteStringResource
  138. ExternalOneByteStringResource;
  139. #endif
  140. #if (NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION)
  141. template<typename T>
  142. class NonCopyablePersistentTraits :
  143. public v8::NonCopyablePersistentTraits<T> {};
  144. template<typename T>
  145. class CopyablePersistentTraits :
  146. public v8::CopyablePersistentTraits<T> {};
  147. template<typename T>
  148. class PersistentBase :
  149. public v8::PersistentBase<T> {};
  150. template<typename T, typename M = v8::NonCopyablePersistentTraits<T> >
  151. class Persistent;
  152. #else
  153. template<typename T> class NonCopyablePersistentTraits;
  154. template<typename T> class PersistentBase;
  155. template<typename T, typename P> class WeakCallbackData;
  156. template<typename T, typename M = NonCopyablePersistentTraits<T> >
  157. class Persistent;
  158. #endif // NODE_MODULE_VERSION
  159. #if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 || \
  160. (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3))
  161. # include "nan_maybe_43_inl.h" // NOLINT(build/include)
  162. #else
  163. # include "nan_maybe_pre_43_inl.h" // NOLINT(build/include)
  164. #endif
  165. #include "nan_converters.h" // NOLINT(build/include)
  166. #include "nan_new.h" // NOLINT(build/include)
  167. #if NAUV_UVVERSION < 0x000b17
  168. #define NAUV_WORK_CB(func) \
  169. void func(uv_async_t *async, int)
  170. #else
  171. #define NAUV_WORK_CB(func) \
  172. void func(uv_async_t *async)
  173. #endif
  174. #if NAUV_UVVERSION >= 0x000b0b
  175. typedef uv_key_t nauv_key_t;
  176. inline int nauv_key_create(nauv_key_t *key) {
  177. return uv_key_create(key);
  178. }
  179. inline void nauv_key_delete(nauv_key_t *key) {
  180. uv_key_delete(key);
  181. }
  182. inline void* nauv_key_get(nauv_key_t *key) {
  183. return uv_key_get(key);
  184. }
  185. inline void nauv_key_set(nauv_key_t *key, void *value) {
  186. uv_key_set(key, value);
  187. }
  188. #else
  189. /* Implement thread local storage for older versions of libuv.
  190. * This is essentially a backport of libuv commit 5d2434bf
  191. * written by Ben Noordhuis, adjusted for names and inline.
  192. */
  193. #ifndef WIN32
  194. typedef pthread_key_t nauv_key_t;
  195. inline int nauv_key_create(nauv_key_t* key) {
  196. return -pthread_key_create(key, NULL);
  197. }
  198. inline void nauv_key_delete(nauv_key_t* key) {
  199. if (pthread_key_delete(*key))
  200. abort();
  201. }
  202. inline void* nauv_key_get(nauv_key_t* key) {
  203. return pthread_getspecific(*key);
  204. }
  205. inline void nauv_key_set(nauv_key_t* key, void* value) {
  206. if (pthread_setspecific(*key, value))
  207. abort();
  208. }
  209. #else
  210. typedef struct {
  211. DWORD tls_index;
  212. } nauv_key_t;
  213. inline int nauv_key_create(nauv_key_t* key) {
  214. key->tls_index = TlsAlloc();
  215. if (key->tls_index == TLS_OUT_OF_INDEXES)
  216. return UV_ENOMEM;
  217. return 0;
  218. }
  219. inline void nauv_key_delete(nauv_key_t* key) {
  220. if (TlsFree(key->tls_index) == FALSE)
  221. abort();
  222. key->tls_index = TLS_OUT_OF_INDEXES;
  223. }
  224. inline void* nauv_key_get(nauv_key_t* key) {
  225. void* value = TlsGetValue(key->tls_index);
  226. if (value == NULL)
  227. if (GetLastError() != ERROR_SUCCESS)
  228. abort();
  229. return value;
  230. }
  231. inline void nauv_key_set(nauv_key_t* key, void* value) {
  232. if (TlsSetValue(key->tls_index, value) == FALSE)
  233. abort();
  234. }
  235. #endif
  236. #endif
  237. #if NODE_MODULE_VERSION < IOJS_3_0_MODULE_VERSION
  238. template<typename T>
  239. v8::Local<T> New(v8::Handle<T>);
  240. #endif
  241. #if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 || \
  242. (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3))
  243. typedef v8::WeakCallbackType WeakCallbackType;
  244. #else
  245. struct WeakCallbackType {
  246. enum E {kParameter, kInternalFields};
  247. E type;
  248. WeakCallbackType(E other) : type(other) {} // NOLINT(runtime/explicit)
  249. inline bool operator==(E other) { return other == this->type; }
  250. inline bool operator!=(E other) { return !operator==(other); }
  251. };
  252. #endif
  253. template<typename P> class WeakCallbackInfo;
  254. #if NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION
  255. # include "nan_persistent_12_inl.h" // NOLINT(build/include)
  256. #else
  257. # include "nan_persistent_pre_12_inl.h" // NOLINT(build/include)
  258. #endif
  259. namespace imp {
  260. static const size_t kMaxLength = 0x3fffffff;
  261. // v8::String::REPLACE_INVALID_UTF8 was introduced
  262. // in node.js v0.10.29 and v0.8.27.
  263. #if NODE_MAJOR_VERSION > 0 || \
  264. NODE_MINOR_VERSION > 10 || \
  265. NODE_MINOR_VERSION == 10 && NODE_PATCH_VERSION >= 29 || \
  266. NODE_MINOR_VERSION == 8 && NODE_PATCH_VERSION >= 27
  267. static const unsigned kReplaceInvalidUtf8 = v8::String::REPLACE_INVALID_UTF8;
  268. #else
  269. static const unsigned kReplaceInvalidUtf8 = 0;
  270. #endif
  271. } // end of namespace imp
  272. //=== HandleScope ==============================================================
  273. class HandleScope {
  274. v8::HandleScope scope;
  275. public:
  276. #if NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION
  277. inline HandleScope() : scope(v8::Isolate::GetCurrent()) {}
  278. inline static int NumberOfHandles() {
  279. return v8::HandleScope::NumberOfHandles(v8::Isolate::GetCurrent());
  280. }
  281. #else
  282. inline HandleScope() : scope() {}
  283. inline static int NumberOfHandles() {
  284. return v8::HandleScope::NumberOfHandles();
  285. }
  286. #endif
  287. private:
  288. // Make it hard to create heap-allocated or illegal handle scopes by
  289. // disallowing certain operations.
  290. HandleScope(const HandleScope &);
  291. void operator=(const HandleScope &);
  292. void *operator new(size_t size);
  293. void operator delete(void *, size_t);
  294. };
  295. class EscapableHandleScope {
  296. public:
  297. #if NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION
  298. inline EscapableHandleScope() : scope(v8::Isolate::GetCurrent()) {}
  299. inline static int NumberOfHandles() {
  300. return v8::EscapableHandleScope::NumberOfHandles(v8::Isolate::GetCurrent());
  301. }
  302. template<typename T>
  303. inline v8::Local<T> Escape(v8::Local<T> value) {
  304. return scope.Escape(value);
  305. }
  306. private:
  307. v8::EscapableHandleScope scope;
  308. #else
  309. inline EscapableHandleScope() : scope() {}
  310. inline static int NumberOfHandles() {
  311. return v8::HandleScope::NumberOfHandles();
  312. }
  313. template<typename T>
  314. inline v8::Local<T> Escape(v8::Local<T> value) {
  315. return scope.Close(value);
  316. }
  317. private:
  318. v8::HandleScope scope;
  319. #endif
  320. private:
  321. // Make it hard to create heap-allocated or illegal handle scopes by
  322. // disallowing certain operations.
  323. EscapableHandleScope(const EscapableHandleScope &);
  324. void operator=(const EscapableHandleScope &);
  325. void *operator new(size_t size);
  326. void operator delete(void *, size_t);
  327. };
  328. //=== TryCatch =================================================================
  329. class TryCatch {
  330. v8::TryCatch try_catch_;
  331. friend void FatalException(const TryCatch&);
  332. public:
  333. #if NODE_MODULE_VERSION > NODE_0_12_MODULE_VERSION
  334. TryCatch() : try_catch_(v8::Isolate::GetCurrent()) {}
  335. #endif
  336. inline bool HasCaught() const { return try_catch_.HasCaught(); }
  337. inline bool CanContinue() const { return try_catch_.CanContinue(); }
  338. inline v8::Local<v8::Value> ReThrow() {
  339. #if NODE_MODULE_VERSION < IOJS_3_0_MODULE_VERSION
  340. return New(try_catch_.ReThrow());
  341. #else
  342. return try_catch_.ReThrow();
  343. #endif
  344. }
  345. inline v8::Local<v8::Value> Exception() const {
  346. return try_catch_.Exception();
  347. }
  348. #if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 || \
  349. (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3))
  350. inline v8::MaybeLocal<v8::Value> StackTrace() const {
  351. return try_catch_.StackTrace(GetCurrentContext());
  352. }
  353. #else
  354. inline MaybeLocal<v8::Value> StackTrace() const {
  355. return MaybeLocal<v8::Value>(try_catch_.StackTrace());
  356. }
  357. #endif
  358. inline v8::Local<v8::Message> Message() const {
  359. return try_catch_.Message();
  360. }
  361. inline void Reset() { try_catch_.Reset(); }
  362. inline void SetVerbose(bool value) { try_catch_.SetVerbose(value); }
  363. inline void SetCaptureMessage(bool value) {
  364. try_catch_.SetCaptureMessage(value);
  365. }
  366. };
  367. //============ =================================================================
  368. /* node 0.12 */
  369. #if NODE_MODULE_VERSION >= NODE_0_12_MODULE_VERSION
  370. inline
  371. void SetCounterFunction(v8::CounterLookupCallback cb) {
  372. v8::Isolate::GetCurrent()->SetCounterFunction(cb);
  373. }
  374. inline
  375. void SetCreateHistogramFunction(v8::CreateHistogramCallback cb) {
  376. v8::Isolate::GetCurrent()->SetCreateHistogramFunction(cb);
  377. }
  378. inline
  379. void SetAddHistogramSampleFunction(v8::AddHistogramSampleCallback cb) {
  380. v8::Isolate::GetCurrent()->SetAddHistogramSampleFunction(cb);
  381. }
  382. #if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 || \
  383. (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3))
  384. inline bool IdleNotification(int idle_time_in_ms) {
  385. return v8::Isolate::GetCurrent()->IdleNotificationDeadline(
  386. idle_time_in_ms * 0.001);
  387. }
  388. # else
  389. inline bool IdleNotification(int idle_time_in_ms) {
  390. return v8::Isolate::GetCurrent()->IdleNotification(idle_time_in_ms);
  391. }
  392. #endif
  393. inline void LowMemoryNotification() {
  394. v8::Isolate::GetCurrent()->LowMemoryNotification();
  395. }
  396. inline void ContextDisposedNotification() {
  397. v8::Isolate::GetCurrent()->ContextDisposedNotification();
  398. }
  399. #else
  400. inline
  401. void SetCounterFunction(v8::CounterLookupCallback cb) {
  402. v8::V8::SetCounterFunction(cb);
  403. }
  404. inline
  405. void SetCreateHistogramFunction(v8::CreateHistogramCallback cb) {
  406. v8::V8::SetCreateHistogramFunction(cb);
  407. }
  408. inline
  409. void SetAddHistogramSampleFunction(v8::AddHistogramSampleCallback cb) {
  410. v8::V8::SetAddHistogramSampleFunction(cb);
  411. }
  412. inline bool IdleNotification(int idle_time_in_ms) {
  413. return v8::V8::IdleNotification(idle_time_in_ms);
  414. }
  415. inline void LowMemoryNotification() {
  416. v8::V8::LowMemoryNotification();
  417. }
  418. inline void ContextDisposedNotification() {
  419. v8::V8::ContextDisposedNotification();
  420. }
  421. #endif
  422. #if (NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION) // Node 0.12
  423. inline v8::Local<v8::Primitive> Undefined() {
  424. # if NODE_MODULE_VERSION < IOJS_3_0_MODULE_VERSION
  425. EscapableHandleScope scope;
  426. return scope.Escape(New(v8::Undefined(v8::Isolate::GetCurrent())));
  427. # else
  428. return v8::Undefined(v8::Isolate::GetCurrent());
  429. # endif
  430. }
  431. inline v8::Local<v8::Primitive> Null() {
  432. # if NODE_MODULE_VERSION < IOJS_3_0_MODULE_VERSION
  433. EscapableHandleScope scope;
  434. return scope.Escape(New(v8::Null(v8::Isolate::GetCurrent())));
  435. # else
  436. return v8::Null(v8::Isolate::GetCurrent());
  437. # endif
  438. }
  439. inline v8::Local<v8::Boolean> True() {
  440. # if NODE_MODULE_VERSION < IOJS_3_0_MODULE_VERSION
  441. EscapableHandleScope scope;
  442. return scope.Escape(New(v8::True(v8::Isolate::GetCurrent())));
  443. # else
  444. return v8::True(v8::Isolate::GetCurrent());
  445. # endif
  446. }
  447. inline v8::Local<v8::Boolean> False() {
  448. # if NODE_MODULE_VERSION < IOJS_3_0_MODULE_VERSION
  449. EscapableHandleScope scope;
  450. return scope.Escape(New(v8::False(v8::Isolate::GetCurrent())));
  451. # else
  452. return v8::False(v8::Isolate::GetCurrent());
  453. # endif
  454. }
  455. inline v8::Local<v8::String> EmptyString() {
  456. return v8::String::Empty(v8::Isolate::GetCurrent());
  457. }
  458. inline int AdjustExternalMemory(int bc) {
  459. return static_cast<int>(
  460. v8::Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(bc));
  461. }
  462. inline void SetTemplate(
  463. v8::Local<v8::Template> templ
  464. , const char *name
  465. , v8::Local<v8::Data> value) {
  466. templ->Set(v8::Isolate::GetCurrent(), name, value);
  467. }
  468. inline void SetTemplate(
  469. v8::Local<v8::Template> templ
  470. , v8::Local<v8::String> name
  471. , v8::Local<v8::Data> value
  472. , v8::PropertyAttribute attributes) {
  473. templ->Set(name, value, attributes);
  474. }
  475. inline v8::Local<v8::Context> GetCurrentContext() {
  476. return v8::Isolate::GetCurrent()->GetCurrentContext();
  477. }
  478. inline void* GetInternalFieldPointer(
  479. v8::Local<v8::Object> object
  480. , int index) {
  481. return object->GetAlignedPointerFromInternalField(index);
  482. }
  483. inline void SetInternalFieldPointer(
  484. v8::Local<v8::Object> object
  485. , int index
  486. , void* value) {
  487. object->SetAlignedPointerInInternalField(index, value);
  488. }
  489. # define NAN_GC_CALLBACK(name) \
  490. void name(v8::Isolate *isolate, v8::GCType type, v8::GCCallbackFlags flags)
  491. #if NODE_MODULE_VERSION <= NODE_4_0_MODULE_VERSION
  492. typedef v8::Isolate::GCEpilogueCallback GCEpilogueCallback;
  493. typedef v8::Isolate::GCPrologueCallback GCPrologueCallback;
  494. #else
  495. typedef v8::Isolate::GCCallback GCEpilogueCallback;
  496. typedef v8::Isolate::GCCallback GCPrologueCallback;
  497. #endif
  498. inline void AddGCEpilogueCallback(
  499. GCEpilogueCallback callback
  500. , v8::GCType gc_type_filter = v8::kGCTypeAll) {
  501. v8::Isolate::GetCurrent()->AddGCEpilogueCallback(callback, gc_type_filter);
  502. }
  503. inline void RemoveGCEpilogueCallback(
  504. GCEpilogueCallback callback) {
  505. v8::Isolate::GetCurrent()->RemoveGCEpilogueCallback(callback);
  506. }
  507. inline void AddGCPrologueCallback(
  508. GCPrologueCallback callback
  509. , v8::GCType gc_type_filter = v8::kGCTypeAll) {
  510. v8::Isolate::GetCurrent()->AddGCPrologueCallback(callback, gc_type_filter);
  511. }
  512. inline void RemoveGCPrologueCallback(
  513. GCPrologueCallback callback) {
  514. v8::Isolate::GetCurrent()->RemoveGCPrologueCallback(callback);
  515. }
  516. inline void GetHeapStatistics(
  517. v8::HeapStatistics *heap_statistics) {
  518. v8::Isolate::GetCurrent()->GetHeapStatistics(heap_statistics);
  519. }
  520. # define X(NAME) \
  521. inline v8::Local<v8::Value> NAME(const char *msg) { \
  522. EscapableHandleScope scope; \
  523. return scope.Escape(v8::Exception::NAME(New(msg).ToLocalChecked())); \
  524. } \
  525. \
  526. inline \
  527. v8::Local<v8::Value> NAME(v8::Local<v8::String> msg) { \
  528. return v8::Exception::NAME(msg); \
  529. } \
  530. \
  531. inline void Throw ## NAME(const char *msg) { \
  532. HandleScope scope; \
  533. v8::Isolate::GetCurrent()->ThrowException( \
  534. v8::Exception::NAME(New(msg).ToLocalChecked())); \
  535. } \
  536. \
  537. inline void Throw ## NAME(v8::Local<v8::String> msg) { \
  538. HandleScope scope; \
  539. v8::Isolate::GetCurrent()->ThrowException( \
  540. v8::Exception::NAME(msg)); \
  541. }
  542. X(Error)
  543. X(RangeError)
  544. X(ReferenceError)
  545. X(SyntaxError)
  546. X(TypeError)
  547. # undef X
  548. inline void ThrowError(v8::Local<v8::Value> error) {
  549. v8::Isolate::GetCurrent()->ThrowException(error);
  550. }
  551. inline MaybeLocal<v8::Object> NewBuffer(
  552. char *data
  553. , size_t length
  554. #if NODE_MODULE_VERSION > IOJS_2_0_MODULE_VERSION
  555. , node::Buffer::FreeCallback callback
  556. #else
  557. , node::smalloc::FreeCallback callback
  558. #endif
  559. , void *hint
  560. ) {
  561. // arbitrary buffer lengths requires
  562. // NODE_MODULE_VERSION >= IOJS_3_0_MODULE_VERSION
  563. assert(length <= imp::kMaxLength && "too large buffer");
  564. #if NODE_MODULE_VERSION > IOJS_2_0_MODULE_VERSION
  565. return node::Buffer::New(
  566. v8::Isolate::GetCurrent(), data, length, callback, hint);
  567. #else
  568. return MaybeLocal<v8::Object>(node::Buffer::New(
  569. v8::Isolate::GetCurrent(), data, length, callback, hint));
  570. #endif
  571. }
  572. inline MaybeLocal<v8::Object> CopyBuffer(
  573. const char *data
  574. , uint32_t size
  575. ) {
  576. // arbitrary buffer lengths requires
  577. // NODE_MODULE_VERSION >= IOJS_3_0_MODULE_VERSION
  578. assert(size <= imp::kMaxLength && "too large buffer");
  579. #if NODE_MODULE_VERSION > IOJS_2_0_MODULE_VERSION
  580. return node::Buffer::Copy(
  581. v8::Isolate::GetCurrent(), data, size);
  582. #else
  583. return MaybeLocal<v8::Object>(node::Buffer::New(
  584. v8::Isolate::GetCurrent(), data, size));
  585. #endif
  586. }
  587. inline MaybeLocal<v8::Object> NewBuffer(uint32_t size) {
  588. // arbitrary buffer lengths requires
  589. // NODE_MODULE_VERSION >= IOJS_3_0_MODULE_VERSION
  590. assert(size <= imp::kMaxLength && "too large buffer");
  591. #if NODE_MODULE_VERSION > IOJS_2_0_MODULE_VERSION
  592. return node::Buffer::New(
  593. v8::Isolate::GetCurrent(), size);
  594. #else
  595. return MaybeLocal<v8::Object>(node::Buffer::New(
  596. v8::Isolate::GetCurrent(), size));
  597. #endif
  598. }
  599. inline MaybeLocal<v8::Object> NewBuffer(
  600. char* data
  601. , uint32_t size
  602. ) {
  603. // arbitrary buffer lengths requires
  604. // NODE_MODULE_VERSION >= IOJS_3_0_MODULE_VERSION
  605. assert(size <= imp::kMaxLength && "too large buffer");
  606. #if NODE_MODULE_VERSION > IOJS_2_0_MODULE_VERSION
  607. return node::Buffer::New(v8::Isolate::GetCurrent(), data, size);
  608. #else
  609. return MaybeLocal<v8::Object>(
  610. node::Buffer::Use(v8::Isolate::GetCurrent(), data, size));
  611. #endif
  612. }
  613. #if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 || \
  614. (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3))
  615. inline MaybeLocal<v8::String>
  616. NewOneByteString(const uint8_t * value, int length = -1) {
  617. return v8::String::NewFromOneByte(v8::Isolate::GetCurrent(), value,
  618. v8::NewStringType::kNormal, length);
  619. }
  620. inline MaybeLocal<BoundScript> CompileScript(
  621. v8::Local<v8::String> s
  622. , const v8::ScriptOrigin& origin
  623. ) {
  624. v8::ScriptCompiler::Source source(s, origin);
  625. return v8::ScriptCompiler::Compile(GetCurrentContext(), &source);
  626. }
  627. inline MaybeLocal<BoundScript> CompileScript(
  628. v8::Local<v8::String> s
  629. ) {
  630. v8::ScriptCompiler::Source source(s);
  631. return v8::ScriptCompiler::Compile(GetCurrentContext(), &source);
  632. }
  633. inline MaybeLocal<v8::Value> RunScript(
  634. v8::Local<UnboundScript> script
  635. ) {
  636. return script->BindToCurrentContext()->Run(GetCurrentContext());
  637. }
  638. inline MaybeLocal<v8::Value> RunScript(
  639. v8::Local<BoundScript> script
  640. ) {
  641. return script->Run(GetCurrentContext());
  642. }
  643. #else
  644. inline MaybeLocal<v8::String>
  645. NewOneByteString(const uint8_t * value, int length = -1) {
  646. return MaybeLocal<v8::String>(
  647. v8::String::NewFromOneByte(
  648. v8::Isolate::GetCurrent()
  649. , value
  650. , v8::String::kNormalString, length));
  651. }
  652. inline MaybeLocal<BoundScript> CompileScript(
  653. v8::Local<v8::String> s
  654. , const v8::ScriptOrigin& origin
  655. ) {
  656. v8::ScriptCompiler::Source source(s, origin);
  657. return MaybeLocal<BoundScript>(
  658. v8::ScriptCompiler::Compile(v8::Isolate::GetCurrent(), &source));
  659. }
  660. inline MaybeLocal<BoundScript> CompileScript(
  661. v8::Local<v8::String> s
  662. ) {
  663. v8::ScriptCompiler::Source source(s);
  664. return MaybeLocal<BoundScript>(
  665. v8::ScriptCompiler::Compile(v8::Isolate::GetCurrent(), &source));
  666. }
  667. inline MaybeLocal<v8::Value> RunScript(
  668. v8::Local<UnboundScript> script
  669. ) {
  670. return MaybeLocal<v8::Value>(script->BindToCurrentContext()->Run());
  671. }
  672. inline MaybeLocal<v8::Value> RunScript(
  673. v8::Local<BoundScript> script
  674. ) {
  675. return MaybeLocal<v8::Value>(script->Run());
  676. }
  677. #endif
  678. inline v8::Local<v8::Value> MakeCallback(
  679. v8::Local<v8::Object> target
  680. , v8::Local<v8::Function> func
  681. , int argc
  682. , v8::Local<v8::Value>* argv) {
  683. #if NODE_MODULE_VERSION < IOJS_3_0_MODULE_VERSION
  684. return New(node::MakeCallback(
  685. v8::Isolate::GetCurrent(), target, func, argc, argv));
  686. #else
  687. return node::MakeCallback(
  688. v8::Isolate::GetCurrent(), target, func, argc, argv);
  689. #endif
  690. }
  691. inline v8::Local<v8::Value> MakeCallback(
  692. v8::Local<v8::Object> target
  693. , v8::Local<v8::String> symbol
  694. , int argc
  695. , v8::Local<v8::Value>* argv) {
  696. #if NODE_MODULE_VERSION < IOJS_3_0_MODULE_VERSION
  697. return New(node::MakeCallback(
  698. v8::Isolate::GetCurrent(), target, symbol, argc, argv));
  699. #else
  700. return node::MakeCallback(
  701. v8::Isolate::GetCurrent(), target, symbol, argc, argv);
  702. #endif
  703. }
  704. inline v8::Local<v8::Value> MakeCallback(
  705. v8::Local<v8::Object> target
  706. , const char* method
  707. , int argc
  708. , v8::Local<v8::Value>* argv) {
  709. #if NODE_MODULE_VERSION < IOJS_3_0_MODULE_VERSION
  710. return New(node::MakeCallback(
  711. v8::Isolate::GetCurrent(), target, method, argc, argv));
  712. #else
  713. return node::MakeCallback(
  714. v8::Isolate::GetCurrent(), target, method, argc, argv);
  715. #endif
  716. }
  717. inline void FatalException(const TryCatch& try_catch) {
  718. node::FatalException(v8::Isolate::GetCurrent(), try_catch.try_catch_);
  719. }
  720. inline v8::Local<v8::Value> ErrnoException(
  721. int errorno
  722. , const char* syscall = NULL
  723. , const char* message = NULL
  724. , const char* path = NULL) {
  725. return node::ErrnoException(v8::Isolate::GetCurrent(), errorno, syscall,
  726. message, path);
  727. }
  728. NAN_DEPRECATED inline v8::Local<v8::Value> NanErrnoException(
  729. int errorno
  730. , const char* syscall = NULL
  731. , const char* message = NULL
  732. , const char* path = NULL) {
  733. return ErrnoException(errorno, syscall, message, path);
  734. }
  735. template<typename T>
  736. inline void SetIsolateData(
  737. v8::Isolate *isolate
  738. , T *data
  739. ) {
  740. isolate->SetData(0, data);
  741. }
  742. template<typename T>
  743. inline T *GetIsolateData(
  744. v8::Isolate *isolate
  745. ) {
  746. return static_cast<T*>(isolate->GetData(0));
  747. }
  748. class Utf8String {
  749. public:
  750. inline explicit Utf8String(v8::Local<v8::Value> from) :
  751. length_(0), str_(str_st_) {
  752. if (!from.IsEmpty()) {
  753. v8::Local<v8::String> string = from->ToString();
  754. if (!string.IsEmpty()) {
  755. size_t len = 3 * string->Length() + 1;
  756. assert(len <= INT_MAX);
  757. if (len > sizeof (str_st_)) {
  758. str_ = static_cast<char*>(malloc(len));
  759. assert(str_ != 0);
  760. }
  761. const int flags =
  762. v8::String::NO_NULL_TERMINATION | imp::kReplaceInvalidUtf8;
  763. length_ = string->WriteUtf8(str_, static_cast<int>(len), 0, flags);
  764. str_[length_] = '\0';
  765. }
  766. }
  767. }
  768. inline int length() const {
  769. return length_;
  770. }
  771. inline char* operator*() { return str_; }
  772. inline const char* operator*() const { return str_; }
  773. inline ~Utf8String() {
  774. if (str_ != str_st_) {
  775. free(str_);
  776. }
  777. }
  778. private:
  779. NAN_DISALLOW_ASSIGN_COPY_MOVE(Utf8String)
  780. int length_;
  781. char *str_;
  782. char str_st_[1024];
  783. };
  784. #else // Node 0.8 and 0.10
  785. inline v8::Local<v8::Primitive> Undefined() {
  786. EscapableHandleScope scope;
  787. return scope.Escape(New(v8::Undefined()));
  788. }
  789. inline v8::Local<v8::Primitive> Null() {
  790. EscapableHandleScope scope;
  791. return scope.Escape(New(v8::Null()));
  792. }
  793. inline v8::Local<v8::Boolean> True() {
  794. EscapableHandleScope scope;
  795. return scope.Escape(New(v8::True()));
  796. }
  797. inline v8::Local<v8::Boolean> False() {
  798. EscapableHandleScope scope;
  799. return scope.Escape(New(v8::False()));
  800. }
  801. inline v8::Local<v8::String> EmptyString() {
  802. return v8::String::Empty();
  803. }
  804. inline int AdjustExternalMemory(int bc) {
  805. return static_cast<int>(v8::V8::AdjustAmountOfExternalAllocatedMemory(bc));
  806. }
  807. inline void SetTemplate(
  808. v8::Local<v8::Template> templ
  809. , const char *name
  810. , v8::Local<v8::Data> value) {
  811. templ->Set(name, value);
  812. }
  813. inline void SetTemplate(
  814. v8::Local<v8::Template> templ
  815. , v8::Local<v8::String> name
  816. , v8::Local<v8::Data> value
  817. , v8::PropertyAttribute attributes) {
  818. templ->Set(name, value, attributes);
  819. }
  820. inline v8::Local<v8::Context> GetCurrentContext() {
  821. return v8::Context::GetCurrent();
  822. }
  823. inline void* GetInternalFieldPointer(
  824. v8::Local<v8::Object> object
  825. , int index) {
  826. return object->GetPointerFromInternalField(index);
  827. }
  828. inline void SetInternalFieldPointer(
  829. v8::Local<v8::Object> object
  830. , int index
  831. , void* value) {
  832. object->SetPointerInInternalField(index, value);
  833. }
  834. # define NAN_GC_CALLBACK(name) \
  835. void name(v8::GCType type, v8::GCCallbackFlags flags)
  836. inline void AddGCEpilogueCallback(
  837. v8::GCEpilogueCallback callback
  838. , v8::GCType gc_type_filter = v8::kGCTypeAll) {
  839. v8::V8::AddGCEpilogueCallback(callback, gc_type_filter);
  840. }
  841. inline void RemoveGCEpilogueCallback(
  842. v8::GCEpilogueCallback callback) {
  843. v8::V8::RemoveGCEpilogueCallback(callback);
  844. }
  845. inline void AddGCPrologueCallback(
  846. v8::GCPrologueCallback callback
  847. , v8::GCType gc_type_filter = v8::kGCTypeAll) {
  848. v8::V8::AddGCPrologueCallback(callback, gc_type_filter);
  849. }
  850. inline void RemoveGCPrologueCallback(
  851. v8::GCPrologueCallback callback) {
  852. v8::V8::RemoveGCPrologueCallback(callback);
  853. }
  854. inline void GetHeapStatistics(
  855. v8::HeapStatistics *heap_statistics) {
  856. v8::V8::GetHeapStatistics(heap_statistics);
  857. }
  858. # define X(NAME) \
  859. inline v8::Local<v8::Value> NAME(const char *msg) { \
  860. EscapableHandleScope scope; \
  861. return scope.Escape(v8::Exception::NAME(New(msg).ToLocalChecked())); \
  862. } \
  863. \
  864. inline \
  865. v8::Local<v8::Value> NAME(v8::Local<v8::String> msg) { \
  866. return v8::Exception::NAME(msg); \
  867. } \
  868. \
  869. inline void Throw ## NAME(const char *msg) { \
  870. HandleScope scope; \
  871. v8::ThrowException(v8::Exception::NAME(New(msg).ToLocalChecked())); \
  872. } \
  873. \
  874. inline \
  875. void Throw ## NAME(v8::Local<v8::String> errmsg) { \
  876. v8::ThrowException(v8::Exception::NAME(errmsg)); \
  877. }
  878. X(Error)
  879. X(RangeError)
  880. X(ReferenceError)
  881. X(SyntaxError)
  882. X(TypeError)
  883. # undef X
  884. inline void ThrowError(v8::Local<v8::Value> error) {
  885. v8::ThrowException(error);
  886. }
  887. inline MaybeLocal<v8::Object> NewBuffer(
  888. char *data
  889. , size_t length
  890. , node::Buffer::free_callback callback
  891. , void *hint
  892. ) {
  893. EscapableHandleScope scope;
  894. // arbitrary buffer lengths requires
  895. // NODE_MODULE_VERSION >= IOJS_3_0_MODULE_VERSION
  896. assert(length <= imp::kMaxLength && "too large buffer");
  897. return MaybeLocal<v8::Object>(scope.Escape(
  898. New(node::Buffer::New(data, length, callback, hint)->handle_)));
  899. }
  900. inline MaybeLocal<v8::Object> CopyBuffer(
  901. const char *data
  902. , uint32_t size
  903. ) {
  904. EscapableHandleScope scope;
  905. // arbitrary buffer lengths requires
  906. // NODE_MODULE_VERSION >= IOJS_3_0_MODULE_VERSION
  907. assert(size <= imp::kMaxLength && "too large buffer");
  908. #if NODE_MODULE_VERSION >= NODE_0_10_MODULE_VERSION
  909. return MaybeLocal<v8::Object>(
  910. scope.Escape(New(node::Buffer::New(data, size)->handle_)));
  911. #else
  912. return MaybeLocal<v8::Object>(scope.Escape(
  913. New(node::Buffer::New(const_cast<char*>(data), size)->handle_)));
  914. #endif
  915. }
  916. inline MaybeLocal<v8::Object> NewBuffer(uint32_t size) {
  917. // arbitrary buffer lengths requires
  918. // NODE_MODULE_VERSION >= IOJS_3_0_MODULE_VERSION
  919. EscapableHandleScope scope;
  920. assert(size <= imp::kMaxLength && "too large buffer");
  921. return MaybeLocal<v8::Object>(
  922. scope.Escape(New(node::Buffer::New(size)->handle_)));
  923. }
  924. inline void FreeData(char *data, void *hint) {
  925. (void) hint; // unused
  926. delete[] data;
  927. }
  928. inline MaybeLocal<v8::Object> NewBuffer(
  929. char* data
  930. , uint32_t size
  931. ) {
  932. EscapableHandleScope scope;
  933. // arbitrary buffer lengths requires
  934. // NODE_MODULE_VERSION >= IOJS_3_0_MODULE_VERSION
  935. assert(size <= imp::kMaxLength && "too large buffer");
  936. return MaybeLocal<v8::Object>(scope.Escape(New(
  937. node::Buffer::New(data, size, FreeData, NULL)->handle_)));
  938. }
  939. namespace imp {
  940. inline void
  941. widenString(std::vector<uint16_t> *ws, const uint8_t *s, int l) {
  942. size_t len = static_cast<size_t>(l);
  943. if (l < 0) {
  944. len = strlen(reinterpret_cast<const char*>(s));
  945. }
  946. assert(len <= INT_MAX && "string too long");
  947. ws->resize(len);
  948. std::copy(s, s + len, ws->begin()); // NOLINT(build/include_what_you_use)
  949. }
  950. } // end of namespace imp
  951. inline MaybeLocal<v8::String>
  952. NewOneByteString(const uint8_t * value, int length = -1) {
  953. std::vector<uint16_t> wideString; // NOLINT(build/include_what_you_use)
  954. imp::widenString(&wideString, value, length);
  955. return imp::Factory<v8::String>::return_t(v8::String::New(
  956. &wideString.front(), static_cast<int>(wideString.size())));
  957. }
  958. inline MaybeLocal<BoundScript> CompileScript(
  959. v8::Local<v8::String> s
  960. , const v8::ScriptOrigin& origin
  961. ) {
  962. return MaybeLocal<BoundScript>(
  963. v8::Script::Compile(s, const_cast<v8::ScriptOrigin *>(&origin)));
  964. }
  965. inline MaybeLocal<BoundScript> CompileScript(
  966. v8::Local<v8::String> s
  967. ) {
  968. return MaybeLocal<BoundScript>(v8::Script::Compile(s));
  969. }
  970. inline
  971. MaybeLocal<v8::Value> RunScript(v8::Local<v8::Script> script) {
  972. return MaybeLocal<v8::Value>(script->Run());
  973. }
  974. inline v8::Local<v8::Value> MakeCallback(
  975. v8::Local<v8::Object> target
  976. , v8::Local<v8::Function> func
  977. , int argc
  978. , v8::Local<v8::Value>* argv) {
  979. return New(node::MakeCallback(target, func, argc, argv));
  980. }
  981. inline v8::Local<v8::Value> MakeCallback(
  982. v8::Local<v8::Object> target
  983. , v8::Local<v8::String> symbol
  984. , int argc
  985. , v8::Local<v8::Value>* argv) {
  986. return New(node::MakeCallback(target, symbol, argc, argv));
  987. }
  988. inline v8::Local<v8::Value> MakeCallback(
  989. v8::Local<v8::Object> target
  990. , const char* method
  991. , int argc
  992. , v8::Local<v8::Value>* argv) {
  993. return New(node::MakeCallback(target, method, argc, argv));
  994. }
  995. inline void FatalException(const TryCatch& try_catch) {
  996. node::FatalException(const_cast<v8::TryCatch &>(try_catch.try_catch_));
  997. }
  998. inline v8::Local<v8::Value> ErrnoException(
  999. int errorno
  1000. , const char* syscall = NULL
  1001. , const char* message = NULL
  1002. , const char* path = NULL) {
  1003. return node::ErrnoException(errorno, syscall, message, path);
  1004. }
  1005. NAN_DEPRECATED inline v8::Local<v8::Value> NanErrnoException(
  1006. int errorno
  1007. , const char* syscall = NULL
  1008. , const char* message = NULL
  1009. , const char* path = NULL) {
  1010. return ErrnoException(errorno, syscall, message, path);
  1011. }
  1012. template<typename T>
  1013. inline void SetIsolateData(
  1014. v8::Isolate *isolate
  1015. , T *data
  1016. ) {
  1017. isolate->SetData(data);
  1018. }
  1019. template<typename T>
  1020. inline T *GetIsolateData(
  1021. v8::Isolate *isolate
  1022. ) {
  1023. return static_cast<T*>(isolate->GetData());
  1024. }
  1025. class Utf8String {
  1026. public:
  1027. inline explicit Utf8String(v8::Local<v8::Value> from) :
  1028. length_(0), str_(str_st_) {
  1029. if (!from.IsEmpty()) {
  1030. v8::Local<v8::String> string = from->ToString();
  1031. if (!string.IsEmpty()) {
  1032. size_t len = 3 * string->Length() + 1;
  1033. assert(len <= INT_MAX);
  1034. if (len > sizeof (str_st_)) {
  1035. str_ = static_cast<char*>(malloc(len));
  1036. assert(str_ != 0);
  1037. }
  1038. const int flags =
  1039. v8::String::NO_NULL_TERMINATION | imp::kReplaceInvalidUtf8;
  1040. length_ = string->WriteUtf8(str_, static_cast<int>(len), 0, flags);
  1041. str_[length_] = '\0';
  1042. }
  1043. }
  1044. }
  1045. inline int length() const {
  1046. return length_;
  1047. }
  1048. inline char* operator*() { return str_; }
  1049. inline const char* operator*() const { return str_; }
  1050. inline ~Utf8String() {
  1051. if (str_ != str_st_) {
  1052. free(str_);
  1053. }
  1054. }
  1055. private:
  1056. NAN_DISALLOW_ASSIGN_COPY_MOVE(Utf8String)
  1057. int length_;
  1058. char *str_;
  1059. char str_st_[1024];
  1060. };
  1061. #endif // NODE_MODULE_VERSION
  1062. typedef void (*FreeCallback)(char *data, void *hint);
  1063. typedef const FunctionCallbackInfo<v8::Value>& NAN_METHOD_ARGS_TYPE;
  1064. typedef void NAN_METHOD_RETURN_TYPE;
  1065. typedef const PropertyCallbackInfo<v8::Value>& NAN_GETTER_ARGS_TYPE;
  1066. typedef void NAN_GETTER_RETURN_TYPE;
  1067. typedef const PropertyCallbackInfo<void>& NAN_SETTER_ARGS_TYPE;
  1068. typedef void NAN_SETTER_RETURN_TYPE;
  1069. typedef const PropertyCallbackInfo<v8::Value>&
  1070. NAN_PROPERTY_GETTER_ARGS_TYPE;
  1071. typedef void NAN_PROPERTY_GETTER_RETURN_TYPE;
  1072. typedef const PropertyCallbackInfo<v8::Value>&
  1073. NAN_PROPERTY_SETTER_ARGS_TYPE;
  1074. typedef void NAN_PROPERTY_SETTER_RETURN_TYPE;
  1075. typedef const PropertyCallbackInfo<v8::Array>&
  1076. NAN_PROPERTY_ENUMERATOR_ARGS_TYPE;
  1077. typedef void NAN_PROPERTY_ENUMERATOR_RETURN_TYPE;
  1078. typedef const PropertyCallbackInfo<v8::Boolean>&
  1079. NAN_PROPERTY_DELETER_ARGS_TYPE;
  1080. typedef void NAN_PROPERTY_DELETER_RETURN_TYPE;
  1081. typedef const PropertyCallbackInfo<v8::Integer>&
  1082. NAN_PROPERTY_QUERY_ARGS_TYPE;
  1083. typedef void NAN_PROPERTY_QUERY_RETURN_TYPE;
  1084. typedef const PropertyCallbackInfo<v8::Value>& NAN_INDEX_GETTER_ARGS_TYPE;
  1085. typedef void NAN_INDEX_GETTER_RETURN_TYPE;
  1086. typedef const PropertyCallbackInfo<v8::Value>& NAN_INDEX_SETTER_ARGS_TYPE;
  1087. typedef void NAN_INDEX_SETTER_RETURN_TYPE;
  1088. typedef const PropertyCallbackInfo<v8::Array>&
  1089. NAN_INDEX_ENUMERATOR_ARGS_TYPE;
  1090. typedef void NAN_INDEX_ENUMERATOR_RETURN_TYPE;
  1091. typedef const PropertyCallbackInfo<v8::Boolean>&
  1092. NAN_INDEX_DELETER_ARGS_TYPE;
  1093. typedef void NAN_INDEX_DELETER_RETURN_TYPE;
  1094. typedef const PropertyCallbackInfo<v8::Integer>&
  1095. NAN_INDEX_QUERY_ARGS_TYPE;
  1096. typedef void NAN_INDEX_QUERY_RETURN_TYPE;
  1097. #define NAN_METHOD(name) \
  1098. Nan::NAN_METHOD_RETURN_TYPE name(Nan::NAN_METHOD_ARGS_TYPE info)
  1099. #define NAN_GETTER(name) \
  1100. Nan::NAN_GETTER_RETURN_TYPE name( \
  1101. v8::Local<v8::String> property \
  1102. , Nan::NAN_GETTER_ARGS_TYPE info)
  1103. #define NAN_SETTER(name) \
  1104. Nan::NAN_SETTER_RETURN_TYPE name( \
  1105. v8::Local<v8::String> property \
  1106. , v8::Local<v8::Value> value \
  1107. , Nan::NAN_SETTER_ARGS_TYPE info)
  1108. #define NAN_PROPERTY_GETTER(name) \
  1109. Nan::NAN_PROPERTY_GETTER_RETURN_TYPE name( \
  1110. v8::Local<v8::String> property \
  1111. , Nan::NAN_PROPERTY_GETTER_ARGS_TYPE info)
  1112. #define NAN_PROPERTY_SETTER(name) \
  1113. Nan::NAN_PROPERTY_SETTER_RETURN_TYPE name( \
  1114. v8::Local<v8::String> property \
  1115. , v8::Local<v8::Value> value \
  1116. , Nan::NAN_PROPERTY_SETTER_ARGS_TYPE info)
  1117. #define NAN_PROPERTY_ENUMERATOR(name) \
  1118. Nan::NAN_PROPERTY_ENUMERATOR_RETURN_TYPE name( \
  1119. Nan::NAN_PROPERTY_ENUMERATOR_ARGS_TYPE info)
  1120. #define NAN_PROPERTY_DELETER(name) \
  1121. Nan::NAN_PROPERTY_DELETER_RETURN_TYPE name( \
  1122. v8::Local<v8::String> property \
  1123. , Nan::NAN_PROPERTY_DELETER_ARGS_TYPE info)
  1124. #define NAN_PROPERTY_QUERY(name) \
  1125. Nan::NAN_PROPERTY_QUERY_RETURN_TYPE name( \
  1126. v8::Local<v8::String> property \
  1127. , Nan::NAN_PROPERTY_QUERY_ARGS_TYPE info)
  1128. # define NAN_INDEX_GETTER(name) \
  1129. Nan::NAN_INDEX_GETTER_RETURN_TYPE name( \
  1130. uint32_t index \
  1131. , Nan::NAN_INDEX_GETTER_ARGS_TYPE info)
  1132. #define NAN_INDEX_SETTER(name) \
  1133. Nan::NAN_INDEX_SETTER_RETURN_TYPE name( \
  1134. uint32_t index \
  1135. , v8::Local<v8::Value> value \
  1136. , Nan::NAN_INDEX_SETTER_ARGS_TYPE info)
  1137. #define NAN_INDEX_ENUMERATOR(name) \
  1138. Nan::NAN_INDEX_ENUMERATOR_RETURN_TYPE \
  1139. name(Nan::NAN_INDEX_ENUMERATOR_ARGS_TYPE info)
  1140. #define NAN_INDEX_DELETER(name) \
  1141. Nan::NAN_INDEX_DELETER_RETURN_TYPE name( \
  1142. uint32_t index \
  1143. , Nan::NAN_INDEX_DELETER_ARGS_TYPE info)
  1144. #define NAN_INDEX_QUERY(name) \
  1145. Nan::NAN_INDEX_QUERY_RETURN_TYPE name( \
  1146. uint32_t index \
  1147. , Nan::NAN_INDEX_QUERY_ARGS_TYPE info)
  1148. class Callback {
  1149. public:
  1150. Callback() {
  1151. HandleScope scope;
  1152. v8::Local<v8::Object> obj = New<v8::Object>();
  1153. handle.Reset(obj);
  1154. }
  1155. explicit Callback(const v8::Local<v8::Function> &fn) {
  1156. HandleScope scope;
  1157. v8::Local<v8::Object> obj = New<v8::Object>();
  1158. handle.Reset(obj);
  1159. SetFunction(fn);
  1160. }
  1161. ~Callback() {
  1162. if (handle.IsEmpty()) return;
  1163. handle.Reset();
  1164. }
  1165. bool operator==(const Callback &other) const {
  1166. HandleScope scope;
  1167. v8::Local<v8::Value> a = New(handle)->Get(kCallbackIndex);
  1168. v8::Local<v8::Value> b = New(other.handle)->Get(kCallbackIndex);
  1169. return a->StrictEquals(b);
  1170. }
  1171. bool operator!=(const Callback &other) const {
  1172. return !this->operator==(other);
  1173. }
  1174. inline
  1175. v8::Local<v8::Function> operator*() const { return this->GetFunction(); }
  1176. inline v8::Local<v8::Value> operator()(
  1177. v8::Local<v8::Object> target
  1178. , int argc = 0
  1179. , v8::Local<v8::Value> argv[] = 0) const {
  1180. return this->Call(target, argc, argv);
  1181. }
  1182. inline v8::Local<v8::Value> operator()(
  1183. int argc = 0
  1184. , v8::Local<v8::Value> argv[] = 0) const {
  1185. return this->Call(argc, argv);
  1186. }
  1187. inline void SetFunction(const v8::Local<v8::Function> &fn) {
  1188. HandleScope scope;
  1189. Set(New(handle), kCallbackIndex, fn);
  1190. }
  1191. inline v8::Local<v8::Function> GetFunction() const {
  1192. EscapableHandleScope scope;
  1193. return scope.Escape(New(handle)->Get(kCallbackIndex)
  1194. .As<v8::Function>());
  1195. }
  1196. inline bool IsEmpty() const {
  1197. HandleScope scope;
  1198. return New(handle)->Get(kCallbackIndex)->IsUndefined();
  1199. }
  1200. inline v8::Local<v8::Value>
  1201. Call(v8::Local<v8::Object> target
  1202. , int argc
  1203. , v8::Local<v8::Value> argv[]) const {
  1204. #if (NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION)
  1205. v8::Isolate *isolate = v8::Isolate::GetCurrent();
  1206. return Call_(isolate, target, argc, argv);
  1207. #else
  1208. return Call_(target, argc, argv);
  1209. #endif
  1210. }
  1211. inline v8::Local<v8::Value>
  1212. Call(int argc, v8::Local<v8::Value> argv[]) const {
  1213. #if (NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION)
  1214. v8::Isolate *isolate = v8::Isolate::GetCurrent();
  1215. return Call_(isolate, isolate->GetCurrentContext()->Global(), argc, argv);
  1216. #else
  1217. return Call_(v8::Context::GetCurrent()->Global(), argc, argv);
  1218. #endif
  1219. }
  1220. private:
  1221. NAN_DISALLOW_ASSIGN_COPY_MOVE(Callback)
  1222. Persistent<v8::Object> handle;
  1223. static const uint32_t kCallbackIndex = 0;
  1224. #if (NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION)
  1225. v8::Local<v8::Value> Call_(v8::Isolate *isolate
  1226. , v8::Local<v8::Object> target
  1227. , int argc
  1228. , v8::Local<v8::Value> argv[]) const {
  1229. EscapableHandleScope scope;
  1230. v8::Local<v8::Function> callback = New(handle)->
  1231. Get(kCallbackIndex).As<v8::Function>();
  1232. # if NODE_MODULE_VERSION < IOJS_3_0_MODULE_VERSION
  1233. return scope.Escape(New(node::MakeCallback(
  1234. isolate
  1235. , target
  1236. , callback
  1237. , argc
  1238. , argv
  1239. )));
  1240. # else
  1241. return scope.Escape(node::MakeCallback(
  1242. isolate
  1243. , target
  1244. , callback
  1245. , argc
  1246. , argv
  1247. ));
  1248. # endif
  1249. }
  1250. #else
  1251. v8::Local<v8::Value> Call_(v8::Local<v8::Object> target
  1252. , int argc
  1253. , v8::Local<v8::Value> argv[]) const {
  1254. EscapableHandleScope scope;
  1255. v8::Local<v8::Function> callback = New(handle)->
  1256. Get(kCallbackIndex).As<v8::Function>();
  1257. return scope.Escape(New(node::MakeCallback(
  1258. target
  1259. , callback
  1260. , argc
  1261. , argv
  1262. )));
  1263. }
  1264. #endif
  1265. };
  1266. /* abstract */ class AsyncWorker {
  1267. public:
  1268. explicit AsyncWorker(Callback *callback_)
  1269. : callback(callback_), errmsg_(NULL) {
  1270. request.data = this;
  1271. HandleScope scope;
  1272. v8::Local<v8::Object> obj = New<v8::Object>();
  1273. persistentHandle.Reset(obj);
  1274. }
  1275. virtual ~AsyncWorker() {
  1276. HandleScope scope;
  1277. if (!persistentHandle.IsEmpty())
  1278. persistentHandle.Reset();
  1279. delete callback;
  1280. delete[] errmsg_;
  1281. }
  1282. virtual void WorkComplete() {
  1283. HandleScope scope;
  1284. if (errmsg_ == NULL)
  1285. HandleOKCallback();
  1286. else
  1287. HandleErrorCallback();
  1288. delete callback;
  1289. callback = NULL;
  1290. }
  1291. inline void SaveToPersistent(
  1292. const char *key, const v8::Local<v8::Value> &value) {
  1293. HandleScope scope;
  1294. New(persistentHandle)->Set(New(key).ToLocalChecked(), value);
  1295. }
  1296. inline void SaveToPersistent(
  1297. const v8::Local<v8::String> &key, const v8::Local<v8::Value> &value) {
  1298. HandleScope scope;
  1299. New(persistentHandle)->Set(key, value);
  1300. }
  1301. inline void SaveToPersistent(
  1302. uint32_t index, const v8::Local<v8::Value> &value) {
  1303. HandleScope scope;
  1304. New(persistentHandle)->Set(index, value);
  1305. }
  1306. inline v8::Local<v8::Value> GetFromPersistent(const char *key) const {
  1307. EscapableHandleScope scope;
  1308. return scope.Escape(
  1309. New(persistentHandle)->Get(New(key).ToLocalChecked()));
  1310. }
  1311. inline v8::Local<v8::Value>
  1312. GetFromPersistent(const v8::Local<v8::String> &key) const {
  1313. EscapableHandleScope scope;
  1314. return scope.Escape(New(persistentHandle)->Get(key));
  1315. }
  1316. inline v8::Local<v8::Value> GetFromPersistent(uint32_t index) const {
  1317. EscapableHandleScope scope;
  1318. return scope.Escape(New(persistentHandle)->Get(index));
  1319. }
  1320. virtual void Execute() = 0;
  1321. uv_work_t request;
  1322. virtual void Destroy() {
  1323. delete this;
  1324. }
  1325. protected:
  1326. Persistent<v8::Object> persistentHandle;
  1327. Callback *callback;
  1328. virtual void HandleOKCallback() {
  1329. callback->Call(0, NULL);
  1330. }
  1331. virtual void HandleErrorCallback() {
  1332. HandleScope scope;
  1333. v8::Local<v8::Value> argv[] = {
  1334. v8::Exception::Error(New<v8::String>(ErrorMessage()).ToLocalChecked())
  1335. };
  1336. callback->Call(1, argv);
  1337. }
  1338. void SetErrorMessage(const char *msg) {
  1339. delete[] errmsg_;
  1340. size_t size = strlen(msg) + 1;
  1341. errmsg_ = new char[size];
  1342. memcpy(errmsg_, msg, size);
  1343. }
  1344. const char* ErrorMessage() const {
  1345. return errmsg_;
  1346. }
  1347. private:
  1348. NAN_DISALLOW_ASSIGN_COPY_MOVE(AsyncWorker)
  1349. char *errmsg_;
  1350. };
  1351. /* abstract */ class AsyncProgressWorker : public AsyncWorker {
  1352. public:
  1353. explicit AsyncProgressWorker(Callback *callback_)
  1354. : AsyncWorker(callback_), asyncdata_(NULL), asyncsize_(0) {
  1355. async = new uv_async_t;
  1356. uv_async_init(
  1357. uv_default_loop()
  1358. , async
  1359. , AsyncProgress_
  1360. );
  1361. async->data = this;
  1362. uv_mutex_init(&async_lock);
  1363. }
  1364. virtual ~AsyncProgressWorker() {
  1365. uv_mutex_destroy(&async_lock);
  1366. delete[] asyncdata_;
  1367. }
  1368. void WorkProgress() {
  1369. uv_mutex_lock(&async_lock);
  1370. char *data = asyncdata_;
  1371. size_t size = asyncsize_;
  1372. asyncdata_ = NULL;
  1373. uv_mutex_unlock(&async_lock