Code changes to get the code to compile under GCC....

courgette/streams.cc

 // Copyright (c) 2009 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Streams classes.
 //
 // These memory-resident streams are used for serializing data into a sequential
 // region of memory.
 //
 // Streams are divided into SourceStreams for reading and SinkStreams for
 // writing.  Streams are aggregated into Sets which allows several streams to be
 // used at once.  Example: we can write A1, B1, A2, B2 but achieve the memory
 // layout A1 A2 B1 B2 by writing 'A's to one stream and 'B's to another.
 //
 // The aggregated streams are important to Courgette's compression efficiency,
 // we use it to cluster similar kinds of data which helps to generate longer
 // common subsequences and repeated sequences.
 
 #include "courgette/streams.h"
 
-#include <io.h>
 #include <memory.h>
 
 #include "base/basictypes.h"
 
 namespace courgette {
 
 // Update this version number if the serialization format of a StreamSet
 // changes.
 static const unsigned int kStreamsSerializationFormatVersion = 20090218;
 
@@ skipping 216 matching lines @@
   size_t accumulated_length = 0;
 
   for (size_t i = 0; i < count_; ++i) {
     finger = Varint::Parse32WithLimit(finger, end, &lengths[i]);
     if (finger == NULL)
       return false;
     accumulated_length += lengths[i];
   }
 
   // Remaining bytes should add up to sum of lengths.
-  if (end - finger != accumulated_length)
+  if (static_cast<size_t>(end - finger) != accumulated_length)
     return false;
 
   accumulated_length = finger - start;
   for (size_t i = 0; i < count_; ++i) {
     stream(i)->Init(start + accumulated_length, lengths[i]);
     accumulated_length += lengths[i];
   }
 
   return true;
 }
@@ skipping 59 matching lines @@
 bool SinkStreamSet::CopyTo(SinkStream *combined_stream) {
   SinkStream header;
   CopyHeaderTo(&header);
   combined_stream->Append(&header);
   for (size_t i = 0; i < count_; ++i) {
     combined_stream->Append(stream(i));
   }
   return true;
 }
 
-namespace {
-bool Write(int file_descriptor, SinkStream* sink) {
-  size_t length = sink->Length();
-  const void *buffer = sink->Buffer();
-  int bytes_written = _write(file_descriptor, buffer, length);
-  return bytes_written == length;
-}
-}
-
-bool SinkStreamSet::CopyToFileDescriptor(int file_descriptor) {
-  SinkStream header;
-  CopyHeaderTo(&header);
-  if (!Write(file_descriptor, &header))
-    return false;
-  for (size_t i = 0; i < count_; ++i) {
-    if (!Write(file_descriptor, stream(i)))
-      return false;
-  }
-  return true;
-}
-
 bool SinkStreamSet::WriteSet(SinkStreamSet* set) {
   uint32 lengths[kMaxStreams];
   // 'stream_count' includes all non-empty streams and all empty stream numbered
   // lower than a non-empty stream.
   size_t stream_count = 0;
   for (size_t i = 0; i < kMaxStreams; ++i) {
     SinkStream* stream = set->stream(i);
     lengths[i] = stream->Length();
     if (lengths[i] > 0)
       stream_count = i + 1;
   }
 
   SinkStream* control_stream = this->stream(0);
   control_stream->WriteVarint32(stream_count);
   for (size_t i = 0; i < stream_count; ++i) {
     control_stream->WriteVarint32(lengths[i]);
   }
 
   for (size_t i = 0; i < stream_count; ++i) {
     this->stream(i)->Append(set->stream(i));
   }
   return true;
 }
 
 }  // namespace