www.aleph1.co.uk Git - yaffs-website/blob - node_modules/nan/nan_implementation_12_inl.h

   1 /*********************************************************************
   2  * NAN - Native Abstractions for Node.js
   3  *
   4  * Copyright (c) 2017 NAN contributors
   5  *
   6  * MIT License <https://github.com/nodejs/nan/blob/master/LICENSE.md>
   7  ********************************************************************/
   8
   9 #ifndef NAN_IMPLEMENTATION_12_INL_H_
  10 #define NAN_IMPLEMENTATION_12_INL_H_
  11 //==============================================================================
  12 // node v0.11 implementation
  13 //==============================================================================
  14
  15 namespace imp {
  16
  17 //=== Array ====================================================================
  18
  19 Factory<v8::Array>::return_t
  20 Factory<v8::Array>::New() {
  21   return v8::Array::New(v8::Isolate::GetCurrent());
  22 }
  23
  24 Factory<v8::Array>::return_t
  25 Factory<v8::Array>::New(int length) {
  26   return v8::Array::New(v8::Isolate::GetCurrent(), length);
  27 }
  28
  29 //=== Boolean ==================================================================
  30
  31 Factory<v8::Boolean>::return_t
  32 Factory<v8::Boolean>::New(bool value) {
  33   return v8::Boolean::New(v8::Isolate::GetCurrent(), value);
  34 }
  35
  36 //=== Boolean Object ===========================================================
  37
  38 Factory<v8::BooleanObject>::return_t
  39 Factory<v8::BooleanObject>::New(bool value) {
  40 #if (NODE_MODULE_VERSION >= NODE_6_0_MODULE_VERSION)
  41   return v8::BooleanObject::New(
  42     v8::Isolate::GetCurrent(), value).As<v8::BooleanObject>();
  43 #else
  44   return v8::BooleanObject::New(value).As<v8::BooleanObject>();
  45 #endif
  46 }
  47
  48 //=== Context ==================================================================
  49
  50 Factory<v8::Context>::return_t
  51 Factory<v8::Context>::New( v8::ExtensionConfiguration* extensions
  52                          , v8::Local<v8::ObjectTemplate> tmpl
  53                          , v8::Local<v8::Value> obj) {
  54   return v8::Context::New(v8::Isolate::GetCurrent(), extensions, tmpl, obj);
  55 }
  56
  57 //=== Date =====================================================================
  58
  59 #if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 ||                      \
  60   (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3))
  61 Factory<v8::Date>::return_t
  62 Factory<v8::Date>::New(double value) {
  63   v8::Isolate *isolate = v8::Isolate::GetCurrent();
  64   v8::EscapableHandleScope scope(isolate);
  65   return scope.Escape(v8::Date::New(isolate->GetCurrentContext(), value)
  66       .FromMaybe(v8::Local<v8::Value>()).As<v8::Date>());
  67 }
  68 #else
  69 Factory<v8::Date>::return_t
  70 Factory<v8::Date>::New(double value) {
  71   return v8::Date::New(v8::Isolate::GetCurrent(), value).As<v8::Date>();
  72 }
  73 #endif
  74
  75 //=== External =================================================================
  76
  77 Factory<v8::External>::return_t
  78 Factory<v8::External>::New(void * value) {
  79   return v8::External::New(v8::Isolate::GetCurrent(), value);
  80 }
  81
  82 //=== Function =================================================================
  83
  84 Factory<v8::Function>::return_t
  85 Factory<v8::Function>::New( FunctionCallback callback
  86                           , v8::Local<v8::Value> data) {
  87   v8::Isolate *isolate = v8::Isolate::GetCurrent();
  88   v8::EscapableHandleScope scope(isolate);
  89   v8::Local<v8::ObjectTemplate> tpl = v8::ObjectTemplate::New(isolate);
  90   tpl->SetInternalFieldCount(imp::kFunctionFieldCount);
  91   v8::Local<v8::Object> obj = NewInstance(tpl).ToLocalChecked();
  92
  93   obj->SetInternalField(
  94       imp::kFunctionIndex
  95     , v8::External::New(isolate, reinterpret_cast<void *>(callback)));
  96
  97   v8::Local<v8::Value> val = v8::Local<v8::Value>::New(isolate, data);
  98
  99   if (!val.IsEmpty()) {
 100     obj->SetInternalField(imp::kDataIndex, val);
 101   }
 102
 103   return scope.Escape(v8::Function::New( isolate
 104                           , imp::FunctionCallbackWrapper
 105                           , obj));
 106 }
 107
 108 //=== Function Template ========================================================
 109
 110 Factory<v8::FunctionTemplate>::return_t
 111 Factory<v8::FunctionTemplate>::New( FunctionCallback callback
 112                                   , v8::Local<v8::Value> data
 113                                   , v8::Local<v8::Signature> signature) {
 114   v8::Isolate *isolate = v8::Isolate::GetCurrent();
 115   if (callback) {
 116     v8::EscapableHandleScope scope(isolate);
 117     v8::Local<v8::ObjectTemplate> tpl = v8::ObjectTemplate::New(isolate);
 118     tpl->SetInternalFieldCount(imp::kFunctionFieldCount);
 119     v8::Local<v8::Object> obj = NewInstance(tpl).ToLocalChecked();
 120
 121     obj->SetInternalField(
 122         imp::kFunctionIndex
 123       , v8::External::New(isolate, reinterpret_cast<void *>(callback)));
 124     v8::Local<v8::Value> val = v8::Local<v8::Value>::New(isolate, data);
 125
 126     if (!val.IsEmpty()) {
 127       obj->SetInternalField(imp::kDataIndex, val);
 128     }
 129
 130     return scope.Escape(v8::FunctionTemplate::New( isolate
 131                                     , imp::FunctionCallbackWrapper
 132                                     , obj
 133                                     , signature));
 134   } else {
 135     return v8::FunctionTemplate::New(isolate, 0, data, signature);
 136   }
 137 }
 138
 139 //=== Number ===================================================================
 140
 141 Factory<v8::Number>::return_t
 142 Factory<v8::Number>::New(double value) {
 143   return v8::Number::New(v8::Isolate::GetCurrent(), value);
 144 }
 145
 146 //=== Number Object ============================================================
 147
 148 Factory<v8::NumberObject>::return_t
 149 Factory<v8::NumberObject>::New(double value) {
 150   return v8::NumberObject::New( v8::Isolate::GetCurrent()
 151                               , value).As<v8::NumberObject>();
 152 }
 153
 154 //=== Integer, Int32 and Uint32 ================================================
 155
 156 template <typename T>
 157 typename IntegerFactory<T>::return_t
 158 IntegerFactory<T>::New(int32_t value) {
 159   return To<T>(T::New(v8::Isolate::GetCurrent(), value));
 160 }
 161
 162 template <typename T>
 163 typename IntegerFactory<T>::return_t
 164 IntegerFactory<T>::New(uint32_t value) {
 165   return To<T>(T::NewFromUnsigned(v8::Isolate::GetCurrent(), value));
 166 }
 167
 168 Factory<v8::Uint32>::return_t
 169 Factory<v8::Uint32>::New(int32_t value) {
 170   return To<v8::Uint32>(
 171       v8::Uint32::NewFromUnsigned(v8::Isolate::GetCurrent(), value));
 172 }
 173
 174 Factory<v8::Uint32>::return_t
 175 Factory<v8::Uint32>::New(uint32_t value) {
 176   return To<v8::Uint32>(
 177       v8::Uint32::NewFromUnsigned(v8::Isolate::GetCurrent(), value));
 178 }
 179
 180 //=== Object ===================================================================
 181
 182 Factory<v8::Object>::return_t
 183 Factory<v8::Object>::New() {
 184   return v8::Object::New(v8::Isolate::GetCurrent());
 185 }
 186
 187 //=== Object Template ==========================================================
 188
 189 Factory<v8::ObjectTemplate>::return_t
 190 Factory<v8::ObjectTemplate>::New() {
 191   return v8::ObjectTemplate::New(v8::Isolate::GetCurrent());
 192 }
 193
 194 //=== RegExp ===================================================================
 195
 196 #if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 ||                      \
 197   (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3))
 198 Factory<v8::RegExp>::return_t
 199 Factory<v8::RegExp>::New(
 200     v8::Local<v8::String> pattern
 201   , v8::RegExp::Flags flags) {
 202   v8::Isolate *isolate = v8::Isolate::GetCurrent();
 203   v8::EscapableHandleScope scope(isolate);
 204   return scope.Escape(
 205       v8::RegExp::New(isolate->GetCurrentContext(), pattern, flags)
 206           .FromMaybe(v8::Local<v8::RegExp>()));
 207 }
 208 #else
 209 Factory<v8::RegExp>::return_t
 210 Factory<v8::RegExp>::New(
 211     v8::Local<v8::String> pattern
 212   , v8::RegExp::Flags flags) {
 213   return v8::RegExp::New(pattern, flags);
 214 }
 215 #endif
 216
 217 //=== Script ===================================================================
 218
 219 #if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 ||                      \
 220   (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3))
 221 Factory<v8::Script>::return_t
 222 Factory<v8::Script>::New( v8::Local<v8::String> source) {
 223   v8::Isolate *isolate = v8::Isolate::GetCurrent();
 224   v8::EscapableHandleScope scope(isolate);
 225   v8::ScriptCompiler::Source src(source);
 226   return scope.Escape(
 227       v8::ScriptCompiler::Compile(isolate->GetCurrentContext(), &src)
 228           .FromMaybe(v8::Local<v8::Script>()));
 229 }
 230
 231 Factory<v8::Script>::return_t
 232 Factory<v8::Script>::New( v8::Local<v8::String> source
 233                         , v8::ScriptOrigin const& origin) {
 234   v8::Isolate *isolate = v8::Isolate::GetCurrent();
 235   v8::EscapableHandleScope scope(isolate);
 236   v8::ScriptCompiler::Source src(source, origin);
 237   return scope.Escape(
 238       v8::ScriptCompiler::Compile(isolate->GetCurrentContext(), &src)
 239           .FromMaybe(v8::Local<v8::Script>()));
 240 }
 241 #else
 242 Factory<v8::Script>::return_t
 243 Factory<v8::Script>::New( v8::Local<v8::String> source) {
 244   v8::ScriptCompiler::Source src(source);
 245   return v8::ScriptCompiler::Compile(v8::Isolate::GetCurrent(), &src);
 246 }
 247
 248 Factory<v8::Script>::return_t
 249 Factory<v8::Script>::New( v8::Local<v8::String> source
 250                         , v8::ScriptOrigin const& origin) {
 251   v8::ScriptCompiler::Source src(source, origin);
 252   return v8::ScriptCompiler::Compile(v8::Isolate::GetCurrent(), &src);
 253 }
 254 #endif
 255
 256 //=== Signature ================================================================
 257
 258 Factory<v8::Signature>::return_t
 259 Factory<v8::Signature>::New(Factory<v8::Signature>::FTH receiver) {
 260   return v8::Signature::New(v8::Isolate::GetCurrent(), receiver);
 261 }
 262
 263 //=== String ===================================================================
 264
 265 Factory<v8::String>::return_t
 266 Factory<v8::String>::New() {
 267   return v8::String::Empty(v8::Isolate::GetCurrent());
 268 }
 269
 270 #if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 ||                      \
 271   (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3))
 272 Factory<v8::String>::return_t
 273 Factory<v8::String>::New(const char * value, int length) {
 274   return v8::String::NewFromUtf8(
 275       v8::Isolate::GetCurrent(), value, v8::NewStringType::kNormal, length);
 276 }
 277
 278 Factory<v8::String>::return_t
 279 Factory<v8::String>::New(std::string const& value) {
 280   assert(value.size() <= INT_MAX && "string too long");
 281   return v8::String::NewFromUtf8(v8::Isolate::GetCurrent(),
 282       value.data(), v8::NewStringType::kNormal, static_cast<int>(value.size()));
 283 }
 284
 285 Factory<v8::String>::return_t
 286 Factory<v8::String>::New(const uint16_t * value, int length) {
 287   return v8::String::NewFromTwoByte(v8::Isolate::GetCurrent(), value,
 288         v8::NewStringType::kNormal, length);
 289 }
 290
 291 Factory<v8::String>::return_t
 292 Factory<v8::String>::New(v8::String::ExternalStringResource * value) {
 293   return v8::String::NewExternalTwoByte(v8::Isolate::GetCurrent(), value);
 294 }
 295
 296 Factory<v8::String>::return_t
 297 Factory<v8::String>::New(ExternalOneByteStringResource * value) {
 298   return v8::String::NewExternalOneByte(v8::Isolate::GetCurrent(), value);
 299 }
 300 #else
 301 Factory<v8::String>::return_t
 302 Factory<v8::String>::New(const char * value, int length) {
 303   return v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), value,
 304                                  v8::String::kNormalString, length);
 305 }
 306
 307 Factory<v8::String>::return_t
 308 Factory<v8::String>::New(
 309     std::string const& value) /* NOLINT(build/include_what_you_use) */ {
 310   assert(value.size() <= INT_MAX && "string too long");
 311   return v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), value.data(),
 312                                  v8::String::kNormalString,
 313                                  static_cast<int>(value.size()));
 314 }
 315
 316 Factory<v8::String>::return_t
 317 Factory<v8::String>::New(const uint16_t * value, int length) {
 318   return v8::String::NewFromTwoByte(v8::Isolate::GetCurrent(), value,
 319                                     v8::String::kNormalString, length);
 320 }
 321
 322 Factory<v8::String>::return_t
 323 Factory<v8::String>::New(v8::String::ExternalStringResource * value) {
 324   return v8::String::NewExternal(v8::Isolate::GetCurrent(), value);
 325 }
 326
 327 Factory<v8::String>::return_t
 328 Factory<v8::String>::New(ExternalOneByteStringResource * value) {
 329   return v8::String::NewExternal(v8::Isolate::GetCurrent(), value);
 330 }
 331 #endif
 332
 333 //=== String Object ============================================================
 334
 335 Factory<v8::StringObject>::return_t
 336 Factory<v8::StringObject>::New(v8::Local<v8::String> value) {
 337   return v8::StringObject::New(value).As<v8::StringObject>();
 338 }
 339
 340 //=== Unbound Script ===========================================================
 341
 342 #if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 ||                      \
 343   (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3))
 344 Factory<v8::UnboundScript>::return_t
 345 Factory<v8::UnboundScript>::New(v8::Local<v8::String> source) {
 346   v8::ScriptCompiler::Source src(source);
 347   return v8::ScriptCompiler::CompileUnboundScript(
 348       v8::Isolate::GetCurrent(), &src);
 349 }
 350
 351 Factory<v8::UnboundScript>::return_t
 352 Factory<v8::UnboundScript>::New( v8::Local<v8::String> source
 353                                , v8::ScriptOrigin const& origin) {
 354   v8::ScriptCompiler::Source src(source, origin);
 355   return v8::ScriptCompiler::CompileUnboundScript(
 356       v8::Isolate::GetCurrent(), &src);
 357 }
 358 #else
 359 Factory<v8::UnboundScript>::return_t
 360 Factory<v8::UnboundScript>::New(v8::Local<v8::String> source) {
 361   v8::ScriptCompiler::Source src(source);
 362   return v8::ScriptCompiler::CompileUnbound(v8::Isolate::GetCurrent(), &src);
 363 }
 364
 365 Factory<v8::UnboundScript>::return_t
 366 Factory<v8::UnboundScript>::New( v8::Local<v8::String> source
 367                                , v8::ScriptOrigin const& origin) {
 368   v8::ScriptCompiler::Source src(source, origin);
 369   return v8::ScriptCompiler::CompileUnbound(v8::Isolate::GetCurrent(), &src);
 370 }
 371 #endif
 372
 373 }  // end of namespace imp
 374
 375 //=== Presistents and Handles ==================================================
 376
 377 #if NODE_MODULE_VERSION < IOJS_3_0_MODULE_VERSION
 378 template <typename T>
 379 inline v8::Local<T> New(v8::Handle<T> h) {
 380   return v8::Local<T>::New(v8::Isolate::GetCurrent(), h);
 381 }
 382 #endif
 383
 384 template <typename T, typename M>
 385 inline v8::Local<T> New(v8::Persistent<T, M> const& p) {
 386   return v8::Local<T>::New(v8::Isolate::GetCurrent(), p);
 387 }
 388
 389 template <typename T, typename M>
 390 inline v8::Local<T> New(Persistent<T, M> const& p) {
 391   return v8::Local<T>::New(v8::Isolate::GetCurrent(), p);
 392 }
 393
 394 template <typename T>
 395 inline v8::Local<T> New(Global<T> const& p) {
 396   return v8::Local<T>::New(v8::Isolate::GetCurrent(), p);
 397 }
 398
 399 #endif  // NAN_IMPLEMENTATION_12_INL_H_