node_modules/websocket/node_modules/nan/nan_implementation_12_inl.h

   1 /*********************************************************************
   2  * NAN - Native Abstractions for Node.js
   3  *
   4  * Copyright (c) 2018 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 #if NODE_MAJOR_VERSION >= 10
 104   v8::Local<v8::Context> context = isolate->GetCurrentContext();
 105   v8::Local<v8::Function> function =
 106       v8::Function::New(context, imp::FunctionCallbackWrapper, obj)
 107       .ToLocalChecked();
 108 #else
 109   v8::Local<v8::Function> function =
 110       v8::Function::New(isolate, imp::FunctionCallbackWrapper, obj);
 111 #endif
 112
 113   return scope.Escape(function);
 114 }
 115
 116 //=== Function Template ========================================================
 117
 118 Factory<v8::FunctionTemplate>::return_t
 119 Factory<v8::FunctionTemplate>::New( FunctionCallback callback
 120                                   , v8::Local<v8::Value> data
 121                                   , v8::Local<v8::Signature> signature) {
 122   v8::Isolate *isolate = v8::Isolate::GetCurrent();
 123   if (callback) {
 124     v8::EscapableHandleScope scope(isolate);
 125     v8::Local<v8::ObjectTemplate> tpl = v8::ObjectTemplate::New(isolate);
 126     tpl->SetInternalFieldCount(imp::kFunctionFieldCount);
 127     v8::Local<v8::Object> obj = NewInstance(tpl).ToLocalChecked();
 128
 129     obj->SetInternalField(
 130         imp::kFunctionIndex
 131       , v8::External::New(isolate, reinterpret_cast<void *>(callback)));
 132     v8::Local<v8::Value> val = v8::Local<v8::Value>::New(isolate, data);
 133
 134     if (!val.IsEmpty()) {
 135       obj->SetInternalField(imp::kDataIndex, val);
 136     }
 137
 138     return scope.Escape(v8::FunctionTemplate::New( isolate
 139                                     , imp::FunctionCallbackWrapper
 140                                     , obj
 141                                     , signature));
 142   } else {
 143     return v8::FunctionTemplate::New(isolate, 0, data, signature);
 144   }
 145 }
 146
 147 //=== Number ===================================================================
 148
 149 Factory<v8::Number>::return_t
 150 Factory<v8::Number>::New(double value) {
 151   return v8::Number::New(v8::Isolate::GetCurrent(), value);
 152 }
 153
 154 //=== Number Object ============================================================
 155
 156 Factory<v8::NumberObject>::return_t
 157 Factory<v8::NumberObject>::New(double value) {
 158   return v8::NumberObject::New( v8::Isolate::GetCurrent()
 159                               , value).As<v8::NumberObject>();
 160 }
 161
 162 //=== Integer, Int32 and Uint32 ================================================
 163
 164 template <typename T>
 165 typename IntegerFactory<T>::return_t
 166 IntegerFactory<T>::New(int32_t value) {
 167   return To<T>(T::New(v8::Isolate::GetCurrent(), value));
 168 }
 169
 170 template <typename T>
 171 typename IntegerFactory<T>::return_t
 172 IntegerFactory<T>::New(uint32_t value) {
 173   return To<T>(T::NewFromUnsigned(v8::Isolate::GetCurrent(), value));
 174 }
 175
 176 Factory<v8::Uint32>::return_t
 177 Factory<v8::Uint32>::New(int32_t value) {
 178   return To<v8::Uint32>(
 179       v8::Uint32::NewFromUnsigned(v8::Isolate::GetCurrent(), value));
 180 }
 181
 182 Factory<v8::Uint32>::return_t
 183 Factory<v8::Uint32>::New(uint32_t value) {
 184   return To<v8::Uint32>(
 185       v8::Uint32::NewFromUnsigned(v8::Isolate::GetCurrent(), value));
 186 }
 187
 188 //=== Object ===================================================================
 189
 190 Factory<v8::Object>::return_t
 191 Factory<v8::Object>::New() {
 192   return v8::Object::New(v8::Isolate::GetCurrent());
 193 }
 194
 195 //=== Object Template ==========================================================
 196
 197 Factory<v8::ObjectTemplate>::return_t
 198 Factory<v8::ObjectTemplate>::New() {
 199   return v8::ObjectTemplate::New(v8::Isolate::GetCurrent());
 200 }
 201
 202 //=== RegExp ===================================================================
 203
 204 #if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 ||                      \
 205   (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3))
 206 Factory<v8::RegExp>::return_t
 207 Factory<v8::RegExp>::New(
 208     v8::Local<v8::String> pattern
 209   , v8::RegExp::Flags flags) {
 210   v8::Isolate *isolate = v8::Isolate::GetCurrent();
 211   v8::EscapableHandleScope scope(isolate);
 212   return scope.Escape(
 213       v8::RegExp::New(isolate->GetCurrentContext(), pattern, flags)
 214           .FromMaybe(v8::Local<v8::RegExp>()));
 215 }
 216 #else
 217 Factory<v8::RegExp>::return_t
 218 Factory<v8::RegExp>::New(
 219     v8::Local<v8::String> pattern
 220   , v8::RegExp::Flags flags) {
 221   return v8::RegExp::New(pattern, flags);
 222 }
 223 #endif
 224
 225 //=== Script ===================================================================
 226
 227 #if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 ||                      \
 228   (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3))
 229 Factory<v8::Script>::return_t
 230 Factory<v8::Script>::New( v8::Local<v8::String> source) {
 231   v8::Isolate *isolate = v8::Isolate::GetCurrent();
 232   v8::EscapableHandleScope scope(isolate);
 233   v8::ScriptCompiler::Source src(source);
 234   return scope.Escape(
 235       v8::ScriptCompiler::Compile(isolate->GetCurrentContext(), &src)
 236           .FromMaybe(v8::Local<v8::Script>()));
 237 }
 238
 239 Factory<v8::Script>::return_t
 240 Factory<v8::Script>::New( v8::Local<v8::String> source
 241                         , v8::ScriptOrigin const& origin) {
 242   v8::Isolate *isolate = v8::Isolate::GetCurrent();
 243   v8::EscapableHandleScope scope(isolate);
 244   v8::ScriptCompiler::Source src(source, origin);
 245   return scope.Escape(
 246       v8::ScriptCompiler::Compile(isolate->GetCurrentContext(), &src)
 247           .FromMaybe(v8::Local<v8::Script>()));
 248 }
 249 #else
 250 Factory<v8::Script>::return_t
 251 Factory<v8::Script>::New( v8::Local<v8::String> source) {
 252   v8::ScriptCompiler::Source src(source);
 253   return v8::ScriptCompiler::Compile(v8::Isolate::GetCurrent(), &src);
 254 }
 255
 256 Factory<v8::Script>::return_t
 257 Factory<v8::Script>::New( v8::Local<v8::String> source
 258                         , v8::ScriptOrigin const& origin) {
 259   v8::ScriptCompiler::Source src(source, origin);
 260   return v8::ScriptCompiler::Compile(v8::Isolate::GetCurrent(), &src);
 261 }
 262 #endif
 263
 264 //=== Signature ================================================================
 265
 266 Factory<v8::Signature>::return_t
 267 Factory<v8::Signature>::New(Factory<v8::Signature>::FTH receiver) {
 268   return v8::Signature::New(v8::Isolate::GetCurrent(), receiver);
 269 }
 270
 271 //=== String ===================================================================
 272
 273 Factory<v8::String>::return_t
 274 Factory<v8::String>::New() {
 275   return v8::String::Empty(v8::Isolate::GetCurrent());
 276 }
 277
 278 #if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 ||                      \
 279   (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3))
 280 Factory<v8::String>::return_t
 281 Factory<v8::String>::New(const char * value, int length) {
 282   return v8::String::NewFromUtf8(
 283       v8::Isolate::GetCurrent(), value, v8::NewStringType::kNormal, length);
 284 }
 285
 286 Factory<v8::String>::return_t
 287 Factory<v8::String>::New(std::string const& value) {
 288   assert(value.size() <= INT_MAX && "string too long");
 289   return v8::String::NewFromUtf8(v8::Isolate::GetCurrent(),
 290       value.data(), v8::NewStringType::kNormal, static_cast<int>(value.size()));
 291 }
 292
 293 Factory<v8::String>::return_t
 294 Factory<v8::String>::New(const uint16_t * value, int length) {
 295   return v8::String::NewFromTwoByte(v8::Isolate::GetCurrent(), value,
 296         v8::NewStringType::kNormal, length);
 297 }
 298
 299 Factory<v8::String>::return_t
 300 Factory<v8::String>::New(v8::String::ExternalStringResource * value) {
 301   return v8::String::NewExternalTwoByte(v8::Isolate::GetCurrent(), value);
 302 }
 303
 304 Factory<v8::String>::return_t
 305 Factory<v8::String>::New(ExternalOneByteStringResource * value) {
 306   return v8::String::NewExternalOneByte(v8::Isolate::GetCurrent(), value);
 307 }
 308 #else
 309 Factory<v8::String>::return_t
 310 Factory<v8::String>::New(const char * value, int length) {
 311   return v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), value,
 312                                  v8::String::kNormalString, length);
 313 }
 314
 315 Factory<v8::String>::return_t
 316 Factory<v8::String>::New(
 317     std::string const& value) /* NOLINT(build/include_what_you_use) */ {
 318   assert(value.size() <= INT_MAX && "string too long");
 319   return v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), value.data(),
 320                                  v8::String::kNormalString,
 321                                  static_cast<int>(value.size()));
 322 }
 323
 324 Factory<v8::String>::return_t
 325 Factory<v8::String>::New(const uint16_t * value, int length) {
 326   return v8::String::NewFromTwoByte(v8::Isolate::GetCurrent(), value,
 327                                     v8::String::kNormalString, length);
 328 }
 329
 330 Factory<v8::String>::return_t
 331 Factory<v8::String>::New(v8::String::ExternalStringResource * value) {
 332   return v8::String::NewExternal(v8::Isolate::GetCurrent(), value);
 333 }
 334
 335 Factory<v8::String>::return_t
 336 Factory<v8::String>::New(ExternalOneByteStringResource * value) {
 337   return v8::String::NewExternal(v8::Isolate::GetCurrent(), value);
 338 }
 339 #endif
 340
 341 //=== String Object ============================================================
 342
 343 // See https://github.com/nodejs/nan/pull/811#discussion_r224594980.
 344 // Disable the warning as there is no way around it.
 345 // TODO(bnoordhuis) Use isolate-based version in Node.js v12.
 346 Factory<v8::StringObject>::return_t
 347 Factory<v8::StringObject>::New(v8::Local<v8::String> value) {
 348 // V8 > 7.0
 349 #if V8_MAJOR_VERSION > 7 || (V8_MAJOR_VERSION == 7 && V8_MINOR_VERSION > 0)
 350   return v8::StringObject::New(v8::Isolate::GetCurrent(), value)
 351       .As<v8::StringObject>();
 352 #else
 353 #ifdef _MSC_VER
 354 #pragma warning(push)
 355 #pragma warning(disable : 4996)
 356 #endif
 357 #ifdef __GNUC__
 358 #pragma GCC diagnostic push
 359 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 360 #endif
 361   return v8::StringObject::New(value).As<v8::StringObject>();
 362 #ifdef __GNUC__
 363 #pragma GCC diagnostic pop
 364 #endif
 365 #ifdef _MSC_VER
 366 #pragma warning(pop)
 367 #endif
 368 #endif
 369 }
 370
 371 //=== Unbound Script ===========================================================
 372
 373 #if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 ||                      \
 374   (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3))
 375 Factory<v8::UnboundScript>::return_t
 376 Factory<v8::UnboundScript>::New(v8::Local<v8::String> source) {
 377   v8::ScriptCompiler::Source src(source);
 378   return v8::ScriptCompiler::CompileUnboundScript(
 379       v8::Isolate::GetCurrent(), &src);
 380 }
 381
 382 Factory<v8::UnboundScript>::return_t
 383 Factory<v8::UnboundScript>::New( v8::Local<v8::String> source
 384                                , v8::ScriptOrigin const& origin) {
 385   v8::ScriptCompiler::Source src(source, origin);
 386   return v8::ScriptCompiler::CompileUnboundScript(
 387       v8::Isolate::GetCurrent(), &src);
 388 }
 389 #else
 390 Factory<v8::UnboundScript>::return_t
 391 Factory<v8::UnboundScript>::New(v8::Local<v8::String> source) {
 392   v8::ScriptCompiler::Source src(source);
 393   return v8::ScriptCompiler::CompileUnbound(v8::Isolate::GetCurrent(), &src);
 394 }
 395
 396 Factory<v8::UnboundScript>::return_t
 397 Factory<v8::UnboundScript>::New( v8::Local<v8::String> source
 398                                , v8::ScriptOrigin const& origin) {
 399   v8::ScriptCompiler::Source src(source, origin);
 400   return v8::ScriptCompiler::CompileUnbound(v8::Isolate::GetCurrent(), &src);
 401 }
 402 #endif
 403
 404 }  // end of namespace imp
 405
 406 //=== Presistents and Handles ==================================================
 407
 408 #if NODE_MODULE_VERSION < IOJS_3_0_MODULE_VERSION
 409 template <typename T>
 410 inline v8::Local<T> New(v8::Handle<T> h) {
 411   return v8::Local<T>::New(v8::Isolate::GetCurrent(), h);
 412 }
 413 #endif
 414
 415 template <typename T, typename M>
 416 inline v8::Local<T> New(v8::Persistent<T, M> const& p) {
 417   return v8::Local<T>::New(v8::Isolate::GetCurrent(), p);
 418 }
 419
 420 template <typename T, typename M>
 421 inline v8::Local<T> New(Persistent<T, M> const& p) {
 422   return v8::Local<T>::New(v8::Isolate::GetCurrent(), p);
 423 }
 424
 425 template <typename T>
 426 inline v8::Local<T> New(Global<T> const& p) {
 427   return v8::Local<T>::New(v8::Isolate::GetCurrent(), p);
 428 }
 429
 430 #endif  // NAN_IMPLEMENTATION_12_INL_H_