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

src/serialize.h

 // 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 117 matching lines @@
   Serializer();
 
   virtual ~Serializer();
 
   // Serialize the current state of the heap. This operation destroys the
   // heap contents and the contents of the roots into the heap.
   void Serialize();
 
   // Returns the serialized buffer. Ownership is transferred to the
   // caller. Only the destructor and getters may be called after this call.
-  void Finalize(char** str, int* len);
+  void Finalize(byte** str, int* len);
 
   int roots() { return roots_; }
   int objects() { return objects_; }
 
 #ifdef DEBUG
   // insert "tag" into the serialized stream
   virtual void Synchronize(const char* tag);
 #endif
 
   static bool enabled() { return serialization_enabled_; }
@@ skipping 55 matching lines @@
 
   HashMap saved_addresses_;
 
   DISALLOW_COPY_AND_ASSIGN(Serializer);
 };
 
 // Helper class to read the bytes of the serialized heap.
 
 class SnapshotReader {
  public:
-  SnapshotReader(const char* str, int len): str_(str), end_(str + len) {}
+  SnapshotReader(const byte* str, int len): str_(str), end_(str + len) {}
 
   void ExpectC(char expected) {
     int c = GetC();
     USE(c);
     ASSERT(c == expected);
   }
 
   int GetC() {
     if (str_ >= end_) return EOF;
     return *str_++;
@@ skipping 15 matching lines @@
     ExpectC('[');
     int size = GetInt();
     ExpectC(']');
     char* s = NewArray<char>(size + 1);
     GetBytes(reinterpret_cast<Address>(s), size);
     s[size] = 0;
     return s;
   }
 
  private:
-  const char* str_;
-  const char* end_;
+  const byte* str_;
+  const byte* end_;
 };
 
 
 // A Deserializer reads a snapshot and reconstructs the Object graph it defines.
 
 class Deserializer: public ObjectVisitor {
  public:
   // Create a deserializer. The snapshot is held in str and has size len.
-  Deserializer(const char* str, int len);
+  Deserializer(const byte* str, int len);
 
   virtual ~Deserializer();
 
   // Read the flags from the header of the file, and set those that
   // should be inherited from the snapshot.
   void GetFlags();
 
   // Read saved profiling information from the file and log it if required.
   void GetLog();
 
@@ skipping 54 matching lines @@
 #ifdef DEBUG
   bool expect_debug_information_;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(Deserializer);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_SERIALIZE_H_