make isolate accessible from returnvalue

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 2764 matching lines @@
 
 
 template<typename T>
 class ReturnValue {
  public:
   V8_INLINE(explicit ReturnValue(internal::Object** slot));
   // Handle setters
   V8_INLINE(void Set(const Persistent<T>& handle));
   V8_INLINE(void Set(const Handle<T> handle));
   // Fast primitive setters
-  V8_INLINE(void Set(Isolate* isolate, bool value));
-  V8_INLINE(void Set(Isolate* isolate, double i));
-  V8_INLINE(void Set(Isolate* isolate, int32_t i));
-  V8_INLINE(void Set(Isolate* isolate, uint32_t i));
+  V8_INLINE(void Set(bool value));
+  V8_INLINE(void Set(double i));
+  V8_INLINE(void Set(int32_t i));
+  V8_INLINE(void Set(uint32_t i));
   // Fast JS primitive setters
-  V8_INLINE(void SetNull(Isolate* isolate));
-  V8_INLINE(void SetUndefined(Isolate* isolate));
+  V8_INLINE(void SetNull());
+  V8_INLINE(void SetUndefined());
+  // Convenience getter for Isolate
+  V8_INLINE(Isolate* GetIsolate());

[Sven Panne, 2013/05/27 11:35:36]

Do we really want to expose GetIsolate() or would it be better to keep that
private as an implementation detail? I don't know what the master plan is, so it
might be OK or not. This is part of an external API and we should be careful
with exposing things here, people might actually use it. ;-)

  private:
-  V8_INLINE(void SetTrue(Isolate* isolate));
-  V8_INLINE(void SetFalse(Isolate* isolate));
   internal::Object** value_;
 };
 
 
 /**
  * The argument information given to function call callbacks.  This
  * class provides access to information about the context of the call,
  * including the receiver, the number and values of arguments, and
  * the holder of the function.
  */
@@ skipping 56 matching lines @@
   // This shouldn't be public, but the arm compiler needs it.
   static const int kArgsLength = 5;
 
  protected:
   friend class MacroAssembler;
   friend class internal::PropertyCallbackArguments;
   friend class internal::CustomArguments<PropertyCallbackInfo>;
   static const int kThisIndex = 0;
   static const int kHolderIndex = -1;
   static const int kDataIndex = -2;
-  static const int kIsolateIndex = -3;
-  static const int kReturnValueIndex = -4;
+  static const int kReturnValueIndex = -3;
+  static const int kIsolateIndex = -4;
 
   V8_INLINE(PropertyCallbackInfo(internal::Object** args))
       : args_(args) { }
   internal::Object** args_;
 };
 
 
 class V8EXPORT AccessorInfo : public PropertyCallbackInfo<Value> {
  private:
   friend class internal::PropertyCallbackArguments;
@@ skipping 2804 matching lines @@
 void ReturnValue<T>::Set(const Persistent<T>& handle) {
   *value_ = *reinterpret_cast<internal::Object**>(*handle);
 }
 
 template<typename T>
 void ReturnValue<T>::Set(const Handle<T> handle) {
   *value_ = *reinterpret_cast<internal::Object**>(*handle);
 }
 
 template<typename T>
-void ReturnValue<T>::Set(Isolate* isolate, double i) {
-  Set(Number::New(isolate, i));
+void ReturnValue<T>::Set(double i) {
+  Set(Number::New(GetIsolate(), i));
 }
 
 template<typename T>
-void ReturnValue<T>::Set(Isolate* isolate, int32_t i) {
+void ReturnValue<T>::Set(int32_t i) {
   typedef internal::Internals I;
   if (V8_LIKELY(I::IsValidSmi(i))) {
     *value_ = I::IntToSmi(i);
     return;
   }
-  Set(Integer::New(i, isolate));
+  Set(Integer::New(i, GetIsolate()));
 }
 
 template<typename T>
-void ReturnValue<T>::Set(Isolate* isolate, uint32_t i) {
+void ReturnValue<T>::Set(uint32_t i) {
   typedef internal::Internals I;
   if (V8_LIKELY(I::IsValidSmi(i))) {
     *value_ = I::IntToSmi(i);
     return;
   }
-  Set(Integer::NewFromUnsigned(i, isolate));
+  Set(Integer::NewFromUnsigned(i, GetIsolate()));
 }
 
 template<typename T>
-void ReturnValue<T>::Set(Isolate* isolate, bool value) {
+void ReturnValue<T>::Set(bool value) {
+  typedef internal::Internals I;
+  int root_index;
   if (value) {
-    SetTrue(isolate);
+    root_index = I::kTrueValueRootIndex;
   } else {
-    SetFalse(isolate);
+    root_index = I::kFalseValueRootIndex;
   }
+  *value_ = *I::GetRoot(GetIsolate(), root_index);
 }
 
 template<typename T>
-void ReturnValue<T>::SetTrue(Isolate* isolate) {
+void ReturnValue<T>::SetNull() {
   typedef internal::Internals I;
-  *value_ = *I::GetRoot(isolate, I::kTrueValueRootIndex);
+  *value_ = *I::GetRoot(GetIsolate(), I::kNullValueRootIndex);
 }
 
 template<typename T>
-void ReturnValue<T>::SetFalse(Isolate* isolate) {
+void ReturnValue<T>::SetUndefined() {
   typedef internal::Internals I;
-  *value_ = *I::GetRoot(isolate, I::kFalseValueRootIndex);
+  *value_ = *I::GetRoot(GetIsolate(), I::kUndefinedValueRootIndex);
 }
 
 template<typename T>
-void ReturnValue<T>::SetNull(Isolate* isolate) {
-  typedef internal::Internals I;
-  *value_ = *I::GetRoot(isolate, I::kNullValueRootIndex);
-}
-
-template<typename T>
-void ReturnValue<T>::SetUndefined(Isolate* isolate) {
-  typedef internal::Internals I;
-  *value_ = *I::GetRoot(isolate, I::kUndefinedValueRootIndex);
+Isolate* ReturnValue<T>::GetIsolate() {
+  // Isolate is always the pointer below value_ on the stack.
+  return *reinterpret_cast<Isolate**>(&value_[-1]);
 }
 
 
 template<typename T>
 FunctionCallbackInfo<T>::FunctionCallbackInfo(internal::Object** implicit_args,
                                               internal::Object** values,
                                               int length,
                                               bool is_construct_call)
     : implicit_args_(implicit_args),
       values_(values),
@@ skipping 562 matching lines @@
 
 
 }  // namespace v8
 
 
 #undef V8EXPORT
 #undef TYPE_CHECK
 
 
 #endif  // V8_H_