VM: Re-format to use at most one newline between functions

runtime/vm/snapshot.h

 // 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.
 
 #ifndef RUNTIME_VM_SNAPSHOT_H_
 #define RUNTIME_VM_SNAPSHOT_H_
 
 #include "platform/assert.h"
 #include "vm/allocation.h"
 #include "vm/bitfield.h"
@@ skipping 103 matching lines @@
   kInlined = 0x1,
   kObjectId = 0x3,
 };
 static const int8_t kHeaderTagBits = 2;
 static const int8_t kObjectIdBits = (kBitsPerInt32 - (kHeaderTagBits + 1));
 static const intptr_t kMaxObjectId = (kMaxUint32 >> (kHeaderTagBits + 1));
 static const bool kAsReference = true;
 static const bool kAsInlinedObject = false;
 static const intptr_t kInvalidPatchIndex = -1;
 
-
 class SerializedHeaderTag
     : public BitField<intptr_t, enum SerializedHeaderType, 0, kHeaderTagBits> {
 };
 
-
 class SerializedHeaderData
     : public BitField<intptr_t, intptr_t, kHeaderTagBits, kObjectIdBits> {};
 
-
 enum DeserializeState {
   kIsDeserialized = 0,
   kIsNotDeserialized = 1,
 };
 
-
 enum SerializeState {
   kIsSerialized = 0,
   kIsNotSerialized = 1,
 };
 
-
 #define HEAP_SPACE(kind) (kind == Snapshot::kMessage) ? Heap::kNew : Heap::kOld
 
-
 // Structure capturing the raw snapshot.
 //
 // TODO(turnidge): Remove this class once the snapshot does not have a
 // header anymore.  This is pending on making the embedder pass in the
 // length of their snapshot.
 class Snapshot {
  public:
   enum Kind {
     // N.B. The order of these values must be preserved to give proper error
     // messages for old snapshots.
@@ skipping 42 matching lines @@
 
   // The following fields are potentially unaligned.
   int64_t unaligned_length_;  // Stream length.
   int64_t unaligned_kind_;    // Kind of snapshot.
 
   // Variable length data follows here.
 
   DISALLOW_COPY_AND_ASSIGN(Snapshot);
 };
 
-
 class Image : ValueObject {
  public:
   explicit Image(const void* raw_memory) : raw_memory_(raw_memory) {
     ASSERT(Utils::IsAligned(raw_memory, OS::kMaxPreferredCodeAlignment));
   }
 
   void* object_start() {
     return reinterpret_cast<void*>(reinterpret_cast<uword>(raw_memory_) +
                                    kHeaderSize);
   }
 
   uword object_size() {
     uword snapshot_size = *reinterpret_cast<const uword*>(raw_memory_);
     return snapshot_size - kHeaderSize;
   }
 
   static const intptr_t kHeaderSize = OS::kMaxPreferredCodeAlignment;
 
  private:
   const void* raw_memory_;  // The symbol kInstructionsSnapshot.
 
   DISALLOW_COPY_AND_ASSIGN(Image);
 };
 
-
 class BaseReader {
  public:
   BaseReader(const uint8_t* buffer, intptr_t size) : stream_(buffer, size) {}
   // Reads raw data (for basic types).
   // sizeof(T) must be in {1,2,4,8}.
   template <typename T>
   T Read() {
     return ReadStream::Raw<sizeof(T), T>::Read(&stream_);
   }
 
@@ skipping 38 matching lines @@
     ASSERT(IsVMIsolateObject(header_val));
     intptr_t value = -header_val;  // Header is negative for VM isolate objects.
     ASSERT(SerializedHeaderTag::decode(value) == kObjectId);
     return SerializedHeaderData::decode(value);
   }
 
  private:
   ReadStream stream_;  // input stream.
 };
 
-
 class BackRefNode : public ValueObject {
  public:
   BackRefNode(Object* reference,
               DeserializeState state,
               bool defer_canonicalization)
       : reference_(reference),
         state_(state),
         defer_canonicalization_(defer_canonicalization),
         patch_records_(NULL) {}
   Object* reference() const { return reference_; }
@@ skipping 20 matching lines @@
     }
   }
 
  private:
   Object* reference_;
   DeserializeState state_;
   bool defer_canonicalization_;
   ZoneGrowableArray<intptr_t>* patch_records_;
 };
 
