libv8-node 16.17.0.0-aarch64-linux → 17.9.1.0-aarch64-linux

Sign up to get free protection for your applications and to get access to all the features.
Files changed (69) hide show
  1. checksums.yaml +4 -4
  2. data/ext/libv8-node/paths.rb +1 -1
  3. data/lib/libv8/node/version.rb +3 -3
  4. data/vendor/v8/aarch64-linux/libv8/obj/libv8_monolith.a +0 -0
  5. data/vendor/v8/include/cppgc/allocation.h +11 -5
  6. data/vendor/v8/include/cppgc/cross-thread-persistent.h +78 -26
  7. data/vendor/v8/include/cppgc/internal/caged-heap-local-data.h +2 -2
  8. data/vendor/v8/include/cppgc/internal/finalizer-trait.h +2 -0
  9. data/vendor/v8/include/cppgc/internal/gc-info.h +90 -10
  10. data/vendor/v8/include/cppgc/internal/name-trait.h +11 -0
  11. data/vendor/v8/include/cppgc/internal/persistent-node.h +44 -12
  12. data/vendor/v8/include/cppgc/internal/pointer-policies.h +22 -11
  13. data/vendor/v8/include/cppgc/internal/write-barrier.h +9 -1
  14. data/vendor/v8/include/cppgc/persistent.h +1 -1
  15. data/vendor/v8/include/cppgc/prefinalizer.h +1 -1
  16. data/vendor/v8/include/v8-array-buffer.h +433 -0
  17. data/vendor/v8/include/v8-callbacks.h +377 -0
  18. data/vendor/v8/include/v8-container.h +129 -0
  19. data/vendor/v8/include/v8-context.h +418 -0
  20. data/vendor/v8/include/v8-cppgc.h +5 -2
  21. data/vendor/v8/include/v8-data.h +65 -0
  22. data/vendor/v8/include/v8-date.h +43 -0
  23. data/vendor/v8/include/v8-debug.h +151 -0
  24. data/vendor/v8/include/v8-embedder-heap.h +238 -0
  25. data/vendor/v8/include/v8-exception.h +224 -0
  26. data/vendor/v8/include/v8-extension.h +62 -0
  27. data/vendor/v8/include/v8-external.h +37 -0
  28. data/vendor/v8/include/v8-fast-api-calls.h +63 -11
  29. data/vendor/v8/include/v8-forward.h +81 -0
  30. data/vendor/v8/include/v8-function-callback.h +475 -0
  31. data/vendor/v8/include/v8-function.h +122 -0
  32. data/vendor/v8/include/v8-initialization.h +282 -0
  33. data/vendor/v8/include/v8-inspector.h +11 -21
  34. data/vendor/v8/include/v8-internal.h +85 -22
  35. data/vendor/v8/include/v8-isolate.h +1662 -0
  36. data/vendor/v8/include/v8-json.h +47 -0
  37. data/vendor/v8/include/v8-local-handle.h +459 -0
  38. data/vendor/v8/include/v8-locker.h +148 -0
  39. data/vendor/v8/include/v8-maybe.h +137 -0
  40. data/vendor/v8/include/v8-memory-span.h +43 -0
  41. data/vendor/v8/include/v8-message.h +241 -0
  42. data/vendor/v8/include/v8-metrics.h +37 -1
  43. data/vendor/v8/include/v8-microtask-queue.h +152 -0
  44. data/vendor/v8/include/v8-microtask.h +28 -0
  45. data/vendor/v8/include/v8-object.h +770 -0
  46. data/vendor/v8/include/v8-persistent-handle.h +590 -0
  47. data/vendor/v8/include/v8-platform.h +41 -17
  48. data/vendor/v8/include/v8-primitive-object.h +118 -0
  49. data/vendor/v8/include/v8-primitive.h +858 -0
  50. data/vendor/v8/include/v8-profiler.h +10 -11
  51. data/vendor/v8/include/v8-promise.h +174 -0
  52. data/vendor/v8/include/v8-proxy.h +50 -0
  53. data/vendor/v8/include/v8-regexp.h +105 -0
  54. data/vendor/v8/include/v8-script.h +771 -0
  55. data/vendor/v8/include/v8-snapshot.h +198 -0
  56. data/vendor/v8/include/v8-statistics.h +215 -0
  57. data/vendor/v8/include/v8-template.h +1052 -0
  58. data/vendor/v8/include/v8-traced-handle.h +605 -0
  59. data/vendor/v8/include/v8-typed-array.h +282 -0
  60. data/vendor/v8/include/v8-unwinder-state.h +4 -3
  61. data/vendor/v8/include/v8-unwinder.h +129 -0
  62. data/vendor/v8/include/v8-util.h +7 -1
  63. data/vendor/v8/include/v8-value-serializer.h +249 -0
  64. data/vendor/v8/include/v8-value.h +526 -0
  65. data/vendor/v8/include/v8-version.h +3 -3
  66. data/vendor/v8/include/v8-wasm.h +245 -0
  67. data/vendor/v8/include/v8-weak-callback-info.h +73 -0
  68. data/vendor/v8/include/v8.h +41 -12604
  69. metadata +45 -3
