Runtime version of declarative native accessors.

include/v8.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 1512 matching lines @@
  */
 typedef Handle<Value> (*AccessorGetter)(Local<String> property,
                                         const AccessorInfo& info);
 
 
 typedef void (*AccessorSetter)(Local<String> property,
                                Local<Value> value,
                                const AccessorInfo& info);
 
 
+enum AccessorDescriptorType {
+  kDescriptorPointerCompare,
+  kDescriptorBitmaskCompare,
+  kDescriptorPrimitiveValue,
+  kDescriptorPointerDereference,
+  kDescriptorInternalFieldDereference
+};
+
+
+enum AccessorDescriptorDataType {
+    kDescriptorBoolType,
+    kDescriptorInt8Type, kDescriptorUint8Type,
+    kDescriptorInt16Type, kDescriptorUint16Type,
+    kDescriptorInt32Type, kDescriptorUint32Type,
+    kDescriptorFloatType, kDescriptorDoubleType
+};
+
+
+struct BitmaskCompareDescriptor {
+  uint32_t bitmask;
+  uint32_t compare_value;
+  uint8_t size;  // Must be in {1,2,4}.
+};
+
+
+struct PointerCompareDescriptor {
+  void* compare_value;
+};
+
+
+struct PrimitiveValueDescriptor {
+  AccessorDescriptorDataType data_type;
+  uint8_t bool_offset;  // Must be in [0,7], used for kDescriptorBoolType.
+};
+
+
+struct AccessorDescriptor {

[Sven Panne, 2013/02/19 08:41:16]

I'm not totally happy with the way this algebraic data type is encoded. Let's
discuss this offline, there are *many* ways of doing it...

Regardless how this finally looks, we need some serious documentation via
comments here!

+  uint8_t internal_field;  // Ignored for kDescriptorPointerDereference.
+  int16_t byte_offset;
+  AccessorDescriptorType type;
+  union {
+    AccessorDescriptor* derefence_descriptor;
+    struct BitmaskCompareDescriptor bitmask_compare_descriptor;
+    struct PointerCompareDescriptor pointer_compare_descriptor;
+    struct PrimitiveValueDescriptor primitive_value_descriptor;
+  };
+};
+
+
 /**
  * Access control specifications.
  *
  * Some accessors should be accessible across contexts.  These
  * accessors have an explicit access control parameter which specifies
  * the kind of cross-context access that should be allowed.
  *
  * Additionally, for security, accessors can prohibit overwriting by
  * accessors defined in JavaScript.  For objects that have such
  * accessors either locally or in their prototype chain it is not
@@ skipping 56 matching lines @@
 
   bool Delete(uint32_t index);
 
   bool SetAccessor(Handle<String> name,
                    AccessorGetter getter,
                    AccessorSetter setter = 0,
                    Handle<Value> data = Handle<Value>(),
                    AccessControl settings = DEFAULT,
                    PropertyAttribute attribute = None);
 
+  bool SetAccessor(Handle<String> name,
+                   const AccessorDescriptor* descriptor,
+                   AccessControl settings = DEFAULT,
+                   PropertyAttribute attribute = None);
+
   /**
    * Returns an array containing the names of the enumerable properties
    * of this object, including properties from prototype objects.  The
    * array returned by this method contains the same values as would
    * be enumerated by a for-in statement over this object.
    */
   Local<Array> GetPropertyNames();
 
   /**
    * This function has the same functionality as GetPropertyNames but
@@ skipping 751 matching lines @@
   void ReadOnlyPrototype();
 
   /**
    * Returns true if the given object is an instance of this function
    * template.
    */
   bool HasInstance(Handle<Value> object);
 
  private:
   FunctionTemplate();
