Prepare for writing token streams directly into a snapshot and reading it directly from the snapsho…

vm/datastream.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 VM_DATASTREAM_H_
 #define VM_DATASTREAM_H_
 
 #include "platform/assert.h"
+#include "platform/utils.h"
 #include "vm/allocation.h"
 #include "vm/globals.h"
 
 namespace dart {
 
 static const int8_t kDataBitsPerByte = 7;
 static const int8_t kByteMask = (1 << kDataBitsPerByte) - 1;
 static const int8_t kMaxUnsignedDataPerByte = kByteMask;
 static const int8_t kMinDataPerByte = -(1 << (kDataBitsPerByte - 1));
 static const int8_t kMaxDataPerByte = (~kMinDataPerByte & kByteMask);
@@ skipping 37 matching lines @@
 
   template<typename T>
   class Raw<8, T> {
    public:
     static T Read(ReadStream* st) {
       return bit_cast<T>(st->Read<int64_t>());
     }
   };
 
   void ReadBytes(uint8_t* addr, intptr_t len) {
-    ASSERT((current_ + len) < end_);
+    ASSERT((end_ - current_) >= len);
     memmove(addr, current_, len);
     current_ += len;
   }
 
  private:
   template<typename T>
   T Read() {
     uint8_t b = ReadByte();
     if (b > kMaxUnsignedDataPerByte) {
       return static_cast<T>(b) - kEndByteMarker;
@@ skipping 18 matching lines @@
   const uint8_t* current_;
   const uint8_t* end_;
 
   DISALLOW_COPY_AND_ASSIGN(ReadStream);
 };
 
 
 // Stream for writing various types into a buffer.
 class WriteStream : public ValueObject {
  public:
-  static const int kBufferIncrementSize = 64 * KB;
+  static const intptr_t kBufferIncrementSize = 64 * KB;
 
   WriteStream(uint8_t** buffer, ReAlloc alloc) :
       buffer_(buffer),
       end_(NULL),
       current_(NULL),
       current_size_(0),
       alloc_(alloc) {
     ASSERT(buffer != NULL);
     ASSERT(alloc != NULL);
     *buffer_ = reinterpret_cast<uint8_t*>(alloc_(NULL,
@@ skipping 38 matching lines @@
   };
 
   template<typename T>
   class Raw<8, T> {
    public:
     static void Write(WriteStream* st, T value) {
       st->Write<int64_t>(bit_cast<int64_t>(value));
     }
   };
 
+  void WriteBytes(const uint8_t* addr, intptr_t len) {
+    if ((end_ - current_) < len) {
+      Resize(len);
+    }
+    ASSERT((end_ - current_) >= len);
+    memmove(current_, addr, len);
+    current_ += len;
+  }
+
  private:
   template<typename T>
   void Write(T value) {
     T v = value;
     while (v < kMinDataPerByte ||
            v > kMaxDataPerByte) {
       WriteByte(static_cast<uint8_t>(v & kByteMask));
       v = v >> kDataBitsPerByte;
     }
     WriteByte(static_cast<uint8_t>(v + kEndByteMarker));
   }
 
   void WriteByte(uint8_t value) {
     if (current_ >= end_) {
-      intptr_t new_size = (current_size_ + kBufferIncrementSize);
-      *buffer_ = reinterpret_cast<uint8_t*>(alloc_(*buffer_,
-                                                   current_size_,
-                                                   new_size));
-      ASSERT(*buffer_ != NULL);
-      current_ = *buffer_ + current_size_;
-      current_size_ = new_size;
-      end_ = *buffer_ + new_size;
+      Resize(1);
     }
     ASSERT(current_ < end_);
     *current_++ = value;
   }
 
+  void Resize(intptr_t size_needed) {
+    intptr_t position = current_ - *buffer_;
+    intptr_t new_size = current_size_ +
+        Utils::RoundUp(size_needed, kBufferIncrementSize);
+    *buffer_ = reinterpret_cast<uint8_t*>(alloc_(*buffer_,
+                                                 current_size_,
+                                                 new_size));
+    ASSERT(*buffer_ != NULL);
+    current_ = *buffer_ + position;
+    current_size_ = new_size;
+    end_ = *buffer_ + new_size;
+    ASSERT(end_ > *buffer_);
+  }
+
  private:
   uint8_t** const buffer_;
   uint8_t* end_;
   uint8_t* current_;
   intptr_t current_size_;
   ReAlloc alloc_;
 
   DISALLOW_COPY_AND_ASSIGN(WriteStream);
 };
 
 }  // namespace dart
 
 #endif  // VM_DATASTREAM_H_