Keep two empty lines between declarations for cpp files

src/api.cc

 // 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 280 matching lines @@
 
 static inline bool EmptyCheck(const char* location, v8::Handle<v8::Data> obj) {
   return obj.IsEmpty() ? ReportEmptyHandle(location) : false;
 }
 
 
 static inline bool EmptyCheck(const char* location, const v8::Data* obj) {
   return (obj == 0) ? ReportEmptyHandle(location) : false;
 }
 
+
 // --- S t a t i c s ---
 
 
 static bool InitializeHelper(i::Isolate* isolate) {
   // If the isolate has a function entry hook, it needs to re-build all its
   // code stubs with entry hooks embedded, so let's deserialize a snapshot.
   if (isolate == NULL || isolate->function_entry_hook() == NULL) {
     if (i::Snapshot::Initialize())
       return true;
   }
   return i::V8::Initialize(NULL);
 }
 
 
 static inline bool EnsureInitializedForIsolate(i::Isolate* isolate,
                                                const char* location) {
   if (IsDeadCheck(isolate, location)) return false;
   if (isolate != NULL) {
     if (isolate->IsInitialized()) return true;
   }
   ASSERT(isolate == i::Isolate::Current());
   return ApiCheck(InitializeHelper(isolate), location, "Error initializing V8");
 }
 
+
 // Some initializing API functions are called early and may be
 // called on a thread different from static initializer thread.
 // If Isolate API is used, Isolate::Enter() will initialize TLS so
 // Isolate::Current() works. If it's a legacy case, then the thread
 // may not have TLS initialized yet. However, in initializing APIs it
 // may be too early to call EnsureInitialized() - some pre-init
 // parameters still have to be configured.
 static inline i::Isolate* EnterIsolateIfNeeded() {
   i::Isolate* isolate = i::Isolate::UncheckedCurrent();
   if (isolate != NULL)
@@ skipping 59 matching lines @@
   kSnapshot = 0,
   kSnapshotContext,
   kLibraries,
   kExperimentalLibraries,
 #if defined(ENABLE_I18N_SUPPORT)
   kI18NExtension,
 #endif
   kCompressedStartupDataCount
 };
 