-  void AddInstancePropertyAccessor(Handle<String> name,
-                                   AccessorGetter getter,
-                                   AccessorSetter setter,
-                                   Handle<Value> data,
-                                   AccessControl settings,
-                                   PropertyAttribute attributes,
-                                   Handle<AccessorSignature> signature);
   void SetNamedInstancePropertyHandler(NamedPropertyGetter getter,
                                        NamedPropertySetter setter,
                                        NamedPropertyQuery query,
                                        NamedPropertyDeleter remover,
                                        NamedPropertyEnumerator enumerator,
                                        Handle<Value> data);
   void SetIndexedInstancePropertyHandler(IndexedPropertyGetter getter,
                                          IndexedPropertySetter setter,
                                          IndexedPropertyQuery query,
                                          IndexedPropertyDeleter remover,
@@ skipping 52 matching lines @@
    */
   void SetAccessor(Handle<String> name,
                    AccessorGetter getter,
                    AccessorSetter setter = 0,
                    Handle<Value> data = Handle<Value>(),
                    AccessControl settings = DEFAULT,
                    PropertyAttribute attribute = None,
                    Handle<AccessorSignature> signature =
                        Handle<AccessorSignature>());
 
+  bool SetAccessor(Handle<String> name,
+                   const AccessorDescriptor* descriptor,
+                   AccessControl settings = DEFAULT,
+                   PropertyAttribute attribute = None,
+                   Handle<AccessorSignature> signature =
+                       Handle<AccessorSignature>());
+
   /**
    * Sets a named property handler on the object template.
    *
    * Whenever a named property is accessed on objects created from
    * this object template, the provided callback is invoked instead of
    * accessing the property directly on the JavaScript object.
    *
    * \param getter The callback to invoke when getting a property.
    * \param setter The callback to invoke when setting a property.
    * \param query The callback to invoke to check if a property is present,
@@ skipping 2113 matching lines @@
 Handle<Boolean> Boolean::New(bool value) {
   return value ? True() : False();
 }
 
 
 void Template::Set(const char* name, v8::Handle<Data> value) {
   Set(v8::String::New(name), value);
 }
 
 
+struct DescriptorVisitorHelper {

[Sven Panne, 2013/02/19 08:41:16]

Why do we need all this stuff here in the external header? (Basically 2
questions: Why at all? Why here?)

+  template<typename Descriptor, typename Visitor>
+  static inline void VisitDescriptor(Descriptor* descriptor, Visitor* visitor) {
+    if (!visitor->ShouldVisit(descriptor)) return;
+    VisitFields(descriptor, visitor);
+  }
+  template<typename Visitor>
+  static inline void VisitFields(BitmaskCompareDescriptor* descriptor,
+                                 Visitor* visitor);
+  template<typename Visitor>
+  static inline void VisitFields(PointerCompareDescriptor* descriptor,
+                                 Visitor* visitor);
+  template<typename Visitor>
+  static inline void VisitFields(PrimitiveValueDescriptor* descriptor,
+                                 Visitor* visitor);
+  template<typename Visitor>
+  static inline void VisitFields(AccessorDescriptor* descriptor,
+                                 Visitor* visitor);
+};
+
+
+template<typename Visitor>
+inline void DescriptorVisitorHelper::VisitFields(
+    BitmaskCompareDescriptor* descriptor,
+    Visitor* visitor) {
+  visitor->Visit(&descriptor->size);
+  visitor->Visit(&descriptor->bitmask);
+  visitor->Visit(&descriptor->compare_value);
+}
+
+
+template<typename Visitor>
+inline void DescriptorVisitorHelper::VisitFields(
+    PointerCompareDescriptor* descriptor,
+    Visitor* visitor) {
+  visitor->Visit(&descriptor->compare_value);
+}
+
+
+template<typename Visitor>
+inline void DescriptorVisitorHelper::VisitFields(
+    PrimitiveValueDescriptor* descriptor,
+    Visitor* visitor) {
+  visitor->Visit(&descriptor->data_type);
+}
+
+
+template<typename Visitor>
+inline void DescriptorVisitorHelper::VisitFields(
+    AccessorDescriptor* descriptor,
+    Visitor* visitor) {
+  visitor->Visit(&descriptor->internal_field);
+  visitor->Visit(&descriptor->byte_offset);
+  visitor->Visit(&descriptor->type);
+  switch (static_cast<AccessorDescriptorType>(descriptor->type)) {
+    case kDescriptorBitmaskCompare:
+      VisitDescriptor(&descriptor->bitmask_compare_descriptor, visitor);
+      break;
+    case kDescriptorPointerCompare:
+      VisitDescriptor(&descriptor->pointer_compare_descriptor, visitor);
+      break;
+    case kDescriptorPrimitiveValue:
+      VisitDescriptor(&descriptor->primitive_value_descriptor, visitor);
+      break;
+    case kDescriptorPointerDereference:
+    case kDescriptorInternalFieldDereference:
+      VisitDescriptor(descriptor->derefence_descriptor, visitor);
+      break;
+    default:
+      visitor->VisitError();
+      break;
+  }
+}
+
+
 Local<Value> Object::GetInternalField(int index) {
 #ifndef V8_ENABLE_CHECKS
   typedef internal::Object O;
   typedef internal::Internals I;
   O* obj = *reinterpret_cast<O**>(this);
   // Fast path: If the object is a plain JSObject, which is the common case, we
   // know where to find the internal fields and can return the value directly.
   if (I::GetInstanceType(obj) == I::kJSObjectType) {
     int offset = I::kJSObjectHeaderSize + (internal::kApiPointerSize * index);
     O* value = I::ReadField<O*>(obj, offset);
@@ skipping 320 matching lines @@
 
 
 }  // namespace v8
 
 
 #undef V8EXPORT
 #undef TYPE_CHECK
 
 
 #endif  // V8_H_