-
 class ImageReader : public ZoneAllocated {
  public:
   ImageReader(const uint8_t* instructions_buffer, const uint8_t* data_buffer)
       : instructions_buffer_(instructions_buffer), data_buffer_(data_buffer) {
     ASSERT(instructions_buffer != NULL);
     ASSERT(data_buffer != NULL);
     ASSERT(Utils::IsAligned(reinterpret_cast<uword>(instructions_buffer),
                             OS::PreferredCodeAlignment()));
   }
 
   RawInstructions* GetInstructionsAt(int32_t offset);
   RawObject* GetObjectAt(int32_t offset);
 
  private:
   const uint8_t* instructions_buffer_;
   const uint8_t* data_buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageReader);
 };
 
-
 // Reads a snapshot into objects.
 class SnapshotReader : public BaseReader {
  public:
   Thread* thread() const { return thread_; }
   Zone* zone() const { return zone_; }
   Isolate* isolate() const { return thread_->isolate(); }
   Heap* heap() const { return heap_; }
   ObjectStore* object_store() const { return isolate()->object_store(); }
   ClassTable* class_table() const { return isolate()->class_table(); }
   PassiveObject* PassiveObjectHandle() { return &pobj_; }
@@ skipping 154 matching lines @@
   friend class Type;
   friend class TypeArguments;
   friend class TypeParameter;
   friend class TypeRef;
   friend class UnhandledException;
   friend class UnresolvedClass;
   friend class WeakProperty;
   DISALLOW_COPY_AND_ASSIGN(SnapshotReader);
 };
 
-
 class ScriptSnapshotReader : public SnapshotReader {
  public:
   ScriptSnapshotReader(const uint8_t* buffer, intptr_t size, Thread* thread);
   ~ScriptSnapshotReader();
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ScriptSnapshotReader);
 };
 
-
 class MessageSnapshotReader : public SnapshotReader {
  public:
   MessageSnapshotReader(const uint8_t* buffer, intptr_t size, Thread* thread);
   ~MessageSnapshotReader();
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MessageSnapshotReader);
 };
 
-
 class BaseWriter : public StackResource {
  public:
   // Size of the snapshot.
   intptr_t BytesWritten() const { return stream_.bytes_written(); }
 
   // Writes raw data to the stream (basic type).
   // sizeof(T) must be in {1,2,4,8}.
   template <typename T>
   void Write(T value) {
     WriteStream::Raw<sizeof(T), T>::Write(&stream_, value);
@@ skipping 75 matching lines @@
     stream_.set_buffer(NULL);
   }
 
  private:
   WriteStream stream_;
   DeAlloc dealloc_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(BaseWriter);
 };
 
-
 class ForwardList {
  public:
   explicit ForwardList(Thread* thread, intptr_t first_object_id);
   ~ForwardList();
 
   class Node : public ZoneAllocated {
    public:
     Node(const Object* obj, SerializeState state) : obj_(obj), state_(state) {}
     const Object* obj() const { return obj_; }
     bool is_serialized() const { return state_ == kIsSerialized; }
@@ skipping 34 matching lines @@
   Heap* heap() const { return thread_->isolate()->heap(); }
 
   Thread* thread_;
   const intptr_t first_object_id_;
   GrowableArray<Node*> nodes_;
   intptr_t first_unprocessed_object_id_;
 
   DISALLOW_COPY_AND_ASSIGN(ForwardList);
 };
 
-
 class ImageWriter : public ZoneAllocated {
  public:
   ImageWriter()
       : next_offset_(0), next_object_offset_(0), instructions_(), objects_() {
     ResetOffsets();
   }
   virtual ~ImageWriter() {}
 
   void ResetOffsets() {
     next_offset_ = Image::kHeaderSize;
@@ skipping 40 matching lines @@
 
   intptr_t next_offset_;
   intptr_t next_object_offset_;
   GrowableArray<InstructionsData> instructions_;
   GrowableArray<ObjectData> objects_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ImageWriter);
 };
 
-
 class AssemblyImageWriter : public ImageWriter {
  public:
   AssemblyImageWriter(uint8_t** assembly_buffer,
                       ReAlloc alloc,
                       intptr_t initial_size);
   void Finalize();
 
   virtual void WriteText(WriteStream* clustered_stream, bool vm);
   virtual intptr_t text_size() { return text_size_; }
 
@@ skipping 13 matching lines @@
     text_size_ += sizeof(value);
   }
 
   WriteStream assembly_stream_;
   intptr_t text_size_;
   Dwarf* dwarf_;
 
   DISALLOW_COPY_AND_ASSIGN(AssemblyImageWriter);
 };
 
