1 // Copyright 2015 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 V8_PROPERTY_DESCRIPTOR_H_ 6 #define V8_PROPERTY_DESCRIPTOR_H_ 7 8 9 #include "src/handles.h" 10 #include "src/property-details.h" 11 12 13 namespace v8 { 14 namespace internal { 15 16 class Isolate; 17 class Object; 18 class PropertyDescriptorObject; 19 20 class PropertyDescriptor { 21 public: PropertyDescriptor()22 PropertyDescriptor() 23 : enumerable_(false), 24 has_enumerable_(false), 25 configurable_(false), 26 has_configurable_(false), 27 writable_(false), 28 has_writable_(false) {} 29 30 // ES6 6.2.4.1 IsAccessorDescriptor(PropertyDescriptor * desc)31 static bool IsAccessorDescriptor(PropertyDescriptor* desc) { 32 return desc->has_get() || desc->has_set(); 33 } 34 35 // ES6 6.2.4.2 IsDataDescriptor(PropertyDescriptor * desc)36 static bool IsDataDescriptor(PropertyDescriptor* desc) { 37 return desc->has_value() || desc->has_writable(); 38 } 39 40 // ES6 6.2.4.3 IsGenericDescriptor(PropertyDescriptor * desc)41 static bool IsGenericDescriptor(PropertyDescriptor* desc) { 42 return !IsAccessorDescriptor(desc) && !IsDataDescriptor(desc); 43 } 44 45 // ES6 6.2.4.4 46 Handle<Object> ToObject(Isolate* isolate); 47 48 Handle<PropertyDescriptorObject> ToPropertyDescriptorObject(Isolate* isolate); 49 50 // ES6 6.2.4.5 51 static bool ToPropertyDescriptor(Isolate* isolate, Handle<Object> obj, 52 PropertyDescriptor* desc); 53 54 // ES6 6.2.4.6 55 static void CompletePropertyDescriptor(Isolate* isolate, 56 PropertyDescriptor* desc); 57 is_empty()58 bool is_empty() const { 59 return !has_enumerable() && !has_configurable() && !has_writable() && 60 !has_value() && !has_get() && !has_set(); 61 } 62 IsRegularAccessorProperty()63 bool IsRegularAccessorProperty() const { 64 return has_configurable() && has_enumerable() && !has_value() && 65 !has_writable() && has_get() && has_set(); 66 } 67 IsRegularDataProperty()68 bool IsRegularDataProperty() const { 69 return has_configurable() && has_enumerable() && has_value() && 70 has_writable() && !has_get() && !has_set(); 71 } 72 enumerable()73 bool enumerable() const { return enumerable_; } set_enumerable(bool enumerable)74 void set_enumerable(bool enumerable) { 75 enumerable_ = enumerable; 76 has_enumerable_ = true; 77 } has_enumerable()78 bool has_enumerable() const { return has_enumerable_; } 79 configurable()80 bool configurable() const { return configurable_; } set_configurable(bool configurable)81 void set_configurable(bool configurable) { 82 configurable_ = configurable; 83 has_configurable_ = true; 84 } has_configurable()85 bool has_configurable() const { return has_configurable_; } 86 value()87 Handle<Object> value() const { return value_; } set_value(Handle<Object> value)88 void set_value(Handle<Object> value) { value_ = value; } has_value()89 bool has_value() const { return !value_.is_null(); } 90 writable()91 bool writable() const { return writable_; } set_writable(bool writable)92 void set_writable(bool writable) { 93 writable_ = writable; 94 has_writable_ = true; 95 } has_writable()96 bool has_writable() const { return has_writable_; } 97 get()98 Handle<Object> get() const { return get_; } set_get(Handle<Object> get)99 void set_get(Handle<Object> get) { get_ = get; } has_get()100 bool has_get() const { return !get_.is_null(); } 101 set()102 Handle<Object> set() const { return set_; } set_set(Handle<Object> set)103 void set_set(Handle<Object> set) { set_ = set; } has_set()104 bool has_set() const { return !set_.is_null(); } 105 name()106 Handle<Object> name() const { return name_; } set_name(Handle<Object> name)107 void set_name(Handle<Object> name) { name_ = name; } 108 ToAttributes()109 PropertyAttributes ToAttributes() { 110 return static_cast<PropertyAttributes>( 111 (has_enumerable() && !enumerable() ? DONT_ENUM : NONE) | 112 (has_configurable() && !configurable() ? DONT_DELETE : NONE) | 113 (has_writable() && !writable() ? READ_ONLY : NONE)); 114 } 115 116 private: 117 bool enumerable_ : 1; 118 bool has_enumerable_ : 1; 119 bool configurable_ : 1; 120 bool has_configurable_ : 1; 121 bool writable_ : 1; 122 bool has_writable_ : 1; 123 Handle<Object> value_; 124 Handle<Object> get_; 125 Handle<Object> set_; 126 Handle<Object> name_; 127 128 // Some compilers (Xcode 5.1, ARM GCC 4.9) insist on having a copy 129 // constructor for std::vector<PropertyDescriptor>, so we can't 130 // DISALLOW_COPY_AND_ASSIGN(PropertyDescriptor); here. 131 }; 132 133 } // namespace internal 134 } // namespace v8 135 136 #endif // V8_PROPERTY_DESCRIPTOR_H_ 137