Changed structure of accessor arguments passing to allow accessor

include/v8.h

 // Copyright 2007-2008 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 112 matching lines @@
 template <class T> class Handle;
 template <class T> class Local;
 template <class T> class Persistent;
 class FunctionTemplate;
 class ObjectTemplate;
 class Data;
 
 namespace internal {
 
 class Object;
+class Arguments;
 
 }
 
 
 // --- W e a k  H a n d l e s
 
 
 /**
  * A weak reference callback function.
  *
@@ skipping 1258 matching lines @@
   int length_;
 };
 
 
 /**
  * The information passed to an accessor callback about the context
  * of the property access.
  */
 class V8EXPORT AccessorInfo {
  public:
-  inline AccessorInfo(Local<Object> self,
-                      Local<Value> data,
-                      Local<Object> holder)
-      : self_(self), data_(data), holder_(holder) { }
+  inline AccessorInfo(internal::Object** args)
+      : args_(args) { }
   inline Local<Value> Data() const;
   inline Local<Object> This() const;
   inline Local<Object> Holder() const;
  private:
-  Local<Object> self_;
-  Local<Value> data_;
-  Local<Object> holder_;
+  internal::Object** args_;
 };
 
 
 typedef Handle<Value> (*InvocationCallback)(const Arguments& args);
 
 typedef int (*LookupCallback)(Local<Object> self, Local<String> name);
 
 /**
  * Accessor[Getter|Setter] are used as callback functions when
  * setting|getting a particular property. See objectTemplate::SetAccessor.
@@ skipping 1431 matching lines @@
 bool Arguments::IsConstructCall() const {
   return is_construct_call_;
 }
 
 
 int Arguments::Length() const {
   return length_;
 }
 
 
-Local<Value> AccessorInfo::Data() const {
-  return data_;
-}
-
-
-Local<Object> AccessorInfo::This() const {
-  return self_;
-}
-
-
-Local<Object> AccessorInfo::Holder() const {
-  return holder_;
-}
-
-
 template <class T>
 Local<T> HandleScope::Close(Handle<T> value) {
   internal::Object** before = reinterpret_cast<internal::Object**>(*value);
   internal::Object** after = RawClose(before);
   return Local<T>(reinterpret_cast<T*>(after));
 }
 
 Handle<Value> ScriptOrigin::ResourceName() const {
   return resource_name_;
 }
@@ skipping 177 matching lines @@
 
 
 External* External::Cast(v8::Value* value) {
 #ifdef V8_ENABLE_CHECKS
   CheckCast(value);
 #endif
   return static_cast<External*>(value);
 }
 
 
+Local<Value> AccessorInfo::Data() const {
+  return Local<Value>(reinterpret_cast<Value*>(&args_[-3]));
+}
+
+
+Local<Object> AccessorInfo::This() const {
+  return Local<Object>(reinterpret_cast<Object*>(&args_[0]));
+}
+
+
+Local<Object> AccessorInfo::Holder() const {
+  return Local<Object>(reinterpret_cast<Object*>(&args_[-1]));
+}
+
+
 /**
  * \example shell.cc
  * A simple shell that takes a list of expressions on the
  * command-line and executes them.
  */
 
 
 /**
  * \example process.cc
  */
 
 
 }  // namespace v8
 
 
 #undef V8EXPORT
 #undef V8EXPORT_INLINE
 #undef TYPE_CHECK
 
 
 #endif  // V8_H_