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
New()20 Factory<v8::Array>::New() {
21 return v8::Array::New(v8::Isolate::GetCurrent());
22 }
23
24 Factory<v8::Array>::return_t
New(int length)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
New(bool value)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
New(bool value)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
New(v8::ExtensionConfiguration * extensions,v8::Local<v8::ObjectTemplate> tmpl,v8::Local<v8::Value> obj)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
New(double value)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
New(double value)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
New(void * value)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
New(FunctionCallback callback,v8::Local<v8::Value> data)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
New(FunctionCallback callback,v8::Local<v8::Value> data,v8::Local<v8::Signature> signature)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
New(double value)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
New(double value)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
New(int32_t value)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
New(uint32_t value)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
New(int32_t value)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
New(uint32_t value)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
New()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
New()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
New(v8::Local<v8::String> pattern,v8::RegExp::Flags flags)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
New(v8::Local<v8::String> pattern,v8::RegExp::Flags flags)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
New(v8::Local<v8::String> source)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
New(v8::Local<v8::String> source,v8::ScriptOrigin const & origin)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
New(v8::Local<v8::String> source)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
New(v8::Local<v8::String> source,v8::ScriptOrigin const & origin)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
New(Factory<v8::Signature>::FTH receiver)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
New()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
New(const char * value,int length)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
New(std::string const & value)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
New(const uint16_t * value,int length)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
New(v8::String::ExternalStringResource * value)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
New(ExternalOneByteStringResource * value)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
New(const char * value,int length)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
New(std::string const & value)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
New(const uint16_t * value,int length)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
New(v8::String::ExternalStringResource * value)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
New(ExternalOneByteStringResource * value)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
New(v8::Local<v8::String> value)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
New(v8::Local<v8::String> source)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
New(v8::Local<v8::String> source,v8::ScriptOrigin const & origin)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
New(v8::Local<v8::String> source)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
New(v8::Local<v8::String> source,v8::ScriptOrigin const & origin)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>
New(v8::Handle<T> h)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>
New(v8::Persistent<T,M> const & p)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>
New(Persistent<T,M> const & p)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>
New(Global<T> const & p)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_
431