[Isolates] Replace ISOLATE_FROM_HEAP with Heap::isolate()

src/runtime.cc

 // Copyright 2006-2009 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 85 matching lines @@
 // Call the specified converter on the object *comand store the result in
 // a variable of the specified type with the given name.  If the
 // object is not a Number call IllegalOperation and return.
 #define CONVERT_NUMBER_CHECKED(type, name, Type, obj)                \
   RUNTIME_ASSERT(obj->IsNumber());                                   \
   type name = NumberTo##Type(obj);
 
 
 static Object* DeepCopyBoilerplate(Heap* heap, JSObject* boilerplate) {
   StackLimitCheck check;
-  if (check.HasOverflowed()) return ISOLATE_FROM_HEAP(heap)->StackOverflow();
+  if (check.HasOverflowed()) return heap->isolate()->StackOverflow();
 
   Object* result = heap->CopyJSObject(boilerplate);
   if (result->IsFailure()) return result;
   JSObject* copy = JSObject::cast(result);
 
   // Deep copy local properties.
   if (copy->HasFastProperties()) {
     FixedArray* properties = copy->properties();
     for (int i = 0; i < properties->length(); i++) {
       Object* value = properties->get(i);
@@ skipping 3813 matching lines @@
 Object* Runtime::GetObjectProperty(Heap* heap,
                                    Handle<Object> object,
                                    Handle<Object> key) {
   HandleScope scope;
 
   if (object->IsUndefined() || object->IsNull()) {
     Handle<Object> args[2] = { key, object };
     Handle<Object> error =
         Factory::NewTypeError("non_object_property_load",
                               HandleVector(args, 2));
-    return ISOLATE_FROM_HEAP(heap)->Throw(*error);
+    return heap->isolate()->Throw(*error);
   }
 
   // Check if the given key is an array index.
   uint32_t index;
   if (key->ToArrayIndex(&index)) {
     return GetElementOrCharAt(heap, object, index);
   }
 
   // Convert the key to a string - possibly by calling back into JavaScript.
   Handle<String> name;
@@ skipping 189 matching lines @@
                                    Handle<Object> key,
                                    Handle<Object> value,
                                    PropertyAttributes attr) {
   HandleScope scope;
 
   if (object->IsUndefined() || object->IsNull()) {
     Handle<Object> args[2] = { key, object };
     Handle<Object> error =
         Factory::NewTypeError("non_object_property_store",
                               HandleVector(args, 2));
-    return ISOLATE_FROM_HEAP(heap)->Throw(*error);
+    return heap->isolate()->Throw(*error);
   }
 
   // If the object isn't a JavaScript object, we ignore the store.
   if (!object->IsJSObject()) return *value;
 
   Handle<JSObject> js_object = Handle<JSObject>::cast(object);
 
   // Check if the given key is an array index.
   uint32_t index;
   if (key->ToArrayIndex(&index)) {
@@ skipping 1033 matching lines @@
       while (buffer->has_more()) {
         current = buffer->GetNext();
         // NOTE: we use 0 as the next character here because, while
         // the next character may affect what a character converts to,
         // it does not in any case affect the length of what it convert
         // to.
         int char_length = mapping->get(current, 0, chars);
         if (char_length == 0) char_length = 1;
         current_length += char_length;
         if (current_length > Smi::kMaxValue) {
-          ISOLATE_FROM_HEAP(heap)->context()->mark_out_of_memory();
+          heap->isolate()->context()->mark_out_of_memory();
           return Failure::OutOfMemoryException();
         }
       }
       // Try again with the real length.
       return Smi::FromInt(current_length);
     } else {
       for (int j = 0; j < char_length; j++) {
         result->Set(i, chars[j]);
         i++;
       }
@@ skipping 1868 matching lines @@
   // Convert the object to a proper JavaScript object.
   Object* js_object = object;
   if (!js_object->IsJSObject()) {
     js_object = js_object->ToObject();
     if (js_object->IsFailure()) {
       if (!Failure::cast(js_object)->IsInternalError()) return js_object;
       HandleScope scope;
       Handle<Object> handle(object);
       Handle<Object> result =
           Factory::NewTypeError("with_expression", HandleVector(&handle, 1));
-      return ISOLATE_FROM_HEAP(heap)->Throw(*result);
+      return heap->isolate()->Throw(*result);
     }
   }
 
   Object* result =
-      heap->AllocateWithContext(ISOLATE_FROM_HEAP(heap)->context(),
+      heap->AllocateWithContext(heap->isolate()->context(),
                                 JSObject::cast(js_object),
                                 is_catch_context);
   if (result->IsFailure()) return result;
 
   Context* context = Context::cast(result);
-  ISOLATE_FROM_HEAP(heap)->set_context(context);
+  heap->isolate()->set_context(context);
 
   return result;
 }
 
 
 static Object* Runtime_PushContext(RUNTIME_CALLING_CONVENTION) {
   RUNTIME_GET_ISOLATE;
   NoHandleAllocation ha;
   ASSERT(args.length() == 1);
   return PushContextHelper(isolate->heap(), args[0], false);
@@ skipping 1320 matching lines @@
       }
       return value;
     case CONSTANT_FUNCTION:
       return result->GetConstantFunction();
     case CALLBACKS: {
       Object* structure = result->GetCallbackObject();
       if (structure->IsProxy() || structure->IsAccessorInfo()) {
         value = receiver->GetPropertyWithCallback(
             receiver, structure, name, result->holder());
         if (value->IsException()) {
-          value = ISOLATE_FROM_HEAP(heap)->pending_exception();
-          ISOLATE_FROM_HEAP(heap)->clear_pending_exception();
+          value = heap->isolate()->pending_exception();
+          heap->isolate()->clear_pending_exception();
           if (caught_exception != NULL) {
             *caught_exception = true;
           }
         }
         return value;
       } else {
         return heap->undefined_value();
       }
     }
     case INTERCEPTOR:
@@ skipping 505 matching lines @@
 static Handle<JSObject> MaterializeLocalScope(Heap* heap,
                                               JavaScriptFrame* frame) {
   Handle<JSFunction> function(JSFunction::cast(frame->function()));
   Handle<SharedFunctionInfo> shared(function->shared());
   Handle<SerializedScopeInfo> serialized_scope_info(shared->scope_info());
   ScopeInfo<> scope_info(*serialized_scope_info);
 
   // Allocate and initialize a JSObject with all the arguments, stack locals
   // heap locals and extension properties of the debugged function.
   Handle<JSObject> local_scope =
-      Factory::NewJSObject(ISOLATE_FROM_HEAP(heap)->object_function());
+      Factory::NewJSObject(heap->isolate()->object_function());
 
   // First fill all parameters.
   for (int i = 0; i < scope_info.number_of_parameters(); ++i) {
     SetProperty(local_scope,
                 scope_info.parameter_name(i),
                 Handle<Object>(frame->GetParameter(i)), NONE);
   }
 
   // Second fill all stack locals.
   for (int i = 0; i < scope_info.number_of_stack_slots(); i++) {
@@ skipping 33 matching lines @@
                                            Handle<Context> context) {
   ASSERT(context->is_function_context());
 
   Handle<SharedFunctionInfo> shared(context->closure()->shared());
   Handle<SerializedScopeInfo> serialized_scope_info(shared->scope_info());
   ScopeInfo<> scope_info(*serialized_scope_info);
 
   // Allocate and initialize a JSObject with all the content of theis function
   // closure.
   Handle<JSObject> closure_scope =
-      Factory::NewJSObject(ISOLATE_FROM_HEAP(heap)->object_function());
+      Factory::NewJSObject(heap->isolate()->object_function());
 
   // Check whether the arguments shadow object exists.
   int arguments_shadow_index =
       shared->scope_info()->ContextSlotIndex(
           heap->arguments_shadow_symbol(), NULL);
   if (arguments_shadow_index >= 0) {
     // In this case all the arguments are available in the arguments shadow
     // object.
     Handle<JSObject> arguments_shadow(
         JSObject::cast(context->get(arguments_shadow_index)));
@@ skipping 1870 matching lines @@
 #define SETUP_RUNTIME_ENTRIES(Name, argc, resize)                              \
   entries_[lut_index].method = &CodeGenerator::Generate##Name;                 \
   entries_[lut_index].name = "_" #Name;                                        \
   entries_[lut_index++].nargs = argc;
   INLINE_RUNTIME_FUNCTION_LIST(SETUP_RUNTIME_ENTRIES);
 #undef SETUP_RUNTIME_ENTRIES
 }
 
 
 } }  // namespace v8::internal