-
 class BlobImageWriter : public ImageWriter {
  public:
   BlobImageWriter(uint8_t** instructions_blob_buffer,
                   ReAlloc alloc,
                   intptr_t initial_size)
       : ImageWriter(),
         instructions_blob_stream_(instructions_blob_buffer,
                                   alloc,
                                   initial_size) {}
 
   virtual void WriteText(WriteStream* clustered_stream, bool vm);
   virtual intptr_t text_size() { return InstructionsBlobSize(); }
 
   intptr_t InstructionsBlobSize() const {
     return instructions_blob_stream_.bytes_written();
   }
 
  private:
   WriteStream instructions_blob_stream_;
 
   DISALLOW_COPY_AND_ASSIGN(BlobImageWriter);
 };
 
-
 class SnapshotWriter : public BaseWriter {
  protected:
   SnapshotWriter(Thread* thread,
                  Snapshot::Kind kind,
                  uint8_t** buffer,
                  ReAlloc alloc,
                  DeAlloc dealloc,
                  intptr_t initial_size,
                  ForwardList* forward_list,
                  bool can_send_any_object);
@@ skipping 98 matching lines @@
   friend class RawTokenStream;
   friend class RawType;
   friend class RawTypeArguments;
   friend class RawTypeParameter;
   friend class RawUserTag;
   friend class SnapshotWriterVisitor;
   friend class WriteInlinedObjectVisitor;
   DISALLOW_COPY_AND_ASSIGN(SnapshotWriter);
 };
 
-
 class ScriptSnapshotWriter : public SnapshotWriter {
  public:
   static const intptr_t kInitialSize = 64 * KB;
   ScriptSnapshotWriter(uint8_t** buffer, ReAlloc alloc);
   ~ScriptSnapshotWriter() {}
 
   // Writes a partial snapshot of the script.
   void WriteScriptSnapshot(const Library& lib);
 
  private:
   ForwardList forward_list_;
 
   DISALLOW_COPY_AND_ASSIGN(ScriptSnapshotWriter);
 };
 
-
 class SerializedObjectBuffer : public StackResource {
  public:
   SerializedObjectBuffer()
       : StackResource(Thread::Current()),
         object_data_(NULL),
         object_length_(0) {}
 
   virtual ~SerializedObjectBuffer() { free(object_data_); }
 
   void StealBuffer(uint8_t** out_data, intptr_t* out_length) {
     *out_data = object_data_;
     *out_length = object_length_;
 
     object_data_ = NULL;
     object_length_ = 0;
   }
 
   uint8_t** data_buffer() { return &object_data_; }
   intptr_t* data_length() { return &object_length_; }
 
  private:
   uint8_t* object_data_;
   intptr_t object_length_;
 };
 
-
 class MessageWriter : public SnapshotWriter {
  public:
   static const intptr_t kInitialSize = 512;
   MessageWriter(uint8_t** buffer,
                 ReAlloc alloc,
                 DeAlloc dealloc,
                 bool can_send_any_object,
                 intptr_t* buffer_len = NULL);
   ~MessageWriter() {}
 
   void WriteMessage(const Object& obj);
 
  private:
   ForwardList forward_list_;
   intptr_t* buffer_len_;
 
   DISALLOW_COPY_AND_ASSIGN(MessageWriter);
 };
 
-
 // An object pointer visitor implementation which writes out
 // objects to a snap shot.
 class SnapshotWriterVisitor : public ObjectPointerVisitor {
  public:
   SnapshotWriterVisitor(SnapshotWriter* writer, bool as_references)
       : ObjectPointerVisitor(Isolate::Current()),
         writer_(writer),
         as_references_(as_references) {}
 
   virtual void VisitPointers(RawObject** first, RawObject** last);
 
  private:
   SnapshotWriter* writer_;
   bool as_references_;
 
   DISALLOW_COPY_AND_ASSIGN(SnapshotWriterVisitor);
 };
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_SNAPSHOT_H_