Where Online Learning is simpler!
The C and C++ Include Header Files
/usr/include/node/v8-object.h
$ cat -n /usr/include/node/v8-object.h 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_OBJECT_H_ 6 #define INCLUDE_V8_OBJECT_H_ 7 8 #include "v8-local-handle.h" // NOLINT(build/include_directory) 9 #include "v8-maybe.h" // NOLINT(build/include_directory) 10 #include "v8-persistent-handle.h" // NOLINT(build/include_directory) 11 #include "v8-primitive.h" // NOLINT(build/include_directory) 12 #include "v8-traced-handle.h" // NOLINT(build/include_directory) 13 #include "v8-value.h" // NOLINT(build/include_directory) 14 #include "v8config.h" // NOLINT(build/include_directory) 15 16 namespace v8 { 17 18 class Array; 19 class Function; 20 class FunctionTemplate; 21 template
22 class PropertyCallbackInfo; 23 24 /** 25 * A private symbol 26 * 27 * This is an experimental feature. Use at your own risk. 28 */ 29 class V8_EXPORT Private : public Data { 30 public: 31 /** 32 * Returns the print name string of the private symbol, or undefined if none. 33 */ 34 Local
Name() const; 35 36 /** 37 * Create a private symbol. If name is not empty, it will be the description. 38 */ 39 static Local
New(Isolate* isolate, 40 Local
name = Local
()); 41 42 /** 43 * Retrieve a global private symbol. If a symbol with this name has not 44 * been retrieved in the same isolate before, it is created. 45 * Note that private symbols created this way are never collected, so 46 * they should only be used for statically fixed properties. 47 * Also, there is only one global name space for the names used as keys. 48 * To minimize the potential for clashes, use qualified names as keys, 49 * e.g., "Class#property". 50 */ 51 static Local
ForApi(Isolate* isolate, Local
name); 52 53 V8_INLINE static Private* Cast(Data* data); 54 55 private: 56 Private(); 57 58 static void CheckCast(Data* that); 59 }; 60 61 /** 62 * An instance of a Property Descriptor, see Ecma-262 6.2.4. 63 * 64 * Properties in a descriptor are present or absent. If you do not set 65 * `enumerable`, `configurable`, and `writable`, they are absent. If `value`, 66 * `get`, or `set` are absent, but you must specify them in the constructor, use 67 * empty handles. 68 * 69 * Accessors `get` and `set` must be callable or undefined if they are present. 70 * 71 * \note Only query properties if they are present, i.e., call `x()` only if 72 * `has_x()` returns true. 73 * 74 * \code 75 * // var desc = {writable: false} 76 * v8::PropertyDescriptor d(Local
()), false); 77 * d.value(); // error, value not set 78 * if (d.has_writable()) { 79 * d.writable(); // false 80 * } 81 * 82 * // var desc = {value: undefined} 83 * v8::PropertyDescriptor d(v8::Undefined(isolate)); 84 * 85 * // var desc = {get: undefined} 86 * v8::PropertyDescriptor d(v8::Undefined(isolate), Local
())); 87 * \endcode 88 */ 89 class V8_EXPORT PropertyDescriptor { 90 public: 91 // GenericDescriptor 92 PropertyDescriptor(); 93 94 // DataDescriptor 95 explicit PropertyDescriptor(Local
value); 96 97 // DataDescriptor with writable property 98 PropertyDescriptor(Local
value, bool writable); 99 100 // AccessorDescriptor 101 PropertyDescriptor(Local
get, Local
set); 102 103 ~PropertyDescriptor(); 104 105 Local
value() const; 106 bool has_value() const; 107 108 Local
get() const; 109 bool has_get() const; 110 Local
set() const; 111 bool has_set() const; 112 113 void set_enumerable(bool enumerable); 114 bool enumerable() const; 115 bool has_enumerable() const; 116 117 void set_configurable(bool configurable); 118 bool configurable() const; 119 bool has_configurable() const; 120 121 bool writable() const; 122 bool has_writable() const; 123 124 struct PrivateData; 125 PrivateData* get_private() const { return private_; } 126 127 PropertyDescriptor(const PropertyDescriptor&) = delete; 128 void operator=(const PropertyDescriptor&) = delete; 129 130 private: 131 PrivateData* private_; 132 }; 133 134 /** 135 * PropertyAttribute. 136 */ 137 enum PropertyAttribute { 138 /** None. **/ 139 None = 0, 140 /** ReadOnly, i.e., not writable. **/ 141 ReadOnly = 1 << 0, 142 /** DontEnum, i.e., not enumerable. **/ 143 DontEnum = 1 << 1, 144 /** DontDelete, i.e., not configurable. **/ 145 DontDelete = 1 << 2 146 }; 147 148 /** 149 * Accessor[Getter|Setter] are used as callback functions when 150 * setting|getting a particular property. See Object and ObjectTemplate's 151 * method SetAccessor. 152 */ 153 using AccessorGetterCallback = 154 void (*)(Local
property, const PropertyCallbackInfo
& info); 155 using AccessorNameGetterCallback = 156 void (*)(Local
property, const PropertyCallbackInfo
& info); 157 158 using AccessorSetterCallback = void (*)(Local
property, 159 Local
value, 160 const PropertyCallbackInfo
& info); 161 using AccessorNameSetterCallback = 162 void (*)(Local
property, Local
value, 163 const PropertyCallbackInfo
& info); 164 165 /** 166 * Access control specifications. 167 * 168 * Some accessors should be accessible across contexts. These 169 * accessors have an explicit access control parameter which specifies 170 * the kind of cross-context access that should be allowed. 171 * 172 */ 173 enum AccessControl { 174 DEFAULT = 0, 175 }; 176 177 /** 178 * Property filter bits. They can be or'ed to build a composite filter. 179 */ 180 enum PropertyFilter { 181 ALL_PROPERTIES = 0, 182 ONLY_WRITABLE = 1, 183 ONLY_ENUMERABLE = 2, 184 ONLY_CONFIGURABLE = 4, 185 SKIP_STRINGS = 8, 186 SKIP_SYMBOLS = 16 187 }; 188 189 /** 190 * Options for marking whether callbacks may trigger JS-observable side effects. 191 * Side-effect-free callbacks are allowlisted during debug evaluation with 192 * throwOnSideEffect. It applies when calling a Function, FunctionTemplate, 193 * or an Accessor callback. For Interceptors, please see 194 * PropertyHandlerFlags's kHasNoSideEffect. 195 * Callbacks that only cause side effects to the receiver are allowlisted if 196 * invoked on receiver objects that are created within the same debug-evaluate 197 * call, as these objects are temporary and the side effect does not escape. 198 */ 199 enum class SideEffectType { 200 kHasSideEffect, 201 kHasNoSideEffect, 202 kHasSideEffectToReceiver 203 }; 204 205 /** 206 * Keys/Properties filter enums: 207 * 208 * KeyCollectionMode limits the range of collected properties. kOwnOnly limits 209 * the collected properties to the given Object only. kIncludesPrototypes will 210 * include all keys of the objects's prototype chain as well. 211 */ 212 enum class KeyCollectionMode { kOwnOnly, kIncludePrototypes }; 213 214 /** 215 * kIncludesIndices allows for integer indices to be collected, while 216 * kSkipIndices will exclude integer indices from being collected. 217 */ 218 enum class IndexFilter { kIncludeIndices, kSkipIndices }; 219 220 /** 221 * kConvertToString will convert integer indices to strings. 222 * kKeepNumbers will return numbers for integer indices. 223 */ 224 enum class KeyConversionMode { kConvertToString, kKeepNumbers, kNoNumbers }; 225 226 /** 227 * Integrity level for objects. 228 */ 229 enum class IntegrityLevel { kFrozen, kSealed }; 230 231 /** 232 * A JavaScript object (ECMA-262, 4.3.3) 233 */ 234 class V8_EXPORT Object : public Value { 235 public: 236 /** 237 * Set only return Just(true) or Empty(), so if it should never fail, use 238 * result.Check(). 239 */ 240 V8_WARN_UNUSED_RESULT Maybe
Set(Local
context, 241 Local
key, Local
value); 242 243 V8_WARN_UNUSED_RESULT Maybe
Set(Local
context, uint32_t index, 244 Local
value); 245 246 /** 247 * Implements CreateDataProperty(O, P, V), see 248 * https://tc39.es/ecma262/#sec-createdataproperty. 249 * 250 * Defines a configurable, writable, enumerable property with the given value 251 * on the object unless the property already exists and is not configurable 252 * or the object is not extensible. 253 * 254 * Returns true on success. 255 */ 256 V8_WARN_UNUSED_RESULT Maybe
CreateDataProperty(Local
context, 257 Local
key, 258 Local
value); 259 V8_WARN_UNUSED_RESULT Maybe
CreateDataProperty(Local
context, 260 uint32_t index, 261 Local
value); 262 263 /** 264 * Implements [[DefineOwnProperty]] for data property case, see 265 * https://tc39.es/ecma262/#table-essential-internal-methods. 266 * 267 * In general, CreateDataProperty will be faster, however, does not allow 268 * for specifying attributes. 269 * 270 * Returns true on success. 271 */ 272 V8_WARN_UNUSED_RESULT Maybe
DefineOwnProperty( 273 Local
context, Local
key, Local
value, 274 PropertyAttribute attributes = None); 275 276 /** 277 * Implements Object.defineProperty(O, P, Attributes), see 278 * https://tc39.es/ecma262/#sec-object.defineproperty. 279 * 280 * The defineProperty function is used to add an own property or 281 * update the attributes of an existing own property of an object. 282 * 283 * Both data and accessor descriptors can be used. 284 * 285 * In general, CreateDataProperty is faster, however, does not allow 286 * for specifying attributes or an accessor descriptor. 287 * 288 * The PropertyDescriptor can change when redefining a property. 289 * 290 * Returns true on success. 291 */ 292 V8_WARN_UNUSED_RESULT Maybe
DefineProperty( 293 Local
context, Local
key, PropertyDescriptor& descriptor); 294 295 V8_WARN_UNUSED_RESULT MaybeLocal
Get(Local
context, 296 Local
key); 297 298 V8_WARN_UNUSED_RESULT MaybeLocal
Get(Local
context, 299 uint32_t index); 300 301 /** 302 * Gets the property attributes of a property which can be None or 303 * any combination of ReadOnly, DontEnum and DontDelete. Returns 304 * None when the property doesn't exist. 305 */ 306 V8_WARN_UNUSED_RESULT Maybe
GetPropertyAttributes( 307 Local
context, Local
key); 308 309 /** 310 * Implements Object.getOwnPropertyDescriptor(O, P), see 311 * https://tc39.es/ecma262/#sec-object.getownpropertydescriptor. 312 */ 313 V8_WARN_UNUSED_RESULT MaybeLocal
GetOwnPropertyDescriptor( 314 Local
context, Local
key); 315 316 /** 317 * Object::Has() calls the abstract operation HasProperty(O, P), see 318 * https://tc39.es/ecma262/#sec-hasproperty. Has() returns 319 * true, if the object has the property, either own or on the prototype chain. 320 * Interceptors, i.e., PropertyQueryCallbacks, are called if present. 321 * 322 * Has() has the same side effects as JavaScript's `variable in object`. 323 * For example, calling Has() on a revoked proxy will throw an exception. 324 * 325 * \note Has() converts the key to a name, which possibly calls back into 326 * JavaScript. 327 * 328 * See also v8::Object::HasOwnProperty() and 329 * v8::Object::HasRealNamedProperty(). 330 */ 331 V8_WARN_UNUSED_RESULT Maybe
Has(Local
context, 332 Local
key); 333 334 V8_WARN_UNUSED_RESULT Maybe
Delete(Local
context, 335 Local
key); 336 337 V8_WARN_UNUSED_RESULT Maybe
Has(Local
context, uint32_t index); 338 339 V8_WARN_UNUSED_RESULT Maybe
Delete(Local
context, 340 uint32_t index); 341 342 V8_DEPRECATE_SOON("Use SetNativeDataProperty instead") 343 V8_WARN_UNUSED_RESULT Maybe
SetAccessor( 344 Local
context, Local
name, 345 AccessorNameGetterCallback getter, 346 AccessorNameSetterCallback setter = nullptr, 347 MaybeLocal
data = MaybeLocal
(), 348 AccessControl deprecated_settings = DEFAULT, 349 PropertyAttribute attribute = None, 350 SideEffectType getter_side_effect_type = SideEffectType::kHasSideEffect, 351 SideEffectType setter_side_effect_type = SideEffectType::kHasSideEffect); 352 353 void SetAccessorProperty(Local
name, Local
getter, 354 Local
setter = Local
(), 355 PropertyAttribute attributes = None); 356 357 /** 358 * Sets a native data property like Template::SetNativeDataProperty, but 359 * this method sets on this object directly. 360 */ 361 V8_WARN_UNUSED_RESULT Maybe
SetNativeDataProperty( 362 Local
context, Local
name, 363 AccessorNameGetterCallback getter, 364 AccessorNameSetterCallback setter = nullptr, 365 Local
data = Local
(), PropertyAttribute attributes = None, 366 SideEffectType getter_side_effect_type = SideEffectType::kHasSideEffect, 367 SideEffectType setter_side_effect_type = SideEffectType::kHasSideEffect); 368 369 /** 370 * Attempts to create a property with the given name which behaves like a data 371 * property, except that the provided getter is invoked (and provided with the 372 * data value) to supply its value the first time it is read. After the 373 * property is accessed once, it is replaced with an ordinary data property. 374 * 375 * Analogous to Template::SetLazyDataProperty. 376 */ 377 V8_WARN_UNUSED_RESULT Maybe
SetLazyDataProperty( 378 Local
context, Local
name, 379 AccessorNameGetterCallback getter, Local
data = Local
(), 380 PropertyAttribute attributes = None, 381 SideEffectType getter_side_effect_type = SideEffectType::kHasSideEffect, 382 SideEffectType setter_side_effect_type = SideEffectType::kHasSideEffect); 383 384 /** 385 * Functionality for private properties. 386 * This is an experimental feature, use at your own risk. 387 * Note: Private properties are not inherited. Do not rely on this, since it 388 * may change. 389 */ 390 Maybe
HasPrivate(Local
context, Local
key); 391 Maybe
SetPrivate(Local
context, Local
key, 392 Local
value); 393 Maybe
DeletePrivate(Local
context, Local
key); 394 MaybeLocal
GetPrivate(Local
context, Local
key); 395 396 /** 397 * Returns an array containing the names of the enumerable properties 398 * of this object, including properties from prototype objects. The 399 * array returned by this method contains the same values as would 400 * be enumerated by a for-in statement over this object. 401 */ 402 V8_WARN_UNUSED_RESULT MaybeLocal
GetPropertyNames( 403 Local
context); 404 V8_WARN_UNUSED_RESULT MaybeLocal
GetPropertyNames( 405 Local
context, KeyCollectionMode mode, 406 PropertyFilter property_filter, IndexFilter index_filter, 407 KeyConversionMode key_conversion = KeyConversionMode::kKeepNumbers); 408 409 /** 410 * This function has the same functionality as GetPropertyNames but 411 * the returned array doesn't contain the names of properties from 412 * prototype objects. 413 */ 414 V8_WARN_UNUSED_RESULT MaybeLocal
GetOwnPropertyNames( 415 Local
context); 416 417 /** 418 * Returns an array containing the names of the filtered properties 419 * of this object, including properties from prototype objects. The 420 * array returned by this method contains the same values as would 421 * be enumerated by a for-in statement over this object. 422 */ 423 V8_WARN_UNUSED_RESULT MaybeLocal
GetOwnPropertyNames( 424 Local
context, PropertyFilter filter, 425 KeyConversionMode key_conversion = KeyConversionMode::kKeepNumbers); 426 427 /** 428 * Get the prototype object. This does not skip objects marked to 429 * be skipped by __proto__ and it does not consult the security 430 * handler. 431 */ 432 Local
GetPrototype(); 433 434 /** 435 * Set the prototype object. This does not skip objects marked to 436 * be skipped by __proto__ and it does not consult the security 437 * handler. 438 */ 439 V8_WARN_UNUSED_RESULT Maybe
SetPrototype(Local
context, 440 Local
prototype); 441 442 /** 443 * Finds an instance of the given function template in the prototype 444 * chain. 445 */ 446 Local
FindInstanceInPrototypeChain(Local
tmpl); 447 448 /** 449 * Call builtin Object.prototype.toString on this object. 450 * This is different from Value::ToString() that may call 451 * user-defined toString function. This one does not. 452 */ 453 V8_WARN_UNUSED_RESULT MaybeLocal
ObjectProtoToString( 454 Local
context); 455 456 /** 457 * Returns the name of the function invoked as a constructor for this object. 458 */ 459 Local
GetConstructorName(); 460 461 /** 462 * Sets the integrity level of the object. 463 */ 464 Maybe
SetIntegrityLevel(Local
context, IntegrityLevel level); 465 466 /** Gets the number of internal fields for this Object. */ 467 int InternalFieldCount() const; 468 469 /** Same as above, but works for PersistentBase. */ 470 V8_INLINE static int InternalFieldCount( 471 const PersistentBase
& object) { 472 return object.template value
()->InternalFieldCount(); 473 } 474 475 /** Same as above, but works for BasicTracedReference. */ 476 V8_INLINE static int InternalFieldCount( 477 const BasicTracedReference
& object) { 478 return object.template value
()->InternalFieldCount(); 479 } 480 481 /** 482 * Gets the data from an internal field. 483 * To cast the return value into v8::Value subtypes, it needs to be 484 * casted to a v8::Value first. For example, to cast it into v8::External: 485 * 486 * object->GetInternalField(index).As
().As
(); 487 * 488 * The embedder should make sure that the internal field being retrieved 489 * using this method has already been set with SetInternalField() before. 490 **/ 491 V8_INLINE Local
GetInternalField(int index); 492 493 /** Sets the data in an internal field. */ 494 void SetInternalField(int index, Local
data); 495 496 /** 497 * Gets a 2-byte-aligned native pointer from an internal field. This field 498 * must have been set by SetAlignedPointerInInternalField, everything else 499 * leads to undefined behavior. 500 */ 501 V8_INLINE void* GetAlignedPointerFromInternalField(int index); 502 V8_INLINE void* GetAlignedPointerFromInternalField(v8::Isolate* isolate, 503 int index); 504 505 /** Same as above, but works for PersistentBase. */ 506 V8_INLINE static void* GetAlignedPointerFromInternalField( 507 const PersistentBase
& object, int index) { 508 return object.template value
()->GetAlignedPointerFromInternalField( 509 index); 510 } 511 512 /** Same as above, but works for TracedReference. */ 513 V8_INLINE static void* GetAlignedPointerFromInternalField( 514 const BasicTracedReference
& object, int index) { 515 return object.template value
()->GetAlignedPointerFromInternalField( 516 index); 517 } 518 519 /** 520 * Sets a 2-byte-aligned native pointer in an internal field. To retrieve such 521 * a field, GetAlignedPointerFromInternalField must be used, everything else 522 * leads to undefined behavior. 523 */ 524 void SetAlignedPointerInInternalField(int index, void* value); 525 void SetAlignedPointerInInternalFields(int argc, int indices[], 526 void* values[]); 527 528 /** 529 * HasOwnProperty() is like JavaScript's Object.prototype.hasOwnProperty(). 530 * 531 * See also v8::Object::Has() and v8::Object::HasRealNamedProperty(). 532 */ 533 V8_WARN_UNUSED_RESULT Maybe
HasOwnProperty(Local
context, 534 Local
key); 535 V8_WARN_UNUSED_RESULT Maybe
HasOwnProperty(Local
context, 536 uint32_t index); 537 /** 538 * Use HasRealNamedProperty() if you want to check if an object has an own 539 * property without causing side effects, i.e., without calling interceptors. 540 * 541 * This function is similar to v8::Object::HasOwnProperty(), but it does not 542 * call interceptors. 543 * 544 * \note Consider using non-masking interceptors, i.e., the interceptors are 545 * not called if the receiver has the real named property. See 546 * `v8::PropertyHandlerFlags::kNonMasking`. 547 * 548 * See also v8::Object::Has(). 549 */ 550 V8_WARN_UNUSED_RESULT Maybe
HasRealNamedProperty(Local
context, 551 Local
key); 552 V8_WARN_UNUSED_RESULT Maybe
HasRealIndexedProperty( 553 Local
context, uint32_t index); 554 V8_WARN_UNUSED_RESULT Maybe
HasRealNamedCallbackProperty( 555 Local
context, Local
key); 556 557 /** 558 * If result.IsEmpty() no real property was located in the prototype chain. 559 * This means interceptors in the prototype chain are not called. 560 */ 561 V8_WARN_UNUSED_RESULT MaybeLocal
GetRealNamedPropertyInPrototypeChain( 562 Local
context, Local
key); 563 564 /** 565 * Gets the property attributes of a real property in the prototype chain, 566 * which can be None or any combination of ReadOnly, DontEnum and DontDelete. 567 * Interceptors in the prototype chain are not called. 568 */ 569 V8_WARN_UNUSED_RESULT Maybe
570 GetRealNamedPropertyAttributesInPrototypeChain(Local
context, 571 Local
key); 572 573 /** 574 * If result.IsEmpty() no real property was located on the object or 575 * in the prototype chain. 576 * This means interceptors in the prototype chain are not called. 577 */ 578 V8_WARN_UNUSED_RESULT MaybeLocal
GetRealNamedProperty( 579 Local
context, Local
key); 580 581 /** 582 * Gets the property attributes of a real property which can be 583 * None or any combination of ReadOnly, DontEnum and DontDelete. 584 * Interceptors in the prototype chain are not called. 585 */ 586 V8_WARN_UNUSED_RESULT Maybe
GetRealNamedPropertyAttributes( 587 Local
context, Local
key); 588 589 /** Tests for a named lookup interceptor.*/ 590 bool HasNamedLookupInterceptor() const; 591 592 /** Tests for an index lookup interceptor.*/ 593 bool HasIndexedLookupInterceptor() const; 594 595 /** 596 * Returns the identity hash for this object. The current implementation 597 * uses a hidden property on the object to store the identity hash. 598 * 599 * The return value will never be 0. Also, it is not guaranteed to be 600 * unique. 601 */ 602 int GetIdentityHash(); 603 604 /** 605 * Clone this object with a fast but shallow copy. Values will point 606 * to the same values as the original object. 607 */ 608 // TODO(dcarney): take an isolate and optionally bail out? 609 Local
Clone(); 610 611 /** 612 * Returns the context in which the object was created. 613 */ 614 MaybeLocal
GetCreationContext(); 615 616 /** 617 * Shortcut for GetCreationContext().ToLocalChecked(). 618 **/ 619 Local
GetCreationContextChecked(); 620 621 /** Same as above, but works for Persistents */ 622 V8_INLINE static MaybeLocal
GetCreationContext( 623 const PersistentBase
& object) { 624 return object.template value
()->GetCreationContext(); 625 } 626 627 /** 628 * Gets the context in which the object was created (see GetCreationContext()) 629 * and if it's available reads respective embedder field value. 630 * If the context can't be obtained nullptr is returned. 631 * Basically it's a shortcut for 632 * obj->GetCreationContext().GetAlignedPointerFromEmbedderData(index) 633 * which doesn't create a handle for Context object on the way and doesn't 634 * try to expand the embedder data attached to the context. 635 * In case the Local
is already available because of other reasons, 636 * it's fine to keep using Context::GetAlignedPointerFromEmbedderData(). 637 */ 638 void* GetAlignedPointerFromEmbedderDataInCreationContext(int index); 639 640 /** 641 * Checks whether a callback is set by the 642 * ObjectTemplate::SetCallAsFunctionHandler method. 643 * When an Object is callable this method returns true. 644 */ 645 bool IsCallable() const; 646 647 /** 648 * True if this object is a constructor. 649 */ 650 bool IsConstructor() const; 651 652 /** 653 * True if this object can carry information relevant to the embedder in its 654 * embedder fields, false otherwise. This is generally true for objects 655 * constructed through function templates but also holds for other types where 656 * V8 automatically adds internal fields at compile time, such as e.g. 657 * v8::ArrayBuffer. 658 */ 659 bool IsApiWrapper() const; 660 661 /** 662 * True if this object was created from an object template which was marked 663 * as undetectable. See v8::ObjectTemplate::MarkAsUndetectable for more 664 * information. 665 */ 666 bool IsUndetectable() const; 667 668 /** 669 * Call an Object as a function if a callback is set by the 670 * ObjectTemplate::SetCallAsFunctionHandler method. 671 */ 672 V8_WARN_UNUSED_RESULT MaybeLocal
CallAsFunction(Local
context, 673 Local
recv, 674 int argc, 675 Local
argv[]); 676 677 /** 678 * Call an Object as a constructor if a callback is set by the 679 * ObjectTemplate::SetCallAsFunctionHandler method. 680 * Note: This method behaves like the Function::NewInstance method. 681 */ 682 V8_WARN_UNUSED_RESULT MaybeLocal
CallAsConstructor( 683 Local
context, int argc, Local
argv[]); 684 685 /** 686 * Return the isolate to which the Object belongs to. 687 */ 688 Isolate* GetIsolate(); 689 690 V8_INLINE static Isolate* GetIsolate(const TracedReference
& handle) { 691 return handle.template value
()->GetIsolate(); 692 } 693 694 /** 695 * If this object is a Set, Map, WeakSet or WeakMap, this returns a 696 * representation of the elements of this object as an array. 697 * If this object is a SetIterator or MapIterator, this returns all 698 * elements of the underlying collection, starting at the iterator's current 699 * position. 700 * For other types, this will return an empty MaybeLocal
(without 701 * scheduling an exception). 702 */ 703 MaybeLocal
PreviewEntries(bool* is_key_value); 704 705 static Local
New(Isolate* isolate); 706 707 /** 708 * Creates a JavaScript object with the given properties, and 709 * a the given prototype_or_null (which can be any JavaScript 710 * value, and if it's null, the newly created object won't have 711 * a prototype at all). This is similar to Object.create(). 712 * All properties will be created as enumerable, configurable 713 * and writable properties. 714 */ 715 static Local
New(Isolate* isolate, Local
prototype_or_null, 716 Local
* names, Local
* values, 717 size_t length); 718 719 V8_INLINE static Object* Cast(Value* obj); 720 721 /** 722 * Support for TC39 "dynamic code brand checks" proposal. 723 * 724 * This API allows to query whether an object was constructed from a 725 * "code like" ObjectTemplate. 726 * 727 * See also: v8::ObjectTemplate::SetCodeLike 728 */ 729 bool IsCodeLike(Isolate* isolate) const; 730 731 private: 732 Object(); 733 static void CheckCast(Value* obj); 734 Local
SlowGetInternalField(int index); 735 void* SlowGetAlignedPointerFromInternalField(int index); 736 void* SlowGetAlignedPointerFromInternalField(v8::Isolate* isolate, int index); 737 }; 738 739 // --- Implementation --- 740 741 Local
Object::GetInternalField(int index) { 742 #ifndef V8_ENABLE_CHECKS 743 using A = internal::Address; 744 using I = internal::Internals; 745 A obj = internal::ValueHelper::ValueAsAddress(this); 746 // Fast path: If the object is a plain JSObject, which is the common case, we 747 // know where to find the internal fields and can return the value directly. 748 int instance_type = I::GetInstanceType(obj); 749 if (I::CanHaveInternalField(instance_type)) { 750 int offset = I::kJSObjectHeaderSize + (I::kEmbedderDataSlotSize * index); 751 A value = I::ReadRawField
(obj, offset); 752 #ifdef V8_COMPRESS_POINTERS 753 // We read the full pointer value and then decompress it in order to avoid 754 // dealing with potential endiannes issues. 755 value = I::DecompressTaggedField(obj, static_cast
(value)); 756 #endif 757 758 auto isolate = reinterpret_cast
( 759 internal::IsolateFromNeverReadOnlySpaceObject(obj)); 760 return Local
::New(isolate, value); 761 } 762 #endif 763 return SlowGetInternalField(index); 764 } 765 766 void* Object::GetAlignedPointerFromInternalField(v8::Isolate* isolate, 767 int index) { 768 #if !defined(V8_ENABLE_CHECKS) 769 using A = internal::Address; 770 using I = internal::Internals; 771 A obj = internal::ValueHelper::ValueAsAddress(this); 772 // Fast path: If the object is a plain JSObject, which is the common case, we 773 // know where to find the internal fields and can return the value directly. 774 auto instance_type = I::GetInstanceType(obj); 775 if (V8_LIKELY(I::CanHaveInternalField(instance_type))) { 776 int offset = I::kJSObjectHeaderSize + (I::kEmbedderDataSlotSize * index) + 777 I::kEmbedderDataSlotExternalPointerOffset; 778 A value = 779 I::ReadExternalPointerField
( 780 isolate, obj, offset); 781 return reinterpret_cast
(value); 782 } 783 #endif 784 return SlowGetAlignedPointerFromInternalField(isolate, index); 785 } 786 787 void* Object::GetAlignedPointerFromInternalField(int index) { 788 #if !defined(V8_ENABLE_CHECKS) 789 using A = internal::Address; 790 using I = internal::Internals; 791 A obj = internal::ValueHelper::ValueAsAddress(this); 792 // Fast path: If the object is a plain JSObject, which is the common case, we 793 // know where to find the internal fields and can return the value directly. 794 auto instance_type = I::GetInstanceType(obj); 795 if (V8_LIKELY(I::CanHaveInternalField(instance_type))) { 796 int offset = I::kJSObjectHeaderSize + (I::kEmbedderDataSlotSize * index) + 797 I::kEmbedderDataSlotExternalPointerOffset; 798 Isolate* isolate = I::GetIsolateForSandbox(obj); 799 A value = 800 I::ReadExternalPointerField
( 801 isolate, obj, offset); 802 return reinterpret_cast
(value); 803 } 804 #endif 805 return SlowGetAlignedPointerFromInternalField(index); 806 } 807 808 Private* Private::Cast(Data* data) { 809 #ifdef V8_ENABLE_CHECKS 810 CheckCast(data); 811 #endif 812 return reinterpret_cast
(data); 813 } 814 815 Object* Object::Cast(v8::Value* value) { 816 #ifdef V8_ENABLE_CHECKS 817 CheckCast(value); 818 #endif 819 return static_cast
(value); 820 } 821 822 } // namespace v8 823 824 #endif // INCLUDE_V8_OBJECT_H_
Contact us
|
About us
|
Term of use
|
Copyright © 2000-2025 MyWebUniversity.com ™