Change type of snapshot from char array to byte array to avoid portability pr...

src/serialize.cc

 // Copyright 2006-2008 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 668 matching lines @@
 // Implementation of Serializer
 
 
 // Helper class to write the bytes of the serialized heap.
 
 class SnapshotWriter {
  public:
   SnapshotWriter() {
     len_ = 0;
     max_ = 8 << 10;  // 8K initial size
-    str_ = NewArray<char>(max_);
+    str_ = NewArray<byte>(max_);
   }
 
   ~SnapshotWriter() {
     DeleteArray(str_);
   }
 
-  void GetString(char** str, int* len) {
-    *str = NewArray<char>(len_);
+  void GetBytes(byte** str, int* len) {
+    *str = NewArray<byte>(len_);
     memcpy(*str, str_, len_);
     *len = len_;
   }
 
   void Reserve(int bytes, int pos);
 
   void PutC(char c) {
     InsertC(c, len_);
   }
 
@@ skipping 27 matching lines @@
     return pos + size;
   }
 
   int InsertString(const char* s, int pos);
 
   int length() { return len_; }
 
   Address position() { return reinterpret_cast<Address>(&str_[len_]); }
 
  private:
-  char* str_;  // the snapshot
+  byte* str_;  // the snapshot
   int len_;   // the current length of str_
   int max_;   // the allocated size of str_
 };
 
 
 void SnapshotWriter::Reserve(int bytes, int pos) {
   CHECK(0 <= pos && pos <= len_);
   while (len_ + bytes >= max_) {
     max_ *= 2;
-    char* old = str_;
-    str_ = NewArray<char>(max_);
+    byte* old = str_;
+    str_ = NewArray<byte>(max_);
     memcpy(str_, old, len_);
     DeleteArray(old);
   }
   if (pos < len_) {
-    char* old = str_;
-    str_ = NewArray<char>(max_);
+    byte* old = str_;
+    str_ = NewArray<byte>(max_);
     memcpy(str_, old, pos);
     memcpy(str_ + pos + bytes, old + pos, len_ - pos);
     DeleteArray(old);
   }
 }
 
 int SnapshotWriter::InsertString(const char* s, int pos) {
   int size = strlen(s);
   pos = InsertC('[', pos);
   pos = InsertInt(size, pos);
@@ skipping 149 matching lines @@
   InitializeAllocators();
   reference_encoder_ = new ExternalReferenceEncoder();
   PutHeader();
   Heap::IterateRoots(this);
   PutLog();
   PutContextStack();
   disable();
 }
 
 
-void Serializer::Finalize(char** str, int* len) {
-  writer_->GetString(str, len);
+void Serializer::Finalize(byte** str, int* len) {
+  writer_->GetBytes(str, len);
 }
 
 
 // Serialize objects by writing them into the stream.
 
 void Serializer::VisitPointers(Object** start, Object** end) {
   bool root = root_;
   root_ = false;
   for (Object** p = start; p < end; ++p) {
     bool serialized;
@@ skipping 229 matching lines @@
 }
 
 
 //------------------------------------------------------------------------------
 // Implementation of Deserializer
 
 
 static const int kInitArraySize = 32;
 
 
-Deserializer::Deserializer(const char* str, int len)
+Deserializer::Deserializer(const byte* str, int len)
   : reader_(str, len),
     map_pages_(kInitArraySize),
     old_pointer_pages_(kInitArraySize),
     old_data_pages_(kInitArraySize),
     code_pages_(kInitArraySize),
     large_objects_(kInitArraySize),
     global_handles_(4) {
   root_ = true;
   roots_ = 0;
   objects_ = 0;
@@ skipping 325 matching lines @@
         ASSERT(index < large_objects_.length());
       }
       return large_objects_[index];  // s.page_offset() is ignored.
   }
   UNREACHABLE();
   return NULL;
 }
 
 
 } }  // namespace v8::internal