@@ -0,0 +1,81 @@
1
+ // Copyright 2021 the V8 project authors. All rights reserved.
2
+ // Use of this source code is governed by a BSD-style license that can be
3
+ // found in the LICENSE file.
4
+
5
+ #ifndef INCLUDE_V8_FORWARD_H_
6
+ #define INCLUDE_V8_FORWARD_H_
7
+
8
+ // This header is intended to be used by headers that pass around V8 types,
9
+ // either by pointer or using Local<Type>. The full definitions can be included
10
+ // either via v8.h or the more fine-grained headers.
11
+
12
+ #include "v8-local-handle.h" // NOLINT(build/include_directory)
13
+
14
+ namespace v8 {
15
+
16
+ class AccessorSignature;
17
+ class Array;
18
+ class ArrayBuffer;
19
+ class ArrayBufferView;
20
+ class BigInt;
21
+ class BigInt64Array;
22
+ class BigIntObject;
23
+ class BigUint64Array;
24
+ class Boolean;
25
+ class BooleanObject;
26
+ class Context;
27
+ class DataView;
28
+ class Data;
29
+ class Date;
30
+ class Extension;
31
+ class External;
32
+ class FixedArray;
33
+ class Float32Array;
34
+ class Float64Array;
35
+ class Function;
36
+ template <class F>
37
+ class FunctionCallbackInfo;
38
+ class FunctionTemplate;
39
+ class Int16Array;
40
+ class Int32;
41
+ class Int32Array;
42
+ class Int8Array;
43
+ class Integer;
44
+ class Isolate;
45
+ class Map;
46
+ class Module;
47
+ class Name;
48
+ class Number;
49
+ class NumberObject;
50
+ class Object;
51
+ class ObjectTemplate;
52
+ class Platform;
53
+ class Primitive;
54
+ class Private;
55
+ class Promise;
56
+ class Proxy;
57
+ class RegExp;
58
+ class Script;
59
+ class Set;
60
+ class SharedArrayBuffer;
61
+ class Signature;
62
+ class String;
63
+ class StringObject;
64
+ class Symbol;
65
+ class SymbolObject;
66
+ class Template;
67
+ class TryCatch;
68
+ class TypedArray;
69
+ class Uint16Array;
70
+ class Uint32;
71
+ class Uint32Array;
72
+ class Uint8Array;
73
+ class Uint8ClampedArray;
74
+ class UnboundModuleScript;
75
+ class Value;
76
+ class WasmMemoryObject;
77
+ class WasmModuleObject;
78
+
79
+ } // namespace v8
80
+
81
+ #endif // INCLUDE_V8_FORWARD_H_
@@ -0,0 +1,475 @@
1
+ // Copyright 2021 the V8 project authors. All rights reserved.
2
+ // Use of this source code is governed by a BSD-style license that can be
3
+ // found in the LICENSE file.
4
+
5
+ #ifndef INCLUDE_V8_FUNCTION_CALLBACK_H_
6
+ #define INCLUDE_V8_FUNCTION_CALLBACK_H_
7
+
8
+ #include "v8-local-handle.h" // NOLINT(build/include_directory)
9
+ #include "v8-primitive.h" // NOLINT(build/include_directory)
10
+ #include "v8config.h" // NOLINT(build/include_directory)
11
+
12
+ namespace v8 {
13
+
14
+ template <typename T>
15
+ class BasicTracedReference;
16
+ template <typename T>
17
+ class Global;
18
+ class Object;
19
+ class Value;
20
+
21
+ namespace internal {
22
+ class FunctionCallbackArguments;
23
+ class PropertyCallbackArguments;
24
+ } // namespace internal
25
+
26
+ namespace debug {
27
+ class ConsoleCallArguments;
28
+ } // namespace debug
29
+
30
+ template <typename T>
31
+ class ReturnValue {
32
+ public:
33
+ template <class S>
34
+ V8_INLINE ReturnValue(const ReturnValue<S>& that) : value_(that.value_) {
35
+ static_assert(std::is_base_of<T, S>::value, "type check");
36
+ }
37
+ // Local setters
38
+ template <typename S>
39
+ V8_INLINE void Set(const Global<S>& handle);
40
+ template <typename S>
41
+ V8_INLINE void Set(const BasicTracedReference<S>& handle);
42
+ template <typename S>
43
+ V8_INLINE void Set(const Local<S> handle);
44
+ // Fast primitive setters
45
+ V8_INLINE void Set(bool value);
46
+ V8_INLINE void Set(double i);
47
+ V8_INLINE void Set(int32_t i);
48
+ V8_INLINE void Set(uint32_t i);
49
+ // Fast JS primitive setters
50
+ V8_INLINE void SetNull();
51
+ V8_INLINE void SetUndefined();
52
+ V8_INLINE void SetEmptyString();
53
+ // Convenience getter for Isolate
54
+ V8_INLINE Isolate* GetIsolate() const;
55
+
56
+ // Pointer setter: Uncompilable to prevent inadvertent misuse.
57
+ template <typename S>
58
+ V8_INLINE void Set(S* whatever);
59
+
60
+ // Getter. Creates a new Local<> so it comes with a certain performance
61
+ // hit. If the ReturnValue was not yet set, this will return the undefined
62
+ // value.
63
+ V8_INLINE Local<Value> Get() const;
64
+
65
+ private:
66
+ template <class F>
67
+ friend class ReturnValue;
68
+ template <class F>
69
+ friend class FunctionCallbackInfo;
70
+ template <class F>
71
+ friend class PropertyCallbackInfo;
72
+ template <class F, class G, class H>
73
+ friend class PersistentValueMapBase;
74
+ V8_INLINE void SetInternal(internal::Address value) { *value_ = value; }
75
+ V8_INLINE internal::Address GetDefaultValue();
76
+ V8_INLINE explicit ReturnValue(internal::Address* slot);
77
+ internal::Address* value_;
78
+ };
79
+
80
+ /**
81
+ * The argument information given to function call callbacks. This
82
+ * class provides access to information about the context of the call,
83
+ * including the receiver, the number and values of arguments, and
84
+ * the holder of the function.
85
+ */
86
+ template <typename T>
87
+ class FunctionCallbackInfo {
88
+ public:
89
+ /** The number of available arguments. */
90
+ V8_INLINE int Length() const;
91
+ /**
92
+ * Accessor for the available arguments. Returns `undefined` if the index
93
+ * is out of bounds.
94
+ */
95
+ V8_INLINE Local<Value> operator[](int i) const;
96
+ /** Returns the receiver. This corresponds to the "this" value. */
97
+ V8_INLINE Local<Object> This() const;
98
+ /**
99
+ * If the callback was created without a Signature, this is the same
100
+ * value as This(). If there is a signature, and the signature didn't match
101
+ * This() but one of its hidden prototypes, this will be the respective
102
+ * hidden prototype.
103
+ *
104
+ * Note that this is not the prototype of This() on which the accessor
105
+ * referencing this callback was found (which in V8 internally is often
106
+ * referred to as holder [sic]).
107
+ */
108
+ V8_INLINE Local<Object> Holder() const;
109
+ /** For construct calls, this returns the "new.target" value. */
110
+ V8_INLINE Local<Value> NewTarget() const;
111
+ /** Indicates whether this is a regular call or a construct call. */
112
+ V8_INLINE bool IsConstructCall() const;
113
+ /** The data argument specified when creating the callback. */
114
+ V8_INLINE Local<Value> Data() const;
115
+ /** The current Isolate. */
116
+ V8_INLINE Isolate* GetIsolate() const;
117
+ /** The ReturnValue for the call. */
118
+ V8_INLINE ReturnValue<T> GetReturnValue() const;
119
+ // This shouldn't be public, but the arm compiler needs it.
120
+ static const int kArgsLength = 6;
121
+
122
+ protected:
123
+ friend class internal::FunctionCallbackArguments;
124
+ friend class internal::CustomArguments<FunctionCallbackInfo>;
125
+ friend class debug::ConsoleCallArguments;
126
+ static const int kHolderIndex = 0;
127
+ static const int kIsolateIndex = 1;
128
+ static const int kReturnValueDefaultValueIndex = 2;
129
+ static const int kReturnValueIndex = 3;
130
+ static const int kDataIndex = 4;
131
+ static const int kNewTargetIndex = 5;
132
+
133
+ V8_INLINE FunctionCallbackInfo(internal::Address* implicit_args,
134
+ internal::Address* values, int length);
135
+ internal::Address* implicit_args_;
136
+ internal::Address* values_;
137
+ int length_;
138
+ };
139
+
140
+ /**
141
+ * The information passed to a property callback about the context
142
+ * of the property access.
143
+ */
144
+ template <typename T>
145
+ class PropertyCallbackInfo {
146
+ public:
147
+ /**
148
+ * \return The isolate of the property access.
149
+ */
150
+ V8_INLINE Isolate* GetIsolate() const;
151
+
152
+ /**
153
+ * \return The data set in the configuration, i.e., in
154
+ * `NamedPropertyHandlerConfiguration` or
155
+ * `IndexedPropertyHandlerConfiguration.`
156
+ */
157
+ V8_INLINE Local<Value> Data() const;
158
+
159
+ /**
160
+ * \return The receiver. In many cases, this is the object on which the
161
+ * property access was intercepted. When using
162
+ * `Reflect.get`, `Function.prototype.call`, or similar functions, it is the
163
+ * object passed in as receiver or thisArg.
164
+ *
165
+ * \code
166
+ * void GetterCallback(Local<Name> name,
167
+ * const v8::PropertyCallbackInfo<v8::Value>& info) {
168
+ * auto context = info.GetIsolate()->GetCurrentContext();
169
+ *
170
+ * v8::Local<v8::Value> a_this =
171
+ * info.This()
172
+ * ->GetRealNamedProperty(context, v8_str("a"))
173
+ * .ToLocalChecked();
174
+ * v8::Local<v8::Value> a_holder =
175
+ * info.Holder()
176
+ * ->GetRealNamedProperty(context, v8_str("a"))
177
+ * .ToLocalChecked();
178
+ *
179
+ * CHECK(v8_str("r")->Equals(context, a_this).FromJust());
180
+ * CHECK(v8_str("obj")->Equals(context, a_holder).FromJust());
181
+ *
182
+ * info.GetReturnValue().Set(name);
183
+ * }
184
+ *
185
+ * v8::Local<v8::FunctionTemplate> templ =
186
+ * v8::FunctionTemplate::New(isolate);
187
+ * templ->InstanceTemplate()->SetHandler(
188
+ * v8::NamedPropertyHandlerConfiguration(GetterCallback));
189
+ * LocalContext env;
190
+ * env->Global()
191
+ * ->Set(env.local(), v8_str("obj"), templ->GetFunction(env.local())
192
+ * .ToLocalChecked()
193
+ * ->NewInstance(env.local())
194
+ * .ToLocalChecked())
195
+ * .FromJust();
196
+ *
197
+ * CompileRun("obj.a = 'obj'; var r = {a: 'r'}; Reflect.get(obj, 'x', r)");
198
+ * \endcode
199
+ */
200
+ V8_INLINE Local<Object> This() const;
201
+
202
+ /**
203
+ * \return The object in the prototype chain of the receiver that has the
204
+ * interceptor. Suppose you have `x` and its prototype is `y`, and `y`
205
+ * has an interceptor. Then `info.This()` is `x` and `info.Holder()` is `y`.
206
+ * The Holder() could be a hidden object (the global object, rather
207
+ * than the global proxy).
208
+ *
209
+ * \note For security reasons, do not pass the object back into the runtime.
210
+ */
211
+ V8_INLINE Local<Object> Holder() const;
212
+
213
+ /**
214
+ * \return The return value of the callback.
215
+ * Can be changed by calling Set().
216
+ * \code
217
+ * info.GetReturnValue().Set(...)
218
+ * \endcode
219
+ *
220
+ */
221
+ V8_INLINE ReturnValue<T> GetReturnValue() const;
222
+
223
+ /**
224
+ * \return True if the intercepted function should throw if an error occurs.
225
+ * Usually, `true` corresponds to `'use strict'`.
226
+ *
227
+ * \note Always `false` when intercepting `Reflect.set()`
228
+ * independent of the language mode.
229
+ */
230
+ V8_INLINE bool ShouldThrowOnError() const;
231
+
232
+ // This shouldn't be public, but the arm compiler needs it.
233
+ static const int kArgsLength = 7;
234
+
235
+ protected:
236
+ friend class MacroAssembler;
237
+ friend class internal::PropertyCallbackArguments;
238
+ friend class internal::CustomArguments<PropertyCallbackInfo>;
239
+ static const int kShouldThrowOnErrorIndex = 0;
240
+ static const int kHolderIndex = 1;
241
+ static const int kIsolateIndex = 2;
242
+ static const int kReturnValueDefaultValueIndex = 3;
243
+ static const int kReturnValueIndex = 4;
244
+ static const int kDataIndex = 5;
245
+ static const int kThisIndex = 6;
246
+
247
+ V8_INLINE PropertyCallbackInfo(internal::Address* args) : args_(args) {}
248
+ internal::Address* args_;
249
+ };
250
+
251
+ using FunctionCallback = void (*)(const FunctionCallbackInfo<Value>& info);
252
+
253
+ // --- Implementation ---
254
+
255
+ template <typename T>
256
+ ReturnValue<T>::ReturnValue(internal::Address* slot) : value_(slot) {}
257
+
258
+ template <typename T>
259
+ template <typename S>
260
+ void ReturnValue<T>::Set(const Global<S>& handle) {
261
+ static_assert(std::is_base_of<T, S>::value, "type check");
262
+ if (V8_UNLIKELY(handle.IsEmpty())) {
263
+ *value_ = GetDefaultValue();
264
+ } else {
265
+ *value_ = *reinterpret_cast<internal::Address*>(*handle);
266
+ }
267
+ }
268
+
269
+ template <typename T>
270
+ template <typename S>
271
+ void ReturnValue<T>::Set(const BasicTracedReference<S>& handle) {
272
+ static_assert(std::is_base_of<T, S>::value, "type check");
273
+ if (V8_UNLIKELY(handle.IsEmpty())) {
274
+ *value_ = GetDefaultValue();
275
+ } else {
276
+ *value_ = *reinterpret_cast<internal::Address*>(handle.val_);
277
+ }
278
+ }
279
+
280
+ template <typename T>
281
+ template <typename S>
282
+ void ReturnValue<T>::Set(const Local<S> handle) {
283
+ static_assert(std::is_void<T>::value || std::is_base_of<T, S>::value,
284
+ "type check");
285
+ if (V8_UNLIKELY(handle.IsEmpty())) {
286
+ *value_ = GetDefaultValue();
287
+ } else {
288
+ *value_ = *reinterpret_cast<internal::Address*>(*handle);
289
+ }
290
+ }
291
+
292
+ template <typename T>
293
+ void ReturnValue<T>::Set(double i) {
294
+ static_assert(std::is_base_of<T, Number>::value, "type check");
295
+ Set(Number::New(GetIsolate(), i));
296
+ }
297
+
298
+ template <typename T>
299
+ void ReturnValue<T>::Set(int32_t i) {
300
+ static_assert(std::is_base_of<T, Integer>::value, "type check");
301
+ using I = internal::Internals;
302
+ if (V8_LIKELY(I::IsValidSmi(i))) {
303
+ *value_ = I::IntToSmi(i);
304
+ return;
305
+ }
306
+ Set(Integer::New(GetIsolate(), i));
307
+ }
308
+
309
+ template <typename T>
310
+ void ReturnValue<T>::Set(uint32_t i) {
311
+ static_assert(std::is_base_of<T, Integer>::value, "type check");
312
+ // Can't simply use INT32_MAX here for whatever reason.
313
+ bool fits_into_int32_t = (i & (1U << 31)) == 0;
314
+ if (V8_LIKELY(fits_into_int32_t)) {
315
+ Set(static_cast<int32_t>(i));
316
+ return;
317
+ }
318
+ Set(Integer::NewFromUnsigned(GetIsolate(), i));
319
+ }
320
+
321
+ template <typename T>
322
+ void ReturnValue<T>::Set(bool value) {
323
+ static_assert(std::is_base_of<T, Boolean>::value, "type check");
324
+ using I = internal::Internals;
325
+ int root_index;
326
+ if (value) {
327
+ root_index = I::kTrueValueRootIndex;
328
+ } else {
329
+ root_index = I::kFalseValueRootIndex;
330
+ }
331
+ *value_ = *I::GetRoot(GetIsolate(), root_index);
332
+ }
333
+
334
+ template <typename T>
335
+ void ReturnValue<T>::SetNull() {
336
+ static_assert(std::is_base_of<T, Primitive>::value, "type check");
337
+ using I = internal::Internals;
338
+ *value_ = *I::GetRoot(GetIsolate(), I::kNullValueRootIndex);
339
+ }
340
+
341
+ template <typename T>
342
+ void ReturnValue<T>::SetUndefined() {
343
+ static_assert(std::is_base_of<T, Primitive>::value, "type check");
344
+ using I = internal::Internals;
345
+ *value_ = *I::GetRoot(GetIsolate(), I::kUndefinedValueRootIndex);
346
+ }
347
+
348
+ template <typename T>
349
+ void ReturnValue<T>::SetEmptyString() {
350
+ static_assert(std::is_base_of<T, String>::value, "type check");
351
+ using I = internal::Internals;
352
+ *value_ = *I::GetRoot(GetIsolate(), I::kEmptyStringRootIndex);
353
+ }
354
+
355
+ template <typename T>
356
+ Isolate* ReturnValue<T>::GetIsolate() const {
357
+ // Isolate is always the pointer below the default value on the stack.
358
+ return *reinterpret_cast<Isolate**>(&value_[-2]);
359
+ }
360
+
361
+ template <typename T>
362
+ Local<Value> ReturnValue<T>::Get() const {
363
+ using I = internal::Internals;
364
+ if (*value_ == *I::GetRoot(GetIsolate(), I::kTheHoleValueRootIndex))
365
+ return Local<Value>(*Undefined(GetIsolate()));
366
+ return Local<Value>::New(GetIsolate(), reinterpret_cast<Value*>(value_));
367
+ }
368
+
369
+ template <typename T>
370
+ template <typename S>
371
+ void ReturnValue<T>::Set(S* whatever) {
372
+ static_assert(sizeof(S) < 0, "incompilable to prevent inadvertent misuse");
373
+ }
374
+
375
+ template <typename T>
376
+ internal::Address ReturnValue<T>::GetDefaultValue() {
377
+ // Default value is always the pointer below value_ on the stack.
378
+ return value_[-1];
379
+ }
380
+
381
+ template <typename T>
382
+ FunctionCallbackInfo<T>::FunctionCallbackInfo(internal::Address* implicit_args,
383
+ internal::Address* values,
384
+ int length)
385
+ : implicit_args_(implicit_args), values_(values), length_(length) {}
386
+
387
+ template <typename T>
388
+ Local<Value> FunctionCallbackInfo<T>::operator[](int i) const {
389
+ // values_ points to the first argument (not the receiver).
390
+ if (i < 0 || length_ <= i) return Local<Value>(*Undefined(GetIsolate()));
391
+ return Local<Value>(reinterpret_cast<Value*>(values_ + i));
392
+ }
393
+
394
+ template <typename T>
395
+ Local<Object> FunctionCallbackInfo<T>::This() const {
396
+ // values_ points to the first argument (not the receiver).
397
+ return Local<Object>(reinterpret_cast<Object*>(values_ - 1));
398
+ }
399
+
400
+ template <typename T>
401
+ Local<Object> FunctionCallbackInfo<T>::Holder() const {
402
+ return Local<Object>(
403
+ reinterpret_cast<Object*>(&implicit_args_[kHolderIndex]));
404
+ }
405
+
406
+ template <typename T>
407
+ Local<Value> FunctionCallbackInfo<T>::NewTarget() const {
408
+ return Local<Value>(
409
+ reinterpret_cast<Value*>(&implicit_args_[kNewTargetIndex]));
410
+ }
411
+
412
+ template <typename T>
413
+ Local<Value> FunctionCallbackInfo<T>::Data() const {
414
+ return Local<Value>(reinterpret_cast<Value*>(&implicit_args_[kDataIndex]));
415
+ }
416
+
417
+ template <typename T>
418
+ Isolate* FunctionCallbackInfo<T>::GetIsolate() const {
419
+ return *reinterpret_cast<Isolate**>(&implicit_args_[kIsolateIndex]);
420
+ }
421
+
422
+ template <typename T>
423
+ ReturnValue<T> FunctionCallbackInfo<T>::GetReturnValue() const {
424
+ return ReturnValue<T>(&implicit_args_[kReturnValueIndex]);
425
+ }
426
+
427
+ template <typename T>
428
+ bool FunctionCallbackInfo<T>::IsConstructCall() const {
429
+ return !NewTarget()->IsUndefined();
430
+ }
431
+
432
+ template <typename T>
433
+ int FunctionCallbackInfo<T>::Length() const {
434
+ return length_;
435
+ }
436
+
437
+ template <typename T>
438
+ Isolate* PropertyCallbackInfo<T>::GetIsolate() const {
439
+ return *reinterpret_cast<Isolate**>(&args_[kIsolateIndex]);
440
+ }
441
+
442
+ template <typename T>
443
+ Local<Value> PropertyCallbackInfo<T>::Data() const {
444
+ return Local<Value>(reinterpret_cast<Value*>(&args_[kDataIndex]));
445
+ }
446
+
447
+ template <typename T>
448
+ Local<Object> PropertyCallbackInfo<T>::This() const {
449
+ return Local<Object>(reinterpret_cast<Object*>(&args_[kThisIndex]));
450
+ }
451
+
452
+ template <typename T>
453
+ Local<Object> PropertyCallbackInfo<T>::Holder() const {
454
+ return Local<Object>(reinterpret_cast<Object*>(&args_[kHolderIndex]));
455
+ }
456
+
457
+ template <typename T>
458
+ ReturnValue<T> PropertyCallbackInfo<T>::GetReturnValue() const {
459
+ return ReturnValue<T>(&args_[kReturnValueIndex]);
460
+ }
461
+
462
+ template <typename T>
463
+ bool PropertyCallbackInfo<T>::ShouldThrowOnError() const {
464
+ using I = internal::Internals;
465
+ if (args_[kShouldThrowOnErrorIndex] !=
466
+ I::IntToSmi(I::kInferShouldThrowMode)) {
467
+ return args_[kShouldThrowOnErrorIndex] != I::IntToSmi(I::kDontThrow);
468
+ }
469
+ return v8::internal::ShouldThrowOnError(
470
+ reinterpret_cast<v8::internal::Isolate*>(GetIsolate()));
471
+ }
472
+
473
+ } // namespace v8
474
+
475
+ #endif // INCLUDE_V8_FUNCTION_CALLBACK_H_
@@ -0,0 +1,122 @@
1
+ // Copyright 2021 the V8 project authors. All rights reserved.
2
+ // Use of this source code is governed by a BSD-style license that can be
3
+ // found in the LICENSE file.
4
+
5
+ #ifndef INCLUDE_V8_FUNCTION_H_
6
+ #define INCLUDE_V8_FUNCTION_H_
7
+
8
+ #include <stddef.h>
9
+ #include <stdint.h>
10
+
11
+ #include "v8-function-callback.h" // NOLINT(build/include_directory)
12
+ #include "v8-local-handle.h" // NOLINT(build/include_directory)
13
+ #include "v8-message.h" // NOLINT(build/include_directory)
14
+ #include "v8-object.h" // NOLINT(build/include_directory)
15
+ #include "v8-template.h" // NOLINT(build/include_directory)
16
+ #include "v8config.h" // NOLINT(build/include_directory)
17
+
18
+ namespace v8 {
19
+
20
+ class Context;
21
+
22
+ /**
23
+ * A JavaScript function object (ECMA-262, 15.3).
24
+ */
25
+ class V8_EXPORT Function : public Object {
26
+ public:
27
+ /**
28
+ * Create a function in the current execution context
29
+ * for a given FunctionCallback.
30
+ */
31
+ static MaybeLocal<Function> New(
32
+ Local<Context> context, FunctionCallback callback,
33
+ Local<Value> data = Local<Value>(), int length = 0,
34
+ ConstructorBehavior behavior = ConstructorBehavior::kAllow,
35
+ SideEffectType side_effect_type = SideEffectType::kHasSideEffect);
36
+
37
+ V8_WARN_UNUSED_RESULT MaybeLocal<Object> NewInstance(
38
+ Local<Context> context, int argc, Local<Value> argv[]) const;
39
+
40
+ V8_WARN_UNUSED_RESULT MaybeLocal<Object> NewInstance(
41
+ Local<Context> context) const {
42
+ return NewInstance(context, 0, nullptr);
43
+ }
44
+
45
+ /**
46
+ * When side effect checks are enabled, passing kHasNoSideEffect allows the
47
+ * constructor to be invoked without throwing. Calls made within the
48
+ * constructor are still checked.
49
+ */
50
+ V8_WARN_UNUSED_RESULT MaybeLocal<Object> NewInstanceWithSideEffectType(
51
+ Local<Context> context, int argc, Local<Value> argv[],
52
+ SideEffectType side_effect_type = SideEffectType::kHasSideEffect) const;
53
+
54
+ V8_WARN_UNUSED_RESULT MaybeLocal<Value> Call(Local<Context> context,
55
+ Local<Value> recv, int argc,
56
+ Local<Value> argv[]);
57
+
58
+ void SetName(Local<String> name);
59
+ Local<Value> GetName() const;
60
+
61
+ /**
62
+ * Name inferred from variable or property assignment of this function.
63
+ * Used to facilitate debugging and profiling of JavaScript code written
64
+ * in an OO style, where many functions are anonymous but are assigned
65
+ * to object properties.
66
+ */
67
+ Local<Value> GetInferredName() const;
68
+
69
+ /**
70
+ * displayName if it is set, otherwise name if it is configured, otherwise
71
+ * function name, otherwise inferred name.
72
+ */
73
+ Local<Value> GetDebugName() const;
74
+
75
+ /**
76
+ * Returns zero based line number of function body and
77
+ * kLineOffsetNotFound if no information available.
78
+ */
79
+ int GetScriptLineNumber() const;
80
+ /**
81
+ * Returns zero based column number of function body and
82
+ * kLineOffsetNotFound if no information available.
83
+ */
84
+ int GetScriptColumnNumber() const;
85
+
86
+ /**
87
+ * Returns scriptId.
88
+ */
89
+ int ScriptId() const;
90
+
91
+ /**
92
+ * Returns the original function if this function is bound, else returns
93
+ * v8::Undefined.
94
+ */
95
+ Local<Value> GetBoundFunction() const;
96
+
97
+ /**
98
+ * Calls builtin Function.prototype.toString on this function.
99
+ * This is different from Value::ToString() that may call a user-defined
100
+ * toString() function, and different than Object::ObjectProtoToString() which
101
+ * always serializes "[object Function]".
102
+ */
103
+ V8_WARN_UNUSED_RESULT MaybeLocal<String> FunctionProtoToString(
104
+ Local<Context> context);
105
+
106
+ ScriptOrigin GetScriptOrigin() const;
107
+ V8_INLINE static Function* Cast(Value* value) {
108
+ #ifdef V8_ENABLE_CHECKS
109
+ CheckCast(value);
110
+ #endif
111
+ return static_cast<Function*>(value);
112
+ }
113
+
114
+ static const int kLineOffsetNotFound;
115
+
116
+ private:
117
+ Function();
118
+ static void CheckCast(Value* obj);
119
+ };
120
+ } // namespace v8
121
+
122
+ #endif // INCLUDE_V8_FUNCTION_H_