/deps/v8/src/api.cc - Diff - CSE2410 Fall 2014 Bounce - CS Projects

Revision f230a1cf deps/v8/src/api.cc

     namespace v8 {
     #define ON_BAILOUT(isolate, location, code)                        \
       if (IsDeadCheck(isolate, location) ||                            \
           IsExecutionTerminatingCheck(isolate)) {                      \
       if (IsExecutionTerminatingCheck(isolate)) {                      \
         code;                                                          \
         UNREACHABLE();                                                 \
+      }
-...
+    }
     static bool ReportV8Dead(const char* location) {
       FatalErrorCallback callback = GetFatalErrorHandler();
       callback(location, "V8 is no longer usable");
       return true;
+    }
     static bool ReportEmptyHandle(const char* location) {
       FatalErrorCallback callback = GetFatalErrorHandler();
       callback(location, "Reading from empty handle");
-...
+    }
     /**
      * IsDeadCheck checks that the vm is usable.  If, for instance, the vm has been
      * out of memory at some point this check will fail.  It should be called on
      * entry to all methods that touch anything in the heap, except destructors
      * which you sometimes can't avoid calling after the vm has crashed.  Functions
      * that call EnsureInitialized or ON_BAILOUT don't have to also call
      * IsDeadCheck.  ON_BAILOUT has the advantage over EnsureInitialized that you
      * can arrange to return if the VM is dead.  This is needed to ensure that no VM
      * heap allocations are attempted on a dead VM.  EnsureInitialized has the
      * advantage over ON_BAILOUT that it actually initializes the VM if this has not
      * yet been done.
      */
     static inline bool IsDeadCheck(i::Isolate* isolate, const char* location) {
       return !isolate->IsInitialized()
           && isolate->IsDead() ? ReportV8Dead(location) : false;
+    }
     static inline bool IsExecutionTerminatingCheck(i::Isolate* isolate) {
       if (!isolate->IsInitialized()) return false;
       if (isolate->has_scheduled_exception()) {
-...
     static inline bool EnsureInitializedForIsolate(i::Isolate* isolate,
                                                    const char* location) {
       if (IsDeadCheck(isolate, location)) return false;
       if (isolate != NULL) {
         if (isolate->IsInitialized()) return true;
+      }
-...
     v8::Handle<Value> ThrowException(v8::Handle<v8::Value> value) {
       i::Isolate* isolate = i::Isolate::Current();
       if (IsDeadCheck(isolate, "v8::ThrowException()")) {
         return v8::Handle<Value>();
+      }
       ENTER_V8(isolate);
       // If we're passed an empty handle, we throw an undefined exception
       // to deal more gracefully with out of memory situations.
       if (value.IsEmpty()) {
         isolate->ScheduleThrow(isolate->heap()->undefined_value());
       } else {
         isolate->ScheduleThrow(*Utils::OpenHandle(*value));
+      }
       return v8::Undefined();
       return v8::Isolate::GetCurrent()->ThrowException(value);
+    }
-...
       : max_young_space_size_(0),
         max_old_space_size_(0),
         max_executable_size_(0),
         stack_limit_(NULL),
         is_memory_constrained_() { }
         stack_limit_(NULL) { }
     bool SetResourceConstraints(ResourceConstraints* constraints) {
-...
       int max_executable_size = constraints->max_executable_size();
       if (young_space_size != 0 || old_gen_size != 0 || max_executable_size != 0) {
         // After initialization it's too late to change Heap constraints.
         ASSERT(!isolate->IsInitialized());
         // TODO(rmcilroy): fix this assert.
         // ASSERT(!isolate->IsInitialized());
         bool result = isolate->heap()->ConfigureHeap(young_space_size / 2,
                                                      old_gen_size,
                                                      max_executable_size);
-...
         uintptr_t limit = reinterpret_cast<uintptr_t>(constraints->stack_limit());
         isolate->stack_guard()->SetStackLimit(limit);
+      }
       if (constraints->is_memory_constrained().has_value) {
         isolate->set_is_memory_constrained(
             constraints->is_memory_constrained().value);
+      }
       return true;
+    }
     i::Object** V8::GlobalizeReference(i::Isolate* isolate, i::Object** obj) {
       if (IsDeadCheck(isolate, "V8::Persistent::New")) return NULL;
       LOG_API(isolate, "Persistent::New");
       i::Handle<i::Object> result = isolate->global_handles()->Create(*obj);
     #ifdef DEBUG
-...
+    }
     i::Object** HandleScope::CreateHandle(i::Object* value) {
       return i::HandleScope::CreateHandle(i::Isolate::Current(), value);
     i::Object** HandleScope::CreateHandle(i::Isolate* isolate, i::Object* value) {
       return i::HandleScope::CreateHandle(isolate, value);
+    }
     i::Object** HandleScope::CreateHandle(i::HeapObject* heap_object,
                                           i::Object* value) {
       ASSERT(heap_object->IsHeapObject());
       return i::HandleScope::CreateHandle(heap_object->GetIsolate(), value);
+    }
     i::Object** HandleScope::CreateHandle(i::Isolate* isolate, i::Object* value) {
       ASSERT(isolate == i::Isolate::Current());
       return i::HandleScope::CreateHandle(isolate, value);
     EscapableHandleScope::EscapableHandleScope(Isolate* v8_isolate) {
       i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
       escape_slot_ = CreateHandle(isolate, isolate->heap()->the_hole_value());
       Initialize(v8_isolate);
+    }
     i::Object** HandleScope::CreateHandle(i::HeapObject* value) {
       ASSERT(value->IsHeapObject());
       return reinterpret_cast<i::Object**>(
           i::HandleScope::CreateHandle(value->GetIsolate(), value));
     i::Object** EscapableHandleScope::Escape(i::Object** escape_value) {
       ApiCheck(*escape_slot_ == isolate_->heap()->the_hole_value(),
                "EscapeableHandleScope::Escape",
                "Escape value set twice");
       if (escape_value == NULL) {
         *escape_slot_ = isolate_->heap()->undefined_value();
         return NULL;
+      }
       *escape_slot_ = *escape_value;
       return escape_slot_;
+    }
     void Context::Enter() {
       i::Handle<i::Context> env = Utils::OpenHandle(this);
       i::Isolate* isolate = env->GetIsolate();
       if (IsDeadCheck(isolate, "v8::Context::Enter()")) return;
       ENTER_V8(isolate);
       isolate->handle_scope_implementer()->EnterContext(env);
       isolate->handle_scope_implementer()->SaveContext(isolate->context());
       isolate->set_context(*env);
+    }
     void Context::Exit() {
       // Exit is essentially a static function and doesn't use the
       // receiver, so we have to get the current isolate from the thread
       // local.
       // TODO(dcarney): fix this once chrome is fixed.
       i::Isolate* isolate = i::Isolate::Current();
       if (!isolate->IsInitialized()) return;
       if (!ApiCheck(isolate->handle_scope_implementer()->LeaveLastContext(),
       i::Handle<i::Context> context = i::Handle<i::Context>::null();
       ENTER_V8(isolate);
       if (!ApiCheck(isolate->handle_scope_implementer()->LeaveContext(context),
                     "v8::Context::Exit()",
                     "Cannot exit non-entered context")) {
         return;
+      }
       // Content of 'last_context' could be NULL.
       i::Context* last_context =
           isolate->handle_scope_implementer()->RestoreContext();
-...
                                                     bool can_grow,
                                                     const char* location) {
       i::Handle<i::Context> env = Utils::OpenHandle(context);
       bool ok = !IsDeadCheck(env->GetIsolate(), location) &&
       bool ok =
           ApiCheck(env->IsNativeContext(), location, "Not a native context") &&
           ApiCheck(index >= 0, location, "Negative index");
       if (!ok) return i::Handle<i::FixedArray>();
-...
                        v8::Handle<Data> value,
                        v8::PropertyAttribute attribute) {
       i::Isolate* isolate = i::Isolate::Current();
       if (IsDeadCheck(isolate, "v8::Template::Set()")) return;
       ENTER_V8(isolate);
       i::HandleScope scope(isolate);
       const int kSize = 3;
-...
         v8::PropertyAttribute attribute,
         v8::AccessControl access_control) {
       i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
       if (IsDeadCheck(isolate, "v8::Template::SetAccessor()")) return;
       ENTER_V8(isolate);
       ASSERT(!name.IsEmpty());
       ASSERT(!getter.IsEmpty() || !setter.IsEmpty());
-...
     Local<ObjectTemplate> FunctionTemplate::PrototypeTemplate() {
       i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
       if (IsDeadCheck(isolate, "v8::FunctionTemplate::PrototypeTemplate()")) {
         return Local<ObjectTemplate>();
+      }
       ENTER_V8(isolate);
       i::Handle<i::Object> result(Utils::OpenHandle(this)->prototype_template(),
                                   isolate);
-...
     void FunctionTemplate::Inherit(v8::Handle<FunctionTemplate> value) {
       i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
       if (IsDeadCheck(isolate, "v8::FunctionTemplate::Inherit()")) return;
       ENTER_V8(isolate);
       Utils::OpenHandle(this)->set_parent_template(*Utils::OpenHandle(*value));
+    }
-...
+      }
       obj->set_serial_number(i::Smi::FromInt(next_serial_number));
       if (callback != 0) {
         if (data.IsEmpty()) data = v8::Undefined();
         if (data.IsEmpty()) {
           data = v8::Undefined(reinterpret_cast<v8::Isolate*>(isolate));
+        }
         Utils::ToLocal(obj)->SetCallHandler(callback, data);
+      }
       obj->set_length(length);
-...
     void FunctionTemplate::SetCallHandler(FunctionCallback callback,
                                           v8::Handle<Value> data) {
       i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
       if (IsDeadCheck(isolate, "v8::FunctionTemplate::SetCallHandler()")) return;
       ENTER_V8(isolate);
       i::HandleScope scope(isolate);
       i::Handle<i::Struct> struct_obj =
-...
       i::Handle<i::CallHandlerInfo> obj =
           i::Handle<i::CallHandlerInfo>::cast(struct_obj);
       SET_FIELD_WRAPPED(obj, set_callback, callback);
       if (data.IsEmpty()) data = v8::Undefined();
       if (data.IsEmpty()) {
         data = v8::Undefined(reinterpret_cast<v8::Isolate*>(isolate));
+      }
       obj->set_data(*Utils::OpenHandle(*data));
       Utils::OpenHandle(this)->set_call_code(*obj);
+    }
-...
           isolate->factory()->NewExecutableAccessorInfo();
       SET_FIELD_WRAPPED(obj, set_getter, getter);
       SET_FIELD_WRAPPED(obj, set_setter, setter);
       if (data.IsEmpty()) data = v8::Undefined();
       if (data.IsEmpty()) {
         data = v8::Undefined(reinterpret_cast<v8::Isolate*>(isolate));
+      }
       obj->set_data(*Utils::OpenHandle(*data));
       return SetAccessorInfoProperties(obj, name, settings, attributes, signature);
+    }
-...
     Local<ObjectTemplate> FunctionTemplate::InstanceTemplate() {
       i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
       if (IsDeadCheck(isolate, "v8::FunctionTemplate::InstanceTemplate()")
           || EmptyCheck("v8::FunctionTemplate::InstanceTemplate()", this))
       if (EmptyCheck("v8::FunctionTemplate::InstanceTemplate()", this))
         return Local<ObjectTemplate>();
       ENTER_V8(isolate);
       i::Handle<i::FunctionTemplateInfo> handle = Utils::OpenHandle(this);
-...
     void FunctionTemplate::SetLength(int length) {
       i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
       if (IsDeadCheck(isolate, "v8::FunctionTemplate::SetLength()")) return;
       ENTER_V8(isolate);
       Utils::OpenHandle(this)->set_length(length);
+    }
-...
     void FunctionTemplate::SetClassName(Handle<String> name) {
       i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
       if (IsDeadCheck(isolate, "v8::FunctionTemplate::SetClassName()")) return;
       ENTER_V8(isolate);
       Utils::OpenHandle(this)->set_class_name(*Utils::OpenHandle(*name));
+    }
-...
     void FunctionTemplate::SetHiddenPrototype(bool value) {
       i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
       if (IsDeadCheck(isolate, "v8::FunctionTemplate::SetHiddenPrototype()")) {
         return;
+      }
       ENTER_V8(isolate);
       Utils::OpenHandle(this)->set_hidden_prototype(value);
+    }
-...
     void FunctionTemplate::ReadOnlyPrototype() {
       i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
       if (IsDeadCheck(isolate, "v8::FunctionTemplate::ReadOnlyPrototype()")) {
         return;
+      }
       ENTER_V8(isolate);
       Utils::OpenHandle(this)->set_read_only_prototype(true);
+    }
-...
     void FunctionTemplate::RemovePrototype() {
       i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
       if (IsDeadCheck(isolate, "v8::FunctionTemplate::RemovePrototype()")) {
         return;
+      }
       ENTER_V8(isolate);
       Utils::OpenHandle(this)->set_remove_prototype(true);
+    }
-...
     Local<ObjectTemplate> ObjectTemplate::New(
           v8::Handle<FunctionTemplate> constructor) {
       i::Isolate* isolate = i::Isolate::Current();
       if (IsDeadCheck(isolate, "v8::ObjectTemplate::New()")) {
         return Local<ObjectTemplate>();
+      }
       EnsureInitializedForIsolate(isolate, "v8::ObjectTemplate::New()");
       LOG_API(isolate, "ObjectTemplate::New");
       ENTER_V8(isolate);
-...
         PropertyAttribute attribute,
         v8::Local<AccessorSignature> signature) {
       i::Isolate* isolate = Utils::OpenHandle(template_obj)->GetIsolate();
       if (IsDeadCheck(isolate, "v8::ObjectTemplate::SetAccessor()")) return false;
       ENTER_V8(isolate);
       i::HandleScope scope(isolate);
       i::Handle<i::AccessorInfo> obj = MakeAccessorInfo(
-...
         NamedPropertyEnumeratorCallback enumerator,
         Handle<Value> data) {
       i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
       if (IsDeadCheck(isolate, "v8::ObjectTemplate::SetNamedPropertyHandler()")) {
         return;
+      }
       ENTER_V8(isolate);
       i::HandleScope scope(isolate);
       EnsureConstructor(this);
-...
       if (remover != 0) SET_FIELD_WRAPPED(obj, set_deleter, remover);
       if (enumerator != 0) SET_FIELD_WRAPPED(obj, set_enumerator, enumerator);
       if (data.IsEmpty()) data = v8::Undefined();
       if (data.IsEmpty()) {
         data = v8::Undefined(reinterpret_cast<v8::Isolate*>(isolate));
+      }
       obj->set_data(*Utils::OpenHandle(*data));
       cons->set_named_property_handler(*obj);
+    }
-...
     void ObjectTemplate::MarkAsUndetectable() {
       i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
       if (IsDeadCheck(isolate, "v8::ObjectTemplate::MarkAsUndetectable()")) return;
       ENTER_V8(isolate);
       i::HandleScope scope(isolate);
       EnsureConstructor(this);
-...
           Handle<Value> data,
           bool turned_on_by_default) {
       i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
       if (IsDeadCheck(isolate, "v8::ObjectTemplate::SetAccessCheckCallbacks()")) {
         return;
+      }
       ENTER_V8(isolate);
       i::HandleScope scope(isolate);
       EnsureConstructor(this);
-...
       SET_FIELD_WRAPPED(info, set_named_callback, named_callback);
       SET_FIELD_WRAPPED(info, set_indexed_callback, indexed_callback);
       if (data.IsEmpty()) data = v8::Undefined();
       if (data.IsEmpty()) {
         data = v8::Undefined(reinterpret_cast<v8::Isolate*>(isolate));
+      }
       info->set_data(*Utils::OpenHandle(*data));
       i::FunctionTemplateInfo* constructor =
-...
           IndexedPropertyEnumeratorCallback enumerator,
           Handle<Value> data) {
       i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
       if (IsDeadCheck(isolate, "v8::ObjectTemplate::SetIndexedPropertyHandler()")) {
         return;
+      }
       ENTER_V8(isolate);
       i::HandleScope scope(isolate);
       EnsureConstructor(this);
-...
       if (remover != 0) SET_FIELD_WRAPPED(obj, set_deleter, remover);
       if (enumerator != 0) SET_FIELD_WRAPPED(obj, set_enumerator, enumerator);
       if (data.IsEmpty()) data = v8::Undefined();
       if (data.IsEmpty()) {
         data = v8::Undefined(reinterpret_cast<v8::Isolate*>(isolate));
+      }
       obj->set_data(*Utils::OpenHandle(*data));
       cons->set_indexed_property_handler(*obj);
+    }
-...
     void ObjectTemplate::SetCallAsFunctionHandler(FunctionCallback callback,
                                                   Handle<Value> data) {
       i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
       if (IsDeadCheck(isolate,
                       "v8::ObjectTemplate::SetCallAsFunctionHandler()")) {
         return;
+      }
       ENTER_V8(isolate);
       i::HandleScope scope(isolate);
       EnsureConstructor(this);
-...
       i::Handle<i::CallHandlerInfo> obj =
           i::Handle<i::CallHandlerInfo>::cast(struct_obj);
       SET_FIELD_WRAPPED(obj, set_callback, callback);
       if (data.IsEmpty()) data = v8::Undefined();
       if (data.IsEmpty()) {
         data = v8::Undefined(reinterpret_cast<v8::Isolate*>(isolate));
+      }
       obj->set_data(*Utils::OpenHandle(*data));
       cons->set_instance_call_handler(*obj);
+    }
     int ObjectTemplate::InternalFieldCount() {
       if (IsDeadCheck(Utils::OpenHandle(this)->GetIsolate(),
                       "v8::ObjectTemplate::InternalFieldCount()")) {
         return 0;
+      }
       return i::Smi::cast(Utils::OpenHandle(this)->internal_field_count())->value();
+    }
     void ObjectTemplate::SetInternalFieldCount(int value) {
       i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
       if (IsDeadCheck(isolate, "v8::ObjectTemplate::SetInternalFieldCount()")) {
         return;
+      }
       if (!ApiCheck(i::Smi::IsValid(value),
                     "v8::ObjectTemplate::SetInternalFieldCount()",
                     "Invalid internal field count")) {
-...
     // --- S c r i p t D a t a ---
     ScriptData* ScriptData::PreCompile(const char* input, int length) {
     ScriptData* ScriptData::PreCompile(v8::Isolate* isolate,
                                        const char* input,
                                        int length) {
       i::Utf8ToUtf16CharacterStream stream(
           reinterpret_cast<const unsigned char*>(input), length);
       return i::PreParserApi::PreParse(i::Isolate::Current(), &stream);
       return i::PreParserApi::PreParse(
           reinterpret_cast<i::Isolate*>(isolate), &stream);
+    }
-...
                               v8::ScriptOrigin* origin,
                               v8::ScriptData* pre_data,
                               v8::Handle<String> script_data) {
       i::Isolate* isolate = i::Isolate::Current();
       i::Handle<i::String> str = Utils::OpenHandle(*source);
       i::Isolate* isolate = str->GetIsolate();
       ON_BAILOUT(isolate, "v8::Script::New()", return Local<Script>());
       LOG_API(isolate, "Script::New");
       ENTER_V8(isolate);
       i::SharedFunctionInfo* raw_result = NULL;
       { i::HandleScope scope(isolate);
         i::Handle<i::String> str = Utils::OpenHandle(*source);
         i::Handle<i::Object> name_obj;
         int line_offset = 0;
         int column_offset = 0;
-...
                 static_cast<int>(origin->ResourceColumnOffset()->Value());
+          }
           if (!origin->ResourceIsSharedCrossOrigin().IsEmpty()) {
             v8::Isolate* v8_isolate = reinterpret_cast<v8::Isolate*>(isolate);
             is_shared_cross_origin =
                 origin->ResourceIsSharedCrossOrigin() == v8::True();
                 origin->ResourceIsSharedCrossOrigin() == v8::True(v8_isolate);
+          }
+        }
         EXCEPTION_PREAMBLE(isolate);
-...
                                   v8::ScriptOrigin* origin,
                                   v8::ScriptData* pre_data,
                                   v8::Handle<String> script_data) {
       i::Isolate* isolate = i::Isolate::Current();
       i::Handle<i::String> str = Utils::OpenHandle(*source);
       i::Isolate* isolate = str->GetIsolate();
       ON_BAILOUT(isolate, "v8::Script::Compile()", return Local<Script>());
       LOG_API(isolate, "Script::Compile");
       ENTER_V8(isolate);
-...
     Local<Value> Script::Run() {
       i::Isolate* isolate = i::Isolate::Current();
       // If execution is terminating, Compile(script)->Run() requires this check.
       if (this == NULL) return Local<Value>();
       i::Handle<i::HeapObject> obj =
           i::Handle<i::HeapObject>::cast(Utils::OpenHandle(this));
       i::Isolate* isolate = obj->GetIsolate();
       ON_BAILOUT(isolate, "v8::Script::Run()", return Local<Value>());
       LOG_API(isolate, "Script::Run");
       ENTER_V8(isolate);
-...
       i::Object* raw_result = NULL;
+      {
         i::HandleScope scope(isolate);
         i::Handle<i::Object> obj = Utils::OpenHandle(this);
         i::Handle<i::JSFunction> fun;
         if (obj->IsSharedFunctionInfo()) {
           i::Handle<i::SharedFunctionInfo>
-...
     Local<Value> Script::Id() {
       i::Isolate* isolate = i::Isolate::Current();
       i::Handle<i::HeapObject> obj =
           i::Handle<i::HeapObject>::cast(Utils::OpenHandle(this));
       i::Isolate* isolate = obj->GetIsolate();
       ON_BAILOUT(isolate, "v8::Script::Id()", return Local<Value>());
       LOG_API(isolate, "Script::Id");
       i::Object* raw_id = NULL;
-...
     int Script::GetId() {
       i::Isolate* isolate = i::Isolate::Current();
       i::Handle<i::HeapObject> obj =
           i::Handle<i::HeapObject>::cast(Utils::OpenHandle(this));
       i::Isolate* isolate = obj->GetIsolate();
       ON_BAILOUT(isolate, "v8::Script::Id()", return -1);
       LOG_API(isolate, "Script::Id");
+      {
-...
     int Script::GetLineNumber(int code_pos) {
       i::Isolate* isolate = i::Isolate::Current();
       i::Handle<i::HeapObject> obj =
           i::Handle<i::HeapObject>::cast(Utils::OpenHandle(this));
       i::Isolate* isolate = obj->GetIsolate();
       ON_BAILOUT(isolate, "v8::Script::GetLineNumber()", return -1);
       LOG_API(isolate, "Script::GetLineNumber");
       i::Handle<i::Object> obj = Utils::OpenHandle(this);
       if (obj->IsScript()) {
         i::Handle<i::Script> script = i::Handle<i::Script>(i::Script::cast(*obj));
         return i::GetScriptLineNumber(script, code_pos);
-...
     Handle<Value> Script::GetScriptName() {
       i::Isolate* isolate = i::Isolate::Current();
       i::Handle<i::HeapObject> obj =
           i::Handle<i::HeapObject>::cast(Utils::OpenHandle(this));
       i::Isolate* isolate = obj->GetIsolate();
       ON_BAILOUT(isolate, "v8::Script::GetName()", return Handle<String>());
       LOG_API(isolate, "Script::GetName");
       i::Handle<i::Object> obj = Utils::OpenHandle(this);
       if (obj->IsScript()) {
         i::Object* name = i::Script::cast(*obj)->name();
         return Utils::ToLocal(i::Handle<i::Object>(name, isolate));
-...
     void Script::SetData(v8::Handle<String> data) {
       i::Isolate* isolate = i::Isolate::Current();
       i::Handle<i::HeapObject> obj =
           i::Handle<i::HeapObject>::cast(Utils::OpenHandle(this));
       i::Isolate* isolate = obj->GetIsolate();
       ON_BAILOUT(isolate, "v8::Script::SetData()", return);
       LOG_API(isolate, "Script::SetData");
+      {
-...
     v8::TryCatch::~TryCatch() {
       ASSERT(isolate_ == i::Isolate::Current());
       if (rethrow_) {
         v8::HandleScope scope(reinterpret_cast<Isolate*>(isolate_));
         v8::Local<v8::Value> exc = v8::Local<v8::Value>::New(Exception());
         v8::Isolate* isolate = reinterpret_cast<Isolate*>(isolate_);
         v8::HandleScope scope(isolate);
         v8::Local<v8::Value> exc = v8::Local<v8::Value>::New(isolate, Exception());
         if (HasCaught() && capture_message_) {
           // If an exception was caught and rethrow_ is indicated, the saved
           // message, script, and location need to be restored to Isolate TLS
-...
           isolate_->RestorePendingMessageFromTryCatch(this);
+        }
         isolate_->UnregisterTryCatchHandler(this);
         v8::ThrowException(exc);
         reinterpret_cast<Isolate*>(isolate_)->ThrowException(exc);
         ASSERT(!isolate_->thread_local_top()->rethrowing_message_);
       } else {
         isolate_->UnregisterTryCatchHandler(this);
-...
     v8::Handle<v8::Value> v8::TryCatch::ReThrow() {
       if (!HasCaught()) return v8::Local<v8::Value>();
       rethrow_ = true;
       return v8::Undefined();
       return v8::Undefined(reinterpret_cast<v8::Isolate*>(isolate_));
+    }
-...
         i::HandleScope scope(isolate_);
         i::Handle<i::JSObject> obj(i::JSObject::cast(raw_obj), isolate_);
         i::Handle<i::String> name = isolate_->factory()->stack_string();
         if (!obj->HasProperty(*name)) return v8::Local<Value>();
         if (!i::JSReceiver::HasProperty(obj, name)) return v8::Local<Value>();
         i::Handle<i::Object> value = i::GetProperty(isolate_, obj, name);
         if (value.is_null()) return v8::Local<Value>();
         return v8::Utils::ToLocal(scope.CloseAndEscape(value));
-...
     v8::Handle<Value> Message::GetScriptResourceName() const {
       i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
       if (IsDeadCheck(isolate, "v8::Message::GetScriptResourceName()")) {
         return Local<String>();
+      }
       ENTER_V8(isolate);
       HandleScope scope(reinterpret_cast<Isolate*>(isolate));
       i::Handle<i::JSMessageObject> message =
-...
     v8::Handle<Value> Message::GetScriptData() const {
       i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
       if (IsDeadCheck(isolate, "v8::Message::GetScriptResourceData()")) {
         return Local<Value>();
+      }
       ENTER_V8(isolate);
       HandleScope scope(reinterpret_cast<Isolate*>(isolate));
       i::Handle<i::JSMessageObject> message =
-...
     v8::Handle<v8::StackTrace> Message::GetStackTrace() const {
       i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
       if (IsDeadCheck(isolate, "v8::Message::GetStackTrace()")) {
         return Local<v8::StackTrace>();
+      }
       ENTER_V8(isolate);
       HandleScope scope(reinterpret_cast<Isolate*>(isolate));
       i::Handle<i::JSMessageObject> message =
-...
     int Message::GetStartPosition() const {
       i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
       if (IsDeadCheck(isolate, "v8::Message::GetStartPosition()")) return 0;
       ENTER_V8(isolate);
       i::HandleScope scope(isolate);
       i::Handle<i::JSMessageObject> message =
-...
     int Message::GetEndPosition() const {
       i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
       if (IsDeadCheck(isolate, "v8::Message::GetEndPosition()")) return 0;
       ENTER_V8(isolate);
       i::HandleScope scope(isolate);
       i::Handle<i::JSMessageObject> message =
-...
     int Message::GetStartColumn() const {
       i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
       if (IsDeadCheck(isolate, "v8::Message::GetStartColumn()")) {
         return kNoColumnInfo;
+      }
       ENTER_V8(isolate);
       i::HandleScope scope(isolate);
       i::Handle<i::JSObject> data_obj = Utils::OpenHandle(this);
-...
     int Message::GetEndColumn() const {
       i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
       if (IsDeadCheck(isolate, "v8::Message::GetEndColumn()")) return kNoColumnInfo;
       ENTER_V8(isolate);
       i::HandleScope scope(isolate);
       i::Handle<i::JSObject> data_obj = Utils::OpenHandle(this);
-...
     bool Message::IsSharedCrossOrigin() const {
       i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
       if (IsDeadCheck(isolate, "v8::Message::IsSharedCrossOrigin()")) return 0;
       ENTER_V8(isolate);
       i::HandleScope scope(isolate);
       i::Handle<i::JSMessageObject> message =
-...
     void Message::PrintCurrentStackTrace(FILE* out) {
       i::Isolate* isolate = i::Isolate::Current();
       if (IsDeadCheck(isolate, "v8::Message::PrintCurrentStackTrace()")) return;
       ENTER_V8(isolate);
       isolate->PrintCurrentStackTrace(out);
+    }
-...
     Local<StackFrame> StackTrace::GetFrame(uint32_t index) const {
       i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
       if (IsDeadCheck(isolate, "v8::StackTrace::GetFrame()")) {
         return Local<StackFrame>();
+      }
       ENTER_V8(isolate);
       HandleScope scope(reinterpret_cast<Isolate*>(isolate));
       i::Handle<i::JSArray> self = Utils::OpenHandle(this);
-...
     int StackTrace::GetFrameCount() const {
       i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
       if (IsDeadCheck(isolate, "v8::StackTrace::GetFrameCount()")) return -1;
       ENTER_V8(isolate);
       return i::Smi::cast(Utils::OpenHandle(this)->length())->value();
+    }
-...
     Local<Array> StackTrace::AsArray() {
       i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
       if (IsDeadCheck(isolate, "v8::StackTrace::AsArray()")) Local<Array>();
       ENTER_V8(isolate);
       return Utils::ToLocal(Utils::OpenHandle(this));
+    }
-...
     Local<StackTrace> StackTrace::CurrentStackTrace(int frame_limit,
         StackTraceOptions options) {
       i::Isolate* isolate = i::Isolate::Current();
       if (IsDeadCheck(isolate, "v8::StackTrace::CurrentStackTrace()")) {
         Local<StackTrace>();
+      }
       ENTER_V8(isolate);
       i::Handle<i::JSArray> stackTrace =
           isolate->CaptureCurrentStackTrace(frame_limit, options);
-...
     int StackFrame::GetLineNumber() const {
       i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
       if (IsDeadCheck(isolate, "v8::StackFrame::GetLineNumber()")) {
         return Message::kNoLineNumberInfo;
+      }
       ENTER_V8(isolate);
       i::HandleScope scope(isolate);
       i::Handle<i::JSObject> self = Utils::OpenHandle(this);
-...
     int StackFrame::GetColumn() const {
       i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
       if (IsDeadCheck(isolate, "v8::StackFrame::GetColumn()")) {
         return Message::kNoColumnInfo;
+      }
       ENTER_V8(isolate);
       i::HandleScope scope(isolate);
       i::Handle<i::JSObject> self = Utils::OpenHandle(this);
-...
     int StackFrame::GetScriptId() const {
       i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
       if (IsDeadCheck(isolate, "v8::StackFrame::GetScriptId()")) {
         return Message::kNoScriptIdInfo;
+      }
       ENTER_V8(isolate);
       i::HandleScope scope(isolate);
       i::Handle<i::JSObject> self = Utils::OpenHandle(this);
-...
     Local<String> StackFrame::GetScriptName() const {
       i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
       if (IsDeadCheck(isolate, "v8::StackFrame::GetScriptName()")) {
         return Local<String>();
+      }
       ENTER_V8(isolate);
       HandleScope scope(reinterpret_cast<Isolate*>(isolate));
       i::Handle<i::JSObject> self = Utils::OpenHandle(this);
-...
     Local<String> StackFrame::GetScriptNameOrSourceURL() const {
       i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
       if (IsDeadCheck(isolate, "v8::StackFrame::GetScriptNameOrSourceURL()")) {
         return Local<String>();
+      }
       ENTER_V8(isolate);
       HandleScope scope(reinterpret_cast<Isolate*>(isolate));
       i::Handle<i::JSObject> self = Utils::OpenHandle(this);
-...
     Local<String> StackFrame::GetFunctionName() const {
       i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
       if (IsDeadCheck(isolate, "v8::StackFrame::GetFunctionName()")) {
         return Local<String>();
+      }
       ENTER_V8(isolate);
       HandleScope scope(reinterpret_cast<Isolate*>(isolate));
       i::Handle<i::JSObject> self = Utils::OpenHandle(this);
-...
     bool StackFrame::IsEval() const {
       i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
       if (IsDeadCheck(isolate, "v8::StackFrame::IsEval()")) return false;
       ENTER_V8(isolate);
       i::HandleScope scope(isolate);
       i::Handle<i::JSObject> self = Utils::OpenHandle(this);
-...
     bool StackFrame::IsConstructor() const {
       i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
       if (IsDeadCheck(isolate, "v8::StackFrame::IsConstructor()")) return false;
       ENTER_V8(isolate);
       i::HandleScope scope(isolate);
       i::Handle<i::JSObject> self = Utils::OpenHandle(this);
-...
     // --- D a t a ---
     bool Value::FullIsUndefined() const {
       if (IsDeadCheck(i::Isolate::Current(), "v8::Value::IsUndefined()")) {
         return false;
+      }
       bool result = Utils::OpenHandle(this)->IsUndefined();
       ASSERT_EQ(result, QuickIsUndefined());
       return result;
-...
     bool Value::FullIsNull() const {
       if (IsDeadCheck(i::Isolate::Current(), "v8::Value::IsNull()")) return false;
       bool result = Utils::OpenHandle(this)->IsNull();
       ASSERT_EQ(result, QuickIsNull());
       return result;
-...
     bool Value::IsTrue() const {
       if (IsDeadCheck(i::Isolate::Current(), "v8::Value::IsTrue()")) return false;
       return Utils::OpenHandle(this)->IsTrue();
+    }
     bool Value::IsFalse() const {
       if (IsDeadCheck(i::Isolate::Current(), "v8::Value::IsFalse()")) return false;
       return Utils::OpenHandle(this)->IsFalse();
+    }
     bool Value::IsFunction() const {
       if (IsDeadCheck(i::Isolate::Current(), "v8::Value::IsFunction()")) {
         return false;
+      }
       return Utils::OpenHandle(this)->IsJSFunction();
+    }
     bool Value::FullIsString() const {
       if (IsDeadCheck(i::Isolate::Current(), "v8::Value::IsString()")) return false;
       bool result = Utils::OpenHandle(this)->IsString();
       ASSERT_EQ(result, QuickIsString());
       return result;
-...
     bool Value::IsSymbol() const {
       if (IsDeadCheck(i::Isolate::Current(), "v8::Value::IsSymbol()")) return false;
       return Utils::OpenHandle(this)->IsSymbol();
+    }
     bool Value::IsArray() const {
       if (IsDeadCheck(i::Isolate::Current(), "v8::Value::IsArray()")) return false;
       return Utils::OpenHandle(this)->IsJSArray();
+    }
     bool Value::IsArrayBuffer() const {
       if (IsDeadCheck(i::Isolate::Current(), "v8::Value::IsArrayBuffer()"))
         return false;
       return Utils::OpenHandle(this)->IsJSArrayBuffer();
+    }
-...
     bool Value::IsTypedArray() const {
       if (IsDeadCheck(i::Isolate::Current(), "v8::Value::IsArrayBuffer()"))
         return false;
       return Utils::OpenHandle(this)->IsJSTypedArray();
+    }
-...
     #define VALUE_IS_TYPED_ARRAY(TypedArray, type_const)                          \
       bool Value::Is##TypedArray() const {                                        \
         if (IsDeadCheck(i::Isolate::Current(), "v8::Value::Is" #TypedArray "()")) \
           return false;                                                           \
         i::Handle<i::Object> obj = Utils::OpenHandle(this);                       \
         if (!obj->IsJSTypedArray()) return false;                                 \
         return i::JSTypedArray::cast(*obj)->type() == type_const;                 \
-...
     bool Value::IsObject() const {
       if (IsDeadCheck(i::Isolate::Current(), "v8::Value::IsObject()")) return false;
       return Utils::OpenHandle(this)->IsJSObject();
+    }
     bool Value::IsNumber() const {
       if (IsDeadCheck(i::Isolate::Current(), "v8::Value::IsNumber()")) return false;
       return Utils::OpenHandle(this)->IsNumber();
+    }
     bool Value::IsBoolean() const {
       if (IsDeadCheck(i::Isolate::Current(), "v8::Value::IsBoolean()")) {
         return false;
+      }
       return Utils::OpenHandle(this)->IsBoolean();
+    }
     bool Value::IsExternal() const {
       if (IsDeadCheck(i::Isolate::Current(), "v8::Value::IsExternal()")) {
         return false;
+      }
       return Utils::OpenHandle(this)->IsExternal();
+    }
     bool Value::IsInt32() const {
       if (IsDeadCheck(i::Isolate::Current(), "v8::Value::IsInt32()")) return false;
       i::Handle<i::Object> obj = Utils::OpenHandle(this);
       if (obj->IsSmi()) return true;
       if (obj->IsNumber()) {
-...
     bool Value::IsUint32() const {
       if (IsDeadCheck(i::Isolate::Current(), "v8::Value::IsUint32()")) return false;
       i::Handle<i::Object> obj = Utils::OpenHandle(this);
       if (obj->IsSmi()) return i::Smi::cast(*obj)->value() >= 0;
       if (obj->IsNumber()) {
-...
     bool Value::IsDate() const {
       i::Isolate* isolate = i::Isolate::Current();
       if (IsDeadCheck(isolate, "v8::Value::IsDate()")) return false;
       i::Handle<i::Object> obj = Utils::OpenHandle(this);
       return obj->HasSpecificClassOf(isolate->heap()->Date_string());
+    }
-...
     bool Value::IsStringObject() const {
       i::Isolate* isolate = i::Isolate::Current();
       if (IsDeadCheck(isolate, "v8::Value::IsStringObject()")) return false;
       i::Handle<i::Object> obj = Utils::OpenHandle(this);
       return obj->HasSpecificClassOf(isolate->heap()->String_string());
+    }
-...
       // TODO(svenpanne): these and other test functions should be written such
       // that they do not use Isolate::Current().
       i::Isolate* isolate = i::Isolate::Current();
       if (IsDeadCheck(isolate, "v8::Value::IsSymbolObject()")) return false;
       i::Handle<i::Object> obj = Utils::OpenHandle(this);
       return obj->HasSpecificClassOf(isolate->heap()->Symbol_string());
+    }
-...
     bool Value::IsNumberObject() const {
       i::Isolate* isolate = i::Isolate::Current();
       if (IsDeadCheck(isolate, "v8::Value::IsNumberObject()")) return false;
       i::Handle<i::Object> obj = Utils::OpenHandle(this);
       return obj->HasSpecificClassOf(isolate->heap()->Number_string());
+    }
-...
     bool Value::IsNativeError() const {
       i::Isolate* isolate = i::Isolate::Current();
       if (IsDeadCheck(isolate, "v8::Value::IsNativeError()")) return false;
       i::Handle<i::Object> obj = Utils::OpenHandle(this);
       if (obj->IsJSObject()) {
         i::Handle<i::JSObject> js_obj(i::JSObject::cast(*obj));
-...
     bool Value::IsBooleanObject() const {
       i::Isolate* isolate = i::Isolate::Current();
       if (IsDeadCheck(isolate, "v8::Value::IsBooleanObject()")) return false;
       i::Handle<i::Object> obj = Utils::OpenHandle(this);
       return obj->HasSpecificClassOf(isolate->heap()->Boolean_string());
+    }
     bool Value::IsRegExp() const {
       if (IsDeadCheck(i::Isolate::Current(), "v8::Value::IsRegExp()")) return false;
       i::Handle<i::Object> obj = Utils::OpenHandle(this);
       return obj->IsJSRegExp();
+    }
-...
         str = obj;
       } else {
         i::Isolate* isolate = i::Isolate::Current();
         if (IsDeadCheck(isolate, "v8::Value::ToString()")) {
           return Local<String>();
+        }
         LOG_API(isolate, "ToString");
         ENTER_V8(isolate);
         EXCEPTION_PREAMBLE(isolate);
-...
         str = obj;
       } else {
         i::Isolate* isolate = i::Isolate::Current();
         if (IsDeadCheck(isolate, "v8::Value::ToDetailString()")) {
           return Local<String>();
+        }
         LOG_API(isolate, "ToDetailString");
         ENTER_V8(isolate);
         EXCEPTION_PREAMBLE(isolate);
-...
         val = obj;
       } else {
         i::Isolate* isolate = i::Isolate::Current();
         if (IsDeadCheck(isolate, "v8::Value::ToObject()")) {
           return Local<v8::Object>();
+        }
         LOG_API(isolate, "ToObject");
         ENTER_V8(isolate);
         EXCEPTION_PREAMBLE(isolate);
-...
         return ToApiHandle<Boolean>(obj);
       } else {
         i::Isolate* isolate = i::Isolate::Current();
         if (IsDeadCheck(isolate, "v8::Value::ToBoolean()")) {
           return Local<Boolean>();
+        }
         LOG_API(isolate, "ToBoolean");
         ENTER_V8(isolate);
         i::Handle<i::Object> val =
-...
         num = obj;
       } else {
         i::Isolate* isolate = i::Isolate::Current();
         if (IsDeadCheck(isolate, "v8::Value::ToNumber()")) {
           return Local<Number>();
+        }
         LOG_API(isolate, "ToNumber");
         ENTER_V8(isolate);
         EXCEPTION_PREAMBLE(isolate);
-...
         num = obj;
       } else {
         i::Isolate* isolate = i::Isolate::Current();
         if (IsDeadCheck(isolate, "v8::Value::ToInteger()")) return Local<Integer>();
         LOG_API(isolate, "ToInteger");
         ENTER_V8(isolate);
         EXCEPTION_PREAMBLE(isolate);
-...
     void External::CheckCast(v8::Value* that) {
       if (IsDeadCheck(i::Isolate::Current(), "v8::External::Cast()")) return;
       ApiCheck(Utils::OpenHandle(that)->IsExternal(),
                "v8::External::Cast()",
                "Could not convert to external");
-...
     void v8::Object::CheckCast(Value* that) {
       if (IsDeadCheck(i::Isolate::Current(), "v8::Object::Cast()")) return;
       i::Handle<i::Object> obj = Utils::OpenHandle(that);
       ApiCheck(obj->IsJSObject(),
                "v8::Object::Cast()",
-...
     void v8::Function::CheckCast(Value* that) {
       if (IsDeadCheck(i::Isolate::Current(), "v8::Function::Cast()")) return;
       i::Handle<i::Object> obj = Utils::OpenHandle(that);
       ApiCheck(obj->IsJSFunction(),
                "v8::Function::Cast()",
-...
     void v8::String::CheckCast(v8::Value* that) {
       if (IsDeadCheck(i::Isolate::Current(), "v8::String::Cast()")) return;
       i::Handle<i::Object> obj = Utils::OpenHandle(that);
       ApiCheck(obj->IsString(),
                "v8::String::Cast()",
-...
     void v8::Symbol::CheckCast(v8::Value* that) {
       if (IsDeadCheck(i::Isolate::Current(), "v8::Symbol::Cast()")) return;
       i::Handle<i::Object> obj = Utils::OpenHandle(that);
       ApiCheck(obj->IsSymbol(),
                "v8::Symbol::Cast()",
-...
     void v8::Number::CheckCast(v8::Value* that) {
       if (IsDeadCheck(i::Isolate::Current(), "v8::Number::Cast()")) return;
       i::Handle<i::Object> obj = Utils::OpenHandle(that);
       ApiCheck(obj->IsNumber(),
                "v8::Number::Cast()",
-...
     void v8::Integer::CheckCast(v8::Value* that) {
       if (IsDeadCheck(i::Isolate::Current(), "v8::Integer::Cast()")) return;
       i::Handle<i::Object> obj = Utils::OpenHandle(that);
       ApiCheck(obj->IsNumber(),
                "v8::Integer::Cast()",
-...
     void v8::Array::CheckCast(Value* that) {
       if (IsDeadCheck(i::Isolate::Current(), "v8::Array::Cast()")) return;
       i::Handle<i::Object> obj = Utils::OpenHandle(that);
       ApiCheck(obj->IsJSArray(),
                "v8::Array::Cast()",
-...
     void v8::ArrayBuffer::CheckCast(Value* that) {
       if (IsDeadCheck(i::Isolate::Current(), "v8::ArrayBuffer::Cast()")) return;
       i::Handle<i::Object> obj = Utils::OpenHandle(that);
       ApiCheck(obj->IsJSArrayBuffer(),
                "v8::ArrayBuffer::Cast()",
-...
     void v8::TypedArray::CheckCast(Value* that) {
       if (IsDeadCheck(i::Isolate::Current(), "v8::TypedArray::Cast()")) return;
       i::Handle<i::Object> obj = Utils::OpenHandle(that);
       ApiCheck(obj->IsJSTypedArray(),
                "v8::TypedArray::Cast()",
-...
     #define CHECK_TYPED_ARRAY_CAST(ApiClass, typeConst)                         \
       void v8::ApiClass::CheckCast(Value* that) {                               \
         if (IsDeadCheck(i::Isolate::Current(), "v8::" #ApiClass "::Cast()"))    \
           return;                                                               \
         i::Handle<i::Object> obj = Utils::OpenHandle(that);                     \
         ApiCheck(obj->IsJSTypedArray() &&                                       \
                  i::JSTypedArray::cast(*obj)->type() == typeConst,              \
-...
     void v8::Date::CheckCast(v8::Value* that) {
       i::Isolate* isolate = i::Isolate::Current();
       if (IsDeadCheck(isolate, "v8::Date::Cast()")) return;
       i::Handle<i::Object> obj = Utils::OpenHandle(that);
       ApiCheck(obj->HasSpecificClassOf(isolate->heap()->Date_string()),
                "v8::Date::Cast()",
-...
     void v8::StringObject::CheckCast(v8::Value* that) {
       i::Isolate* isolate = i::Isolate::Current();
       if (IsDeadCheck(isolate, "v8::StringObject::Cast()")) return;
       i::Handle<i::Object> obj = Utils::OpenHandle(that);
       ApiCheck(obj->HasSpecificClassOf(isolate->heap()->String_string()),
                "v8::StringObject::Cast()",
-...
     void v8::SymbolObject::CheckCast(v8::Value* that) {
       i::Isolate* isolate = i::Isolate::Current();
       if (IsDeadCheck(isolate, "v8::SymbolObject::Cast()")) return;
       i::Handle<i::Object> obj = Utils::OpenHandle(that);
       ApiCheck(obj->HasSpecificClassOf(isolate->heap()->Symbol_string()),
                "v8::SymbolObject::Cast()",
-...
     void v8::NumberObject::CheckCast(v8::Value* that) {
       i::Isolate* isolate = i::Isolate::Current();
       if (IsDeadCheck(isolate, "v8::NumberObject::Cast()")) return;
       i::Handle<i::Object> obj = Utils::OpenHandle(that);
       ApiCheck(obj->HasSpecificClassOf(isolate->heap()->Number_string()),
                "v8::NumberObject::Cast()",
-...
     void v8::BooleanObject::CheckCast(v8::Value* that) {
       i::Isolate* isolate = i::Isolate::Current();
       if (IsDeadCheck(isolate, "v8::BooleanObject::Cast()")) return;
       i::Handle<i::Object> obj = Utils::OpenHandle(that);
       ApiCheck(obj->HasSpecificClassOf(isolate->heap()->Boolean_string()),
                "v8::BooleanObject::Cast()",
-...
     void v8::RegExp::CheckCast(v8::Value* that) {
       if (IsDeadCheck(i::Isolate::Current(), "v8::RegExp::Cast()")) return;
       i::Handle<i::Object> obj = Utils::OpenHandle(that);
       ApiCheck(obj->IsJSRegExp(),
                "v8::RegExp::Cast()",
-...
         num = obj;
       } else {
         i::Isolate* isolate = i::Isolate::Current();
         if (IsDeadCheck(isolate, "v8::Value::NumberValue()")) {
           return i::OS::nan_value();
+        }
         LOG_API(isolate, "NumberValue");
         ENTER_V8(isolate);
         EXCEPTION_PREAMBLE(isolate);
-...
         num = obj;
       } else {
         i::Isolate* isolate = i::Isolate::Current();
         if (IsDeadCheck(isolate, "v8::Value::IntegerValue()")) return 0;
         LOG_API(isolate, "IntegerValue");
         ENTER_V8(isolate);
         EXCEPTION_PREAMBLE(isolate);
-...
         num = obj;
       } else {
         i::Isolate* isolate = i::Isolate::Current();
         if (IsDeadCheck(isolate, "v8::Value::ToInt32()")) return Local<Int32>();
         LOG_API(isolate, "ToInt32");
         ENTER_V8(isolate);
         EXCEPTION_PREAMBLE(isolate);
-...
         num = obj;
       } else {
         i::Isolate* isolate = i::Isolate::Current();
         if (IsDeadCheck(isolate, "v8::Value::ToUint32()")) return Local<Uint32>();
         LOG_API(isolate, "ToUInt32");
         ENTER_V8(isolate);
         EXCEPTION_PREAMBLE(isolate);
-...
         return Local<Uint32>();
+      }
       i::Isolate* isolate = i::Isolate::Current();
       if (IsDeadCheck(isolate, "v8::Value::ToArrayIndex()")) return Local<Uint32>();
       LOG_API(isolate, "ToArrayIndex");
       ENTER_V8(isolate);
       EXCEPTION_PREAMBLE(isolate);
-...
         return i::Smi::cast(*obj)->value();
       } else {
         i::Isolate* isolate = i::Isolate::Current();
         if (IsDeadCheck(isolate, "v8::Value::Int32Value()")) return 0;
         LOG_API(isolate, "Int32Value (slow)");
         ENTER_V8(isolate);
         EXCEPTION_PREAMBLE(isolate);
-...
     bool Value::Equals(Handle<Value> that) const {
       i::Isolate* isolate = i::Isolate::Current();
       if (IsDeadCheck(isolate, "v8::Value::Equals()")
           || EmptyCheck("v8::Value::Equals()", this)
           || EmptyCheck("v8::Value::Equals()", that)) {
       if (EmptyCheck("v8::Value::Equals()", this) ||
           EmptyCheck("v8::Value::Equals()", that)) {
         return false;
+      }
       LOG_API(isolate, "Equals");
-...
     bool Value::StrictEquals(Handle<Value> that) const {
       i::Isolate* isolate = i::Isolate::Current();
       if (IsDeadCheck(isolate, "v8::Value::StrictEquals()")
           || EmptyCheck("v8::Value::StrictEquals()", this)
           || EmptyCheck("v8::Value::StrictEquals()", that)) {
       if (EmptyCheck("v8::Value::StrictEquals()", this) ||
           EmptyCheck("v8::Value::StrictEquals()", that)) {
         return false;
+      }
       LOG_API(isolate, "StrictEquals");
-...
+    }
     bool Value::SameValue(Handle<Value> that) const {
       i::Isolate* isolate = i::Isolate::Current();
       if (EmptyCheck("v8::Value::SameValue()", this) ||
           EmptyCheck("v8::Value::SameValue()", that)) {
         return false;
+      }
       LOG_API(isolate, "SameValue");
       i::Handle<i::Object> obj = Utils::OpenHandle(this);
       i::Handle<i::Object> other = Utils::OpenHandle(*that);
       return obj->SameValue(*other);
+    }
     uint32_t Value::Uint32Value() const {
       i::Handle<i::Object> obj = Utils::OpenHandle(this);
       if (obj->IsSmi()) {
         return i::Smi::cast(*obj)->value();
       } else {
         i::Isolate* isolate = i::Isolate::Current();
         if (IsDeadCheck(isolate, "v8::Value::Uint32Value()")) return 0;
         LOG_API(isolate, "Uint32Value");
         ENTER_V8(isolate);
         EXCEPTION_PREAMBLE(isolate);
-...
       i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
       ON_BAILOUT(isolate, "v8::Object::HasProperty()", return false);
       i::Handle<i::JSObject> self = Utils::OpenHandle(this);
       return self->HasElement(index);
       return i::JSReceiver::HasElement(self, index);
+    }
-...
       i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
       ON_BAILOUT(isolate, "v8::Object::HasOwnProperty()",
                  return false);
       return Utils::OpenHandle(this)->HasLocalProperty(
           *Utils::OpenHandle(*key));
       return i::JSReceiver::HasLocalProperty(
           Utils::OpenHandle(this), Utils::OpenHandle(*key));
+    }
-...
       i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
       ON_BAILOUT(isolate, "v8::Object::HasRealNamedProperty()",
                  return false);
       return Utils::OpenHandle(this)->HasRealNamedProperty(
           isolate,
           *Utils::OpenHandle(*key));
       return i::JSObject::HasRealNamedProperty(Utils::OpenHandle(this),
                                                Utils::OpenHandle(*key));
+    }
-...
       i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
       ON_BAILOUT(isolate, "v8::Object::HasRealIndexedProperty()",
                  return false);
       return Utils::OpenHandle(this)->HasRealElementProperty(isolate, index);
       return i::JSObject::HasRealElementProperty(Utils::OpenHandle(this), index);
+    }
-...
                  "v8::Object::HasRealNamedCallbackProperty()",
                  return false);
       ENTER_V8(isolate);
       return Utils::OpenHandle(this)->HasRealNamedCallbackProperty(
           isolate,
           *Utils::OpenHandle(*key));
       return i::JSObject::HasRealNamedCallbackProperty(Utils::OpenHandle(this),
                                                        Utils::OpenHandle(*key));
+    }
-...
       ENTER_V8(isolate);
       i::Handle<i::JSObject> self = Utils::OpenHandle(this);
       EXCEPTION_PREAMBLE(isolate);
       i::Handle<i::JSObject> result = i::Copy(self);
       i::Handle<i::JSObject> result = i::JSObject::Copy(self);
       has_pending_exception = result.is_null();
       EXCEPTION_BAILOUT_CHECK(isolate, Local<Object>());
       return Utils::ToLocal(result);
-...
+    }
     Local<v8::Value> Object::CallAsFunction(v8::Handle<v8::Object> recv,
     Local<v8::Value> Object::CallAsFunction(v8::Handle<v8::Value> recv,
                                             int argc,
                                             v8::Handle<v8::Value> argv[]) {
       i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
-...
+      }
       EXCEPTION_PREAMBLE(isolate);
       i::Handle<i::Object> returned = i::Execution::Call(
           isolate, fun, recv_obj, argc, args, &has_pending_exception);
           isolate, fun, recv_obj, argc, args, &has_pending_exception, true);
       EXCEPTION_BAILOUT_CHECK_DO_CALLBACK(isolate, Local<Value>());
       return Utils::ToLocal(scope.CloseAndEscape(returned));
+    }
-...
+    }
     Local<v8::Value> Function::Call(v8::Handle<v8::Object> recv, int argc,
     Local<v8::Value> Function::Call(v8::Handle<v8::Value> recv, int argc,
                                     v8::Handle<v8::Value> argv[]) {
       i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
       ON_BAILOUT(isolate, "v8::Function::Call()", return Local<v8::Value>());
-...
         i::Handle<i::Object>* args = reinterpret_cast<i::Handle<i::Object>*>(argv);
         EXCEPTION_PREAMBLE(isolate);
         i::Handle<i::Object> returned = i::Execution::Call(
             isolate, fun, recv_obj, argc, args, &has_pending_exception);
             isolate, fun, recv_obj, argc, args, &has_pending_exception, true);
         EXCEPTION_BAILOUT_CHECK_DO_CALLBACK(isolate, Local<Object>());
         raw_result = *returned;
+      }
-...
+    }
     Handle<Value> Function::GetDisplayName() const {
       i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
       ON_BAILOUT(isolate, "v8::Function::GetDisplayName()",
                  return ToApiHandle<Primitive>(
                     isolate->factory()->undefined_value()));
       ENTER_V8(isolate);
       i::Handle<i::JSFunction> func = Utils::OpenHandle(this);
       i::Handle<i::String> property_name =
           isolate->factory()->InternalizeOneByteString(
               STATIC_ASCII_VECTOR("displayName"));
       i::LookupResult lookup(isolate);
       func->LookupRealNamedProperty(*property_name, &lookup);
       if (lookup.IsFound()) {
         i::Object* value = lookup.GetLazyValue();
         if (value && value->IsString()) {
           i::String* name = i::String::cast(value);
           if (name->length() > 0) return Utils::ToLocal(i::Handle<i::String>(name));
+        }
+      }
       return ToApiHandle<Primitive>(isolate->factory()->undefined_value());
+    }
     ScriptOrigin Function::GetScriptOrigin() const {
       i::Handle<i::JSFunction> func = Utils::OpenHandle(this);
       if (func->shared()->script()->IsScript()) {
-...
+    }
     bool Function::IsBuiltin() const {
       i::Handle<i::JSFunction> func = Utils::OpenHandle(this);
       return func->IsBuiltin();
+    }
     Handle<Value> Function::GetScriptId() const {
       i::Handle<i::JSFunction> func = Utils::OpenHandle(this);
       if (!func->shared()->script()->IsScript())
         return v8::Undefined();
       i::Isolate* isolate = func->GetIsolate();
       if (!func->shared()->script()->IsScript()) {
         return v8::Undefined(reinterpret_cast<v8::Isolate*>(isolate));
+      }
       i::Handle<i::Script> script(i::Script::cast(func->shared()->script()));
       return Utils::ToLocal(i::Handle<i::Object>(script->id(), func->GetIsolate()));
       return Utils::ToLocal(i::Handle<i::Object>(script->id(), isolate));
+    }
-...
     int String::Length() const {
       i::Handle<i::String> str = Utils::OpenHandle(this);
       if (IsDeadCheck(str->GetIsolate(), "v8::String::Length()")) return 0;
       return str->length();
+    }
     bool String::IsOneByte() const {
       i::Handle<i::String> str = Utils::OpenHandle(this);
       if (IsDeadCheck(str->GetIsolate(), "v8::String::IsOneByte()")) {
         return false;
+      }
       return str->HasOnlyOneByteChars();
+    }
-...
     bool String::ContainsOnlyOneByte() const {
       i::Handle<i::String> str = Utils::OpenHandle(this);
       if (IsDeadCheck(str->GetIsolate(),
                       "v8::String::ContainsOnlyOneByte()")) {

... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff