v8-value.h

Go to the documentation of this file.

// Copyright 2021 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
 
#ifndef INCLUDE_V8_VALUE_H_
#define INCLUDE_V8_VALUE_H_
 
#include "v8-data.h"          // NOLINT(build/include_directory)
#include "v8-internal.h"      // NOLINT(build/include_directory)
#include "v8-local-handle.h"  // NOLINT(build/include_directory)
#include "v8-maybe.h"         // NOLINT(build/include_directory)
#include "v8config.h"         // NOLINT(build/include_directory)
 
namespace v8 {
 
class Primitive;
class Numeric;
class BigInt;
class Int32;
class Integer;
class Number;
class Object;
class String;
class Uint32;
 
class V8_EXPORT Value : public Data {
 public:
  V8_INLINE bool IsUndefined() const;
 
  V8_INLINE bool IsNull() const;
 
  V8_INLINE bool IsNullOrUndefined() const;
 
  V8_INLINE bool IsTrue() const;
 
  V8_INLINE bool IsFalse() const;
 
  bool IsName() const;
 
  V8_INLINE bool IsString() const;
 
  bool IsSymbol() const;
 
  bool IsFunction() const;
 
  bool IsArray() const;
 
  bool IsObject() const;
 
  bool IsBigInt() const;
 
  bool IsBoolean() const;
 
  bool IsNumber() const;
 
  bool IsExternal() const;
 
  bool IsInt32() const;
 
  bool IsUint32() const;
 
  bool IsDate() const;
 
  bool IsArgumentsObject() const;
 
  bool IsBigIntObject() const;
 
  bool IsBooleanObject() const;
 
  bool IsNumberObject() const;
 
  bool IsStringObject() const;
 
  bool IsSymbolObject() const;
 
  bool IsNativeError() const;
 
  bool IsRegExp() const;
 
  bool IsAsyncFunction() const;
 
  bool IsGeneratorFunction() const;
 
  bool IsGeneratorObject() const;
 
  bool IsPromise() const;
 
  bool IsMap() const;
 
  bool IsSet() const;
 
  bool IsMapIterator() const;
 
  bool IsSetIterator() const;
 
  bool IsWeakMap() const;
 
  bool IsWeakSet() const;
 
  bool IsWeakRef() const;
 
  bool IsArrayBuffer() const;
 
  bool IsArrayBufferView() const;
 
  bool IsTypedArray() const;
 
  bool IsUint8Array() const;
 
  bool IsUint8ClampedArray() const;
 
  bool IsInt8Array() const;
 
  bool IsUint16Array() const;
 
  bool IsInt16Array() const;
 
  bool IsUint32Array() const;
 
  bool IsInt32Array() const;
 
  bool IsFloat16Array() const;
 
  bool IsFloat32Array() const;
 
  bool IsFloat64Array() const;
 
  bool IsBigInt64Array() const;
 
  bool IsBigUint64Array() const;
 
  bool IsDataView() const;
 
  bool IsSharedArrayBuffer() const;
 
  bool IsProxy() const;
 
  bool IsWasmMemoryObject() const;
 
  bool IsWasmMemoryMapDescriptor() const;
 
  bool IsWasmModuleObject() const;
 
  bool IsWasmNull() const;
 
  bool IsModuleNamespaceObject() const;
 
  bool IsDeferredModuleNamespaceObject() const;
 
  bool IsPrimitive() const;
 
