Fix GCC 4.7 warnings, which are related to char being signed in GCC

src/mksnapshot.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 69 matching lines @@
   uint32_t max_counters_;
   uint32_t max_name_size_;
   uint32_t counters_in_use_;
   Counter counters_[kMaxCounters];
 };
 
 
 class Compressor {
  public:
   virtual ~Compressor() {}
-  virtual bool Compress(i::Vector<char> input) = 0;
-  virtual i::Vector<char>* output() = 0;
+  virtual bool Compress(i::Vector<unsigned char> input) = 0;
+  virtual i::Vector<unsigned char>* output() = 0;
 };
 
 
 class PartialSnapshotSink : public i::SnapshotByteSink {
  public:
   PartialSnapshotSink() : data_(), raw_size_(-1) { }
   virtual ~PartialSnapshotSink() { data_.Free(); }
   virtual void Put(int byte, const char* description) {
     data_.Add(byte);
   }
   virtual int Position() { return data_.length(); }
   void Print(FILE* fp) {
     int length = Position();
     for (int j = 0; j < length; j++) {
       if ((j & 0x1f) == 0x1f) {
         fprintf(fp, "\n");
       }
       if (j != 0) {
         fprintf(fp, ",");
       }
       fprintf(fp, "%d", at(j));

[Vyacheslav Egorov (Chromium), 2011/12/12 18:06:17]

Instead of using unsigned char you can probably just add a cast from char to
unsigned char here. This will be a smaller yet more correct change (as it
conveys our intent directly --- we want all printed values to be positive).

What do you think?

[Tobias Burnus, 2011/12/12 21:54:00]

I agree that the patch will be shorter. I am not sure that it is more correct.
With the current patch, no cast is needed which I regard as more correct than
adding a cast. However, I am open for either solution.

     }
   }
-  char at(int i) { return data_[i]; }
+  unsigned char at(int i) { return data_[i]; }
   bool Compress(Compressor* compressor) {
     ASSERT_EQ(-1, raw_size_);
     raw_size_ = data_.length();
     if (!compressor->Compress(data_.ToVector())) return false;
     data_.Clear();
     data_.AddAll(*compressor->output());
     return true;
   }
   int raw_size() { return raw_size_; }
 
  private:
-  i::List<char> data_;
+  i::List<unsigned char> data_;
   int raw_size_;
 };
 
 
 class CppByteSink : public PartialSnapshotSink {
  public:
   explicit CppByteSink(const char* snapshot_file) {
     fp_ = i::OS::FOpen(snapshot_file, "wb");
     if (fp_ == NULL) {
       i::PrintF("Unable to write to snapshot file \"%s\"\n", snapshot_file);
@@ skipping 87 matching lines @@
 };
 
 
 #ifdef COMPRESS_STARTUP_DATA_BZ2
 class BZip2Compressor : public Compressor {
  public:
   BZip2Compressor() : output_(NULL) {}
   virtual ~BZip2Compressor() {
     delete output_;
   }
-  virtual bool Compress(i::Vector<char> input) {
+  virtual bool Compress(i::Vector<unsigned char> input) {
     delete output_;
-    output_ = new i::ScopedVector<char>((input.length() * 101) / 100 + 1000);
+    output_ = new i::ScopedVector<unsigned char>((input.length() * 101) / 100

[Vyacheslav Egorov (Chromium), 2011/12/12 18:06:17]

Usually we are leaving operation on the previous line.

You can break the line after >( if + does not fit.

+                                                 + 1000);
     unsigned int output_length_ = output_->length();
     int result = BZ2_bzBuffToBuffCompress(output_->start(), &output_length_,
                                           input.start(), input.length(),
                                           9, 1, 0);
     if (result == BZ_OK) {
       output_->Truncate(output_length_);
       return true;
     } else {
       fprintf(stderr, "bzlib error code: %d\n", result);
       return false;
     }
   }
-  virtual i::Vector<char>* output() { return output_; }
+  virtual i::Vector<unsigned char>* output() { return output_; }
 
  private:
-  i::ScopedVector<char>* output_;
+  i::ScopedVector<unsigned char>* output_;
 };
 
 
 class BZip2Decompressor : public StartupDataDecompressor {
  public:
   virtual ~BZip2Decompressor() { }
 
  protected:
-  virtual int DecompressData(char* raw_data,
+  virtual int DecompressData(unsigned char* raw_data,
                              int* raw_data_size,
                              const char* compressed_data,
                              int compressed_data_size) {
     ASSERT_EQ(StartupData::kBZip2,
               V8::GetCompressedStartupDataAlgorithm());
     unsigned int decompressed_size = *raw_data_size;
     int result =
         BZ2_bzBuffToBuffDecompress(raw_data,
                                    &decompressed_size,
-                                   const_cast<char*>(compressed_data),
+                                   const_cast<unsigned char*>(compressed_data),
                                    compressed_data_size,
                                    0, 1);
     if (result == BZ_OK) {
       *raw_data_size = decompressed_size;
     }
     return result;
   }
 };
 #endif
 
@@ skipping 56 matching lines @@
   sink.WriteSpaceUsed(
       partial_ser.CurrentAllocationAddress(i::NEW_SPACE),
       partial_ser.CurrentAllocationAddress(i::OLD_POINTER_SPACE),
       partial_ser.CurrentAllocationAddress(i::OLD_DATA_SPACE),
       partial_ser.CurrentAllocationAddress(i::CODE_SPACE),
       partial_ser.CurrentAllocationAddress(i::MAP_SPACE),
       partial_ser.CurrentAllocationAddress(i::CELL_SPACE),
       partial_ser.CurrentAllocationAddress(i::LO_SPACE));
   return 0;
 }