+
 int V8::GetCompressedStartupDataCount() {
 #ifdef COMPRESS_STARTUP_DATA_BZ2
   return kCompressedStartupDataCount;
 #else
   return 0;
 #endif
 }
 
 
 void V8::GetCompressedStartupData(StartupData* compressed_data) {
@@ skipping 249 matching lines @@
 
 void V8::ClearWeak(i::Object** obj) {
   i::GlobalHandles::ClearWeakness(obj);
 }
 
 
 void V8::DisposeGlobal(i::Object** obj) {
   i::GlobalHandles::Destroy(obj);
 }
 
+
 // --- H a n d l e s ---
 
 
 HandleScope::HandleScope() {
   Initialize(reinterpret_cast<Isolate*>(i::Isolate::Current()));
 }
 
 
 HandleScope::HandleScope(Isolate* isolate) {
   Initialize(isolate);
@@ skipping 3732 matching lines @@
 
 
 bool String::IsOneByte() const {
   i::Handle<i::String> str = Utils::OpenHandle(this);
   if (IsDeadCheck(str->GetIsolate(), "v8::String::IsOneByte()")) {
     return false;
   }
   return str->HasOnlyOneByteChars();
 }
 
+
 // Helpers for ContainsOnlyOneByteHelper
 template<size_t size> struct OneByteMask;
 template<> struct OneByteMask<4> {
   static const uint32_t value = 0xFF00FF00;
 };
 template<> struct OneByteMask<8> {
   static const uint64_t value = V8_2PART_UINT64_C(0xFF00FF00, FF00FF00);
 };
 static const uintptr_t kOneByteMask = OneByteMask<sizeof(uintptr_t)>::value;
 static const uintptr_t kAlignmentMask = sizeof(uintptr_t) - 1;
 static inline bool Unaligned(const uint16_t* chars) {
   return reinterpret_cast<const uintptr_t>(chars) & kAlignmentMask;
 }
+
+
 static inline const uint16_t* Align(const uint16_t* chars) {
   return reinterpret_cast<uint16_t*>(
     reinterpret_cast<uintptr_t>(chars) & ~kAlignmentMask);
 }
 
 class ContainsOnlyOneByteHelper {
  public:
   ContainsOnlyOneByteHelper() : is_one_byte_(true) {}
   bool Check(i::String* string) {
     i::ConsString* cons_string = i::String::VisitFlat(this, string, 0);
@@ skipping 1826 matching lines @@
   has_pending_exception = result.is_null();
   EXCEPTION_BAILOUT_CHECK(isolate, Local<Object>());
   return Utils::ToLocal(result);
 }
 
 
 bool v8::ArrayBuffer::IsExternal() const {
   return Utils::OpenHandle(this)->is_external();
 }
 
+
 v8::ArrayBuffer::Contents v8::ArrayBuffer::Externalize() {
   i::Handle<i::JSArrayBuffer> obj = Utils::OpenHandle(this);
   ApiCheck(!obj->is_external(),
             "v8::ArrayBuffer::Externalize",
             "ArrayBuffer already externalized");
   obj->set_is_external(true);
   size_t byte_length = static_cast<size_t>(obj->byte_length()->Number());
   Contents contents;
   contents.data_ = obj->backing_store();
   contents.byte_length_ = byte_length;
@@ skipping 280 matching lines @@
   i::Handle<i::Object> result = internal_isolate->factory()->NewNumber(value);
   return Utils::IntegerToLocal(result);
 }
 
 
 #ifdef DEBUG
 v8::AssertNoGCScope::AssertNoGCScope(v8::Isolate* isolate) {
   disallow_heap_allocation_ = new i::DisallowHeapAllocation();
 }
 
+
 v8::AssertNoGCScope::~AssertNoGCScope() {
   delete static_cast<i::DisallowHeapAllocation*>(disallow_heap_allocation_);
 }
 #endif
 
 
 void V8::IgnoreOutOfMemoryException() {
   EnterIsolateIfNeeded()->set_ignore_out_of_memory(true);
 }
 
@@ skipping 43 matching lines @@
       options);
 }
 
 
 void V8::SetCounterFunction(CounterLookupCallback callback) {
   i::Isolate* isolate = EnterIsolateIfNeeded();
   if (IsDeadCheck(isolate, "v8::V8::SetCounterFunction()")) return;
   isolate->stats_table()->SetCounterFunction(callback);
 }
 
+
 void V8::SetCreateHistogramFunction(CreateHistogramCallback callback) {
   i::Isolate* isolate = EnterIsolateIfNeeded();
   if (IsDeadCheck(isolate, "v8::V8::SetCreateHistogramFunction()")) return;
   isolate->stats_table()->SetCreateHistogramFunction(callback);
   isolate->InitializeLoggingAndCounters();
   isolate->counters()->ResetHistograms();
 }
 
+
 void V8::SetAddHistogramSampleFunction(AddHistogramSampleCallback callback) {
   i::Isolate* isolate = EnterIsolateIfNeeded();
   if (IsDeadCheck(isolate, "v8::V8::SetAddHistogramSampleFunction()")) return;
   isolate->stats_table()->
       SetAddHistogramSampleFunction(callback);
 }
 
 void V8::SetFailedAccessCheckCallbackFunction(
       FailedAccessCheckCallback callback) {
   i::Isolate* isolate = i::Isolate::Current();
@@ skipping 327 matching lines @@
   length_ = str->Length();
   str_ = i::NewArray<uint16_t>(length_ + 1);
   str->Write(str_);
 }
 
 
 String::Value::~Value() {
   i::DeleteArray(str_);
 }
 
+
 Local<Value> Exception::RangeError(v8::Handle<v8::String> raw_message) {
   i::Isolate* isolate = i::Isolate::Current();
   LOG_API(isolate, "RangeError");
   ON_BAILOUT(isolate, "v8::Exception::RangeError()", return Local<Value>());
   ENTER_V8(isolate);
   i::Object* error;
   {
     i::HandleScope scope(isolate);
     i::Handle<i::String> message = Utils::OpenHandle(*raw_message);
     i::Handle<i::Object> result = isolate->factory()->NewRangeError(message);
     error = *result;
   }
   i::Handle<i::Object> result(error, isolate);
   return Utils::ToLocal(result);
 }
 
+
 Local<Value> Exception::ReferenceError(v8::Handle<v8::String> raw_message) {
   i::Isolate* isolate = i::Isolate::Current();
   LOG_API(isolate, "ReferenceError");
   ON_BAILOUT(isolate, "v8::Exception::ReferenceError()", return Local<Value>());
   ENTER_V8(isolate);
   i::Object* error;
   {
     i::HandleScope scope(isolate);
     i::Handle<i::String> message = Utils::OpenHandle(*raw_message);
     i::Handle<i::Object> result =
         isolate->factory()->NewReferenceError(message);
     error = *result;
   }
   i::Handle<i::Object> result(error, isolate);
   return Utils::ToLocal(result);
 }
 
+
 Local<Value> Exception::SyntaxError(v8::Handle<v8::String> raw_message) {
   i::Isolate* isolate = i::Isolate::Current();
   LOG_API(isolate, "SyntaxError");
   ON_BAILOUT(isolate, "v8::Exception::SyntaxError()", return Local<Value>());
   ENTER_V8(isolate);
   i::Object* error;
   {
     i::HandleScope scope(isolate);
     i::Handle<i::String> message = Utils::OpenHandle(*raw_message);
     i::Handle<i::Object> result = isolate->factory()->NewSyntaxError(message);
     error = *result;
   }
   i::Handle<i::Object> result(error, isolate);
   return Utils::ToLocal(result);
 }
 
+
 Local<Value> Exception::TypeError(v8::Handle<v8::String> raw_message) {
   i::Isolate* isolate = i::Isolate::Current();
   LOG_API(isolate, "TypeError");
   ON_BAILOUT(isolate, "v8::Exception::TypeError()", return Local<Value>());
   ENTER_V8(isolate);
   i::Object* error;
   {
     i::HandleScope scope(isolate);
     i::Handle<i::String> message = Utils::OpenHandle(*raw_message);
     i::Handle<i::Object> result = isolate->factory()->NewTypeError(message);
     error = *result;
   }
   i::Handle<i::Object> result(error, isolate);
   return Utils::ToLocal(result);
 }
 
+
 Local<Value> Exception::Error(v8::Handle<v8::String> raw_message) {
   i::Isolate* isolate = i::Isolate::Current();
   LOG_API(isolate, "Error");
   ON_BAILOUT(isolate, "v8::Exception::Error()", return Local<Value>());
   ENTER_V8(isolate);
   i::Object* error;
   {
     i::HandleScope scope(isolate);
     i::Handle<i::String> message = Utils::OpenHandle(*raw_message);
     i::Handle<i::Object> result = isolate->factory()->NewError(message);
@@ skipping 730 matching lines @@
 
 
 v8::Testing::StressType internal::Testing::stress_type_ =
     v8::Testing::kStressTypeOpt;
 
 
 void Testing::SetStressRunType(Testing::StressType type) {
   internal::Testing::set_stress_type(type);
 }
 
+
 int Testing::GetStressRuns() {
   if (internal::FLAG_stress_runs != 0) return internal::FLAG_stress_runs;
 #ifdef DEBUG
   // In debug mode the code runs much slower so stressing will only make two
   // runs.
   return 2;
 #else
   return 5;
 #endif
 }
@@ skipping 236 matching lines @@
   Isolate* isolate = reinterpret_cast<Isolate*>(info.GetIsolate());
   Address callback_address =
       reinterpret_cast<Address>(reinterpret_cast<intptr_t>(callback));
   VMState<EXTERNAL> state(isolate);
   ExternalCallbackScope call_scope(isolate, callback_address);
   return callback(info);
 }
 
 
 } }  // namespace v8::internal