  V8_WARN_UNUSED_RESULT MaybeLocal<Primitive> ToPrimitive(
      Local<Context> context) const;
  V8_WARN_UNUSED_RESULT MaybeLocal<Numeric> ToNumeric(
      Local<Context> context) const;
  V8_WARN_UNUSED_RESULT MaybeLocal<BigInt> ToBigInt(
      Local<Context> context) const;
  V8_WARN_UNUSED_RESULT MaybeLocal<Number> ToNumber(
      Local<Context> context) const;
  V8_WARN_UNUSED_RESULT MaybeLocal<String> ToString(
      Local<Context> context) const;
  V8_WARN_UNUSED_RESULT MaybeLocal<String> ToDetailString(
      Local<Context> context) const;
  V8_WARN_UNUSED_RESULT MaybeLocal<Object> ToObject(
      Local<Context> context) const;
  V8_WARN_UNUSED_RESULT MaybeLocal<Integer> ToInteger(
      Local<Context> context) const;
  V8_WARN_UNUSED_RESULT MaybeLocal<Uint32> ToUint32(
      Local<Context> context) const;
  V8_WARN_UNUSED_RESULT MaybeLocal<Int32> ToInt32(Local<Context> context) const;
 
  Local<Boolean> ToBoolean(Isolate* isolate) const;
 
  V8_WARN_UNUSED_RESULT MaybeLocal<Uint32> ToArrayIndex(
      Local<Context> context) const;
 
  bool BooleanValue(Isolate* isolate) const;
 
  V8_WARN_UNUSED_RESULT Maybe<double> NumberValue(Local<Context> context) const;
  V8_WARN_UNUSED_RESULT Maybe<int64_t> IntegerValue(
      Local<Context> context) const;
  V8_WARN_UNUSED_RESULT Maybe<uint32_t> Uint32Value(
      Local<Context> context) const;
  V8_WARN_UNUSED_RESULT Maybe<int32_t> Int32Value(Local<Context> context) const;
 
  V8_WARN_UNUSED_RESULT Maybe<bool> Equals(Local<Context> context,
                                           Local<Value> that) const;
  bool StrictEquals(Local<Value> that) const;
  bool SameValue(Local<Value> that) const;
 
  template <class T>
  V8_INLINE static Value* Cast(T* value) {
    return static_cast<Value*>(value);
  }
 
  Local<String> TypeOf(Isolate*);
 
  Maybe<bool> InstanceOf(Local<Context> context, Local<Object> object);
 
  uint32_t GetHash();
 
 private:
  V8_INLINE bool QuickIsUndefined() const;
  V8_INLINE bool QuickIsNull() const;
  V8_INLINE bool QuickIsNullOrUndefined() const;
#if V8_STATIC_ROOTS_BOOL
  V8_INLINE bool QuickIsTrue() const;
  V8_INLINE bool QuickIsFalse() const;
#endif  // V8_STATIC_ROOTS_BOOL
  V8_INLINE bool QuickIsString() const;
  bool FullIsUndefined() const;
  bool FullIsNull() const;
  bool FullIsTrue() const;
  bool FullIsFalse() const;
  bool FullIsString() const;
 
  static void CheckCast(Data* that);
};
 
class V8_EXPORT TypecheckWitness {
 public:
  explicit TypecheckWitness(Isolate* isolate);
 
  V8_INLINE bool Matches(Local<Value> candidate) const;
 
  void Update(Local<Value> baseline);
 
 private:
  Local<Data> cached_map_;
};
 
template <>
V8_INLINE Value* Value::Cast(Data* value) {
#ifdef V8_ENABLE_CHECKS
  CheckCast(value);
#endif
  return static_cast<Value*>(value);
}
 
bool Value::IsUndefined() const {
#ifdef V8_ENABLE_CHECKS
  return FullIsUndefined();
#else
  return QuickIsUndefined();
#endif
}
 
bool Value::QuickIsUndefined() const {
  using A = internal::Address;
  using I = internal::Internals;
  A obj = internal::ValueHelper::ValueAsAddress(this);
#if V8_STATIC_ROOTS_BOOL
  return I::is_identical(obj, I::StaticReadOnlyRoot::kUndefinedValue);
#else
  if (!I::HasHeapObjectTag(obj)) return false;
  if (I::GetInstanceType(obj) != I::kOddballType) return false;
  return (I::GetOddballKind(obj) == I::kUndefinedOddballKind);
#endif  // V8_STATIC_ROOTS_BOOL
}
 
bool Value::IsNull() const {
#ifdef V8_ENABLE_CHECKS
  return FullIsNull();
#else
  return QuickIsNull();
#endif
}
 
bool Value::QuickIsNull() const {
  using A = internal::Address;
  using I = internal::Internals;
  A obj = internal::ValueHelper::ValueAsAddress(this);
#if V8_STATIC_ROOTS_BOOL
  return I::is_identical(obj, I::StaticReadOnlyRoot::kNullValue);
#else
  if (!I::HasHeapObjectTag(obj)) return false;
  if (I::GetInstanceType(obj) != I::kOddballType) return false;
  return (I::GetOddballKind(obj) == I::kNullOddballKind);
#endif  // V8_STATIC_ROOTS_BOOL
}
 
bool Value::IsNullOrUndefined() const {
#ifdef V8_ENABLE_CHECKS
  return FullIsNull() || FullIsUndefined();
#else
  return QuickIsNullOrUndefined();
#endif
}
 
bool Value::QuickIsNullOrUndefined() const {
#if V8_STATIC_ROOTS_BOOL
  return QuickIsNull() || QuickIsUndefined();
#else
  using A = internal::Address;
  using I = internal::Internals;
  A obj = internal::ValueHelper::ValueAsAddress(this);
  if (!I::HasHeapObjectTag(obj)) return false;
  if (I::GetInstanceType(obj) != I::kOddballType) return false;
  int kind = I::GetOddballKind(obj);
  return kind == I::kNullOddballKind || kind == I::kUndefinedOddballKind;
#endif  // V8_STATIC_ROOTS_BOOL
}
 
bool Value::IsTrue() const {
#if V8_STATIC_ROOTS_BOOL && !defined(V8_ENABLE_CHECKS)
  return QuickIsTrue();
#else
  return FullIsTrue();
#endif
}
 
#if V8_STATIC_ROOTS_BOOL
bool Value::QuickIsTrue() const {
  using A = internal::Address;
  using I = internal::Internals;
  A obj = internal::ValueHelper::ValueAsAddress(this);
  return I::is_identical(obj, I::StaticReadOnlyRoot::kTrueValue);
}
#endif  // V8_STATIC_ROOTS_BOOL
 
bool Value::IsFalse() const {
#if V8_STATIC_ROOTS_BOOL && !defined(V8_ENABLE_CHECKS)
  return QuickIsFalse();
#else
  return FullIsFalse();
#endif
}
 
#if V8_STATIC_ROOTS_BOOL
bool Value::QuickIsFalse() const {
  using A = internal::Address;
  using I = internal::Internals;
  A obj = internal::ValueHelper::ValueAsAddress(this);
  return I::is_identical(obj, I::StaticReadOnlyRoot::kFalseValue);
}
#endif  // V8_STATIC_ROOTS_BOOL
 
bool Value::IsString() const {
#ifdef V8_ENABLE_CHECKS
  return FullIsString();
#else
  return QuickIsString();
#endif
}
 
bool Value::QuickIsString() const {
  using A = internal::Address;
  using I = internal::Internals;
  A obj = internal::ValueHelper::ValueAsAddress(this);
  if (!I::HasHeapObjectTag(obj)) return false;
#if V8_STATIC_ROOTS_BOOL && !V8_MAP_PACKING
  return I::CheckInstanceMapRange(obj,
                                  I::StaticReadOnlyRoot::kStringMapLowerBound,
                                  I::StaticReadOnlyRoot::kStringMapUpperBound);
#else
  return (I::GetInstanceType(obj) < I::kFirstNonstringType);
#endif  // V8_STATIC_ROOTS_BOOL
}
 
bool TypecheckWitness::Matches(Local<Value> candidate) const {
  internal::Address obj = internal::ValueHelper::ValueAsAddress(*candidate);
  internal::Address obj_map = internal::Internals::LoadMap(obj);
  internal::Address cached =
      internal::ValueHelper::ValueAsAddress(*cached_map_);
  return obj_map == cached;
}
 
}  // namespace v8
 
#endif  // INCLUDE_V8_VALUE_H_