clang-format runtime/vm

runtime/vm/zone.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/zone.h"
 
 #include "platform/assert.h"
 #include "platform/utils.h"
 #include "vm/flags.h"
 #include "vm/handles_impl.h"
@@ skipping 89 matching lines @@
 void Zone::DeleteAll() {
   // Traverse the chained list of segments, zapping (in debug mode)
   // and freeing every zone segment.
   if (head_ != NULL) {
     Segment::DeleteSegmentList(head_);
   }
   if (large_segments_ != NULL) {
     Segment::DeleteSegmentList(large_segments_);
   }
 
-  // Reset zone state.
+// Reset zone state.
 #ifdef DEBUG
   memset(initial_buffer_.pointer(), kZapDeletedByte, initial_buffer_.size());
 #endif
   position_ = initial_buffer_.start();
   limit_ = initial_buffer_.end();
   head_ = NULL;
   large_segments_ = NULL;
   previous_ = NULL;
   handles_.Reset();
 }
@@ skipping 19 matching lines @@
   ASSERT(size >= 0);
   if (FLAG_trace_zones) {
     OS::PrintErr("*** Expanding zone 0x%" Px "\n",
                  reinterpret_cast<intptr_t>(this));
     DumpZoneSizes();
   }
   // Make sure the requested size is already properly aligned and that
   // there isn't enough room in the Zone to satisfy the request.
   ASSERT(Utils::IsAligned(size, kAlignment));
   intptr_t free_size = (limit_ - position_);
-  ASSERT(free_size <  size);
+  ASSERT(free_size < size);
 
   // First check to see if we should just chain it as a large segment.
-  intptr_t max_size = Utils::RoundDown(kSegmentSize - sizeof(Segment),
-                                       kAlignment);
+  intptr_t max_size =
+      Utils::RoundDown(kSegmentSize - sizeof(Segment), kAlignment);
   ASSERT(max_size > 0);
   if (size > max_size) {
     return AllocateLargeSegment(size);
   }
 
   // Allocate another segment and chain it up.
   head_ = Segment::New(kSegmentSize, head_);
 
   // Recompute 'position' and 'limit' based on the new head segment.
   uword result = Utils::RoundUp(head_->start(), kAlignment);
   position_ = result + size;
   limit_ = head_->end();
   ASSERT(position_ <= limit_);
   return result;
 }
 
 
 uword Zone::AllocateLargeSegment(intptr_t size) {
   ASSERT(size >= 0);
   // Make sure the requested size is already properly aligned and that
   // there isn't enough room in the Zone to satisfy the request.
   ASSERT(Utils::IsAligned(size, kAlignment));
   intptr_t free_size = (limit_ - position_);
-  ASSERT(free_size <  size);
+  ASSERT(free_size < size);
 
   // Create a new large segment and chain it up.
   ASSERT(Utils::IsAligned(sizeof(Segment), kAlignment));
   size += sizeof(Segment);  // Account for book keeping fields in size.
   large_segments_ = Segment::New(size, large_segments_);
 
   uword result = Utils::RoundUp(large_segments_->start(), kAlignment);
   return result;
 }
 
@@ skipping 34 matching lines @@
   strncpy(&copy[a_len], b, b_len);
   return copy;
 }
 
 
 void Zone::DumpZoneSizes() {
   intptr_t size = 0;
   for (Segment* s = large_segments_; s != NULL; s = s->next()) {
     size += s->size();
   }
-  OS::PrintErr("***   Zone(0x%" Px ") size in bytes,"
+  OS::PrintErr("***   Zone(0x%" Px
+               ") size in bytes,"
                " Total = %" Pd " Large Segments = %" Pd "\n",
                reinterpret_cast<intptr_t>(this), SizeInBytes(), size);
 }
 
 
 void Zone::VisitObjectPointers(ObjectPointerVisitor* visitor) {
   Zone* zone = this;
   while (zone != NULL) {
     zone->handles()->VisitObjectPointers(visitor);
     zone = zone->previous_;
@@ skipping 30 matching lines @@
   ASSERT(thread()->zone() == &zone_);
   thread()->set_zone(zone_.previous_);
   if (FLAG_trace_zones) {
     OS::PrintErr("*** Deleting Stack zone 0x%" Px "(0x%" Px ")\n",
                  reinterpret_cast<intptr_t>(this),
                  reinterpret_cast<intptr_t>(&zone_));
   }
 }
 
 }  // namespace dart