brotli 0.1.1 → 0.1.2

data/vendor/brotli/enc/ringbuffer.h

@@ -9,6 +9,7 @@
 #ifndef BROTLI_ENC_RINGBUFFER_H_
 #define BROTLI_ENC_RINGBUFFER_H_
 
+#include <cstdlib>  /* free, realloc */
 
 #include "./port.h"
 #include "./types.h"
@@ -16,30 +17,66 @@
 namespace brotli {
 
 // A RingBuffer(window_bits, tail_bits) contains `1 << window_bits' bytes of
-// data in a circular manner: writing a byte writes it to
-// `position() % (1 << window_bits)'. For convenience, the RingBuffer array
-// contains another copy of the first `1 << tail_bits' bytes:
-// buffer_[i] == buffer_[i + (1 << window_bits)] if i < (1 << tail_bits).
+// data in a circular manner: writing a byte writes it to:
+//   `position() % (1 << window_bits)'.
+// For convenience, the RingBuffer array contains another copy of the
+// first `1 << tail_bits' bytes:
+//   buffer_[i] == buffer_[i + (1 << window_bits)], if i < (1 << tail_bits),
+// and another copy of the last two bytes:
+//   buffer_[-1] == buffer_[(1 << window_bits) - 1] and
+//   buffer_[-2] == buffer_[(1 << window_bits) - 2].
 class RingBuffer {
  public:
   RingBuffer(int window_bits, int tail_bits)
-      : size_((size_t(1) << window_bits)),
-        mask_((size_t(1) << window_bits) - 1),
-        tail_size_(size_t(1) << tail_bits),
-        pos_(0) {
-    static const int kSlackForEightByteHashingEverywhere = 7;
-    const size_t buflen = size_ + tail_size_;
-    buffer_ = new uint8_t[buflen + kSlackForEightByteHashingEverywhere];
-    for (int i = 0; i < kSlackForEightByteHashingEverywhere; ++i) {
-      buffer_[buflen + i] = 0;
-    }
+      : size_(1u << window_bits),
+        mask_((1u << window_bits) - 1),
+        tail_size_(1u << tail_bits),
+        total_size_(size_ + tail_size_),
+        cur_size_(0),
+        pos_(0),
+        data_(0),
+        buffer_(0) {}
+
+  ~RingBuffer(void) {
+    free(data_);
   }
-  ~RingBuffer() {
-    delete [] buffer_;
+
+  // Allocates or re-allocates data_ to the given length + plus some slack
+  // region before and after. Fills the slack regions with zeros.
+  inline void InitBuffer(const uint32_t buflen) {
+    static const size_t kSlackForEightByteHashingEverywhere = 7;
+    cur_size_ = buflen;
+    data_ = static_cast<uint8_t*>(realloc(
+        data_, 2 + buflen + kSlackForEightByteHashingEverywhere));
+    buffer_ = data_ + 2;
+    buffer_[-2] = buffer_[-1] = 0;
+    for (size_t i = 0; i < kSlackForEightByteHashingEverywhere; ++i) {
+      buffer_[cur_size_ + i] = 0;
+    }
   }
 
   // Push bytes into the ring buffer.
   void Write(const uint8_t *bytes, size_t n) {
+    if (pos_ == 0 && n < tail_size_) {
+      // Special case for the first write: to process the first block, we don't
+      // need to allocate the whole ringbuffer and we don't need the tail
+      // either. However, we do this memory usage optimization only if the
+      // first write is less than the tail size, which is also the input block
+      // size, otherwise it is likely that other blocks will follow and we
+      // will need to reallocate to the full size anyway.
+      pos_ = static_cast<uint32_t>(n);
+      InitBuffer(pos_);
+      memcpy(buffer_, bytes, n);
+      return;
+    }
+    if (cur_size_ < total_size_) {
+      // Lazily allocate the full buffer.
+      InitBuffer(total_size_);
+      // Initialize the last two bytes to zero, so that we don't have to worry
+      // later when we copy the last two bytes to the first two positions.
+      buffer_[size_ - 2] = 0;
+      buffer_[size_ - 1] = 0;
+    }
     const size_t masked_pos = pos_ & mask_;
     // The length of the writes is limited so that we do not need to worry
     // about a write
@@ -51,26 +88,31 @@ class RingBuffer {
       // Split into two writes.
       // Copy into the end of the buffer, including the tail buffer.
       memcpy(&buffer_[masked_pos], bytes,
-             std::min(n, (size_ + tail_size_) - masked_pos));
+             std::min(n, total_size_ - masked_pos));
       // Copy into the beginning of the buffer
       memcpy(&buffer_[0], bytes + (size_ - masked_pos),
              n - (size_ - masked_pos));
     }
-    pos_ += n;
+    buffer_[-2] = buffer_[size_ - 2];
+    buffer_[-1] = buffer_[size_ - 1];
+    pos_ += static_cast<uint32_t>(n);
+    if (pos_ > (1u << 30)) {  /* Wrap, but preserve not-a-first-lap feature. */
+      pos_ = (pos_ & ((1u << 30) - 1)) | (1u << 30);
+    }
   }
 
-  void Reset() {
+  void Reset(void) {
     pos_ = 0;
   }
 
   // Logical cursor position in the ring buffer.
-  size_t position() const { return pos_; }
+  uint32_t position(void) const { return pos_; }
 
   // Bit mask for getting the physical position for a logical position.
-  size_t mask() const { return mask_; }
+  uint32_t mask(void) const { return mask_; }
 
-  uint8_t *start() { return &buffer_[0]; }
-  const uint8_t *start() const { return &buffer_[0]; }
+  uint8_t *start(void) { return &buffer_[0]; }
+  const uint8_t *start(void) const { return &buffer_[0]; }
 
  private:
   void WriteTail(const uint8_t *bytes, size_t n) {
@@ -83,14 +125,18 @@ class RingBuffer {
   }
 
   // Size of the ringbuffer is (1 << window_bits) + tail_size_.
-  const size_t size_;
-  const size_t mask_;
-  const size_t tail_size_;
+  const uint32_t size_;
+  const uint32_t mask_;
+  const uint32_t tail_size_;
+  const uint32_t total_size_;
 
+  uint32_t cur_size_;
   // Position to write in the ring buffer.
-  size_t pos_;
-  // The actual ring buffer containing the data and the copy of the beginning
-  // as a tail.
+  uint32_t pos_;
+  // The actual ring buffer containing the copy of the last two bytes, the data,
+  // and the copy of the beginning as a tail.
+  uint8_t *data_;
+  // The start of the ringbuffer.
   uint8_t *buffer_;
 };
 

data/vendor/brotli/enc/static_dict.cc

@@ -22,19 +22,24 @@ inline uint32_t Hash(const uint8_t *data) {
   return h >> (32 - kDictNumBits);
 }
 
-inline void AddMatch(int distance, int len, int len_code, int* matches) {
-  matches[len] = std::min(matches[len], (distance << 5) + len_code);
+inline void AddMatch(size_t distance, size_t len, size_t len_code,
+                     uint32_t* matches) {
+  uint32_t match = static_cast<uint32_t>((distance << 5) + len_code);
+  matches[len] = std::min(matches[len], match);
 }
 
-inline int DictMatchLength(const uint8_t* data, int id, int len, int maxlen) {
-  const int offset = kBrotliDictionaryOffsetsByLength[len] + len * id;
+inline size_t DictMatchLength(const uint8_t* data,
+                              size_t id,
+                              size_t len,
+                              size_t maxlen) {
+  const size_t offset = kBrotliDictionaryOffsetsByLength[len] + len * id;
   return FindMatchLengthWithLimit(&kBrotliDictionary[offset], data,
                                   std::min(len, maxlen));
 }
 
-inline bool IsMatch(DictWord w, const uint8_t* data, int max_length) {
+inline bool IsMatch(DictWord w, const uint8_t* data, size_t max_length) {
   if (w.len > max_length) return false;
-  const int offset = kBrotliDictionaryOffsetsByLength[w.len] + w.len * w.idx;
+  const size_t offset = kBrotliDictionaryOffsetsByLength[w.len] + w.len * w.idx;
   const uint8_t* dict = &kBrotliDictionary[offset];
   if (w.transform == 0) {
     // Match against base dictionary word.
@@ -44,12 +49,12 @@ inline bool IsMatch(DictWord w, const uint8_t* data, int max_length) {
     // Note that there are only ASCII uppercase words in the lookup table.
     return (dict[0] >= 'a' && dict[0] <= 'z' &&
             (dict[0] ^ 32) == data[0] &&
-            FindMatchLengthWithLimit(&dict[1], &data[1], w.len - 1) ==
-            w.len - 1);
+            FindMatchLengthWithLimit(&dict[1], &data[1], w.len - 1u) ==
+            w.len - 1u);
   } else {
     // Match against uppercase all transform.
     // Note that there are only ASCII uppercase words in the lookup table.
-    for (int i = 0; i < w.len; ++i) {
+    for (size_t i = 0; i < w.len; ++i) {
       if (dict[i] >= 'a' && dict[i] <= 'z') {
         if ((dict[i] ^ 32) != data[i]) return false;
       } else {
@@ -61,22 +66,22 @@ inline bool IsMatch(DictWord w, const uint8_t* data, int max_length) {
 }
 
 bool FindAllStaticDictionaryMatches(const uint8_t* data,
-                                    int min_length,
-                                    int max_length,
-                                    int* matches) {
+                                    size_t min_length,
+                                    size_t max_length,
+                                    uint32_t* matches) {
   bool found_match = false;
-  uint32_t key = Hash(data);
-  uint32_t bucket = kStaticDictionaryBuckets[key];
+  size_t key = Hash(data);
+  size_t bucket = kStaticDictionaryBuckets[key];
   if (bucket != 0) {
-    int num = bucket & 0xff;
-    int offset = bucket >> 8;
-    for (int i = 0; i < num; ++i) {
+    size_t num = bucket & 0xff;
+    size_t offset = bucket >> 8;
+    for (size_t i = 0; i < num; ++i) {
       const DictWord w = kStaticDictionaryWords[offset + i];
-      const int l = w.len;
-      const int n = 1 << kBrotliDictionarySizeBitsByLength[l];
-      const int id = w.idx;
+      const size_t l = w.len;
+      const size_t n = 1u << kBrotliDictionarySizeBitsByLength[l];
+      const size_t id = w.idx;
       if (w.transform == 0) {
-        const int matchlen = DictMatchLength(data, id, l, max_length);
+        const size_t matchlen = DictMatchLength(data, id, l, max_length);
         // Transform "" + kIdentity + ""
         if (matchlen == l) {
           AddMatch(id, l, l, matches);
@@ -93,9 +98,10 @@ bool FindAllStaticDictionaryMatches(const uint8_t* data,
           found_match = true;
         }
         // Transform "" + kOmitLastN + "" (N = 2 .. 9)
-        int minlen = std::max<int>(min_length, l - 9);
-        int maxlen = std::min<int>(matchlen, l - 2);
-        for (int len = minlen; len <= maxlen; ++len) {
+        size_t minlen = min_length;
+        if (l > 9) minlen = std::max(minlen, l - 9);
+        size_t maxlen = std::min(matchlen, l - 2);
+        for (size_t len = minlen; len <= maxlen; ++len) {
           AddMatch(id + kOmitLastNTransforms[l - len] * n, len, l, matches);
           found_match = true;
         }
@@ -250,8 +256,9 @@ bool FindAllStaticDictionaryMatches(const uint8_t* data,
           }
         }
       } else {
-        // Set t=0 for kUppercaseFirst and t=1 for kUppercaseAll transform.
-        const int t = w.transform - 10;
+        // Set t=false for kUppercaseFirst and
+        //     t=true otherwise (kUppercaseAll) transform.
+        const bool t = w.transform != kUppercaseFirst;
         if (!IsMatch(w, data, max_length)) {
           continue;
         }
@@ -299,13 +306,13 @@ bool FindAllStaticDictionaryMatches(const uint8_t* data,
     bool is_space = (data[0] == ' ');
     key = Hash(&data[1]);
     bucket = kStaticDictionaryBuckets[key];
-    int num = bucket & 0xff;
-    int offset = bucket >> 8;
-    for (int i = 0; i < num; ++i) {
+    size_t num = bucket & 0xff;
+    size_t offset = bucket >> 8;
+    for (size_t i = 0; i < num; ++i) {
       const DictWord w = kStaticDictionaryWords[offset + i];
-      const int l = w.len;
-      const int n = 1 << kBrotliDictionarySizeBitsByLength[l];
-      const int id = w.idx;
+      const size_t l = w.len;
+      const size_t n = 1u << kBrotliDictionarySizeBitsByLength[l];
+      const size_t id = w.idx;
       if (w.transform == 0) {
         if (!IsMatch(w, &data[1], max_length - 1)) {
           continue;
@@ -342,8 +349,9 @@ bool FindAllStaticDictionaryMatches(const uint8_t* data,
           }
         }
       } else if (is_space) {
-        // Set t=0 for kUppercaseFirst and t=1 for kUppercaseAll transform.
-        const int t = w.transform - 10;
+        // Set t=false for kUppercaseFirst and
+        //     t=true otherwise (kUppercaseAll) transform.
+        const bool t = w.transform != kUppercaseFirst;
         if (!IsMatch(w, &data[1], max_length - 1)) {
           continue;
         }
@@ -358,7 +366,7 @@ bool FindAllStaticDictionaryMatches(const uint8_t* data,
         if (s[0] == ' ') {
           AddMatch(id + (t ? 83 : 15) * n, l + 2, l, matches);
         } else if (s[0] == ',') {
-          if (t == 0) {
+          if (!t) {
             AddMatch(id + 109 * n, l + 2, l, matches);
         }
           if (s[1] == ' ') {
@@ -386,19 +394,19 @@ bool FindAllStaticDictionaryMatches(const uint8_t* data,
         (data[0] == 0xc2 && data[1] == 0xa0)) {
       key = Hash(&data[2]);
       bucket = kStaticDictionaryBuckets[key];
-      int num = bucket & 0xff;
-      int offset = bucket >> 8;
-      for (int i = 0; i < num; ++i) {
+      size_t num = bucket & 0xff;
+      size_t offset = bucket >> 8;
+      for (size_t i = 0; i < num; ++i) {
         const DictWord w = kStaticDictionaryWords[offset + i];
-        const int l = w.len;
-        const int n = 1 << kBrotliDictionarySizeBitsByLength[l];
-        const int id = w.idx;
+        const size_t l = w.len;
+        const size_t n = 1u << kBrotliDictionarySizeBitsByLength[l];
+        const size_t id = w.idx;
         if (w.transform == 0 && IsMatch(w, &data[2], max_length - 2)) {
           if (data[0] == 0xc2) {
             AddMatch(id + 102 * n, l + 2, l, matches);
             found_match = true;
           } else if (l + 2 < max_length && data[l + 2] == ' ') {
-            int t = data[0] == 'e' ? 18 : (data[0] == 's' ? 7 : 13);
+            size_t t = data[0] == 'e' ? 18 : (data[0] == 's' ? 7 : 13);
             AddMatch(id + t * n, l + 3, l, matches);
             found_match = true;
           }
@@ -414,13 +422,13 @@ bool FindAllStaticDictionaryMatches(const uint8_t* data,
          data[3] == 'm' && data[4] == '/')) {
       key = Hash(&data[5]);
       bucket = kStaticDictionaryBuckets[key];
-      int num = bucket & 0xff;
-      int offset = bucket >> 8;
-      for (int i = 0; i < num; ++i) {
+      size_t num = bucket & 0xff;
+      size_t offset = bucket >> 8;
+      for (size_t i = 0; i < num; ++i) {
         const DictWord w = kStaticDictionaryWords[offset + i];
-        const int l = w.len;
-        const int n = 1 << kBrotliDictionarySizeBitsByLength[l];
-        const int id = w.idx;
+        const size_t l = w.len;
+        const size_t n = 1u << kBrotliDictionarySizeBitsByLength[l];
+        const size_t id = w.idx;
         if (w.transform == 0 && IsMatch(w, &data[5], max_length - 5)) {
           AddMatch(id + (data[0] == ' ' ? 41 : 72) * n, l + 5, l, matches);
           found_match = true;

data/vendor/brotli/enc/static_dict.h

@@ -13,8 +13,8 @@
 
 namespace brotli {
 
-static const int kMaxDictionaryMatchLen = 37;
-static const int kInvalidMatch = 0xfffffff;
+static const size_t kMaxDictionaryMatchLen = 37;
+static const uint32_t kInvalidMatch = 0xfffffff;
 
 // Matches data against static dictionary words, and for each length l,
 // for which a match is found, updates matches[l] to be the minimum possible
@@ -23,9 +23,9 @@ static const int kInvalidMatch = 0xfffffff;
 //   matches array is at least kMaxDictionaryMatchLen + 1 long
 //   all elements are initialized to kInvalidMatch
 bool FindAllStaticDictionaryMatches(const uint8_t* data,
-                                    int min_length,
-                                    int max_length,
-                                    int* matches);
+                                    size_t min_length,
+                                    size_t max_length,
+                                    uint32_t* matches);
 
 }  // namespace brotli
 

data/vendor/brotli/enc/streams.cc

@@ -84,7 +84,7 @@ BrotliFileIn::BrotliFileIn(FILE* f, size_t max_read_size)
       buf_(new char[max_read_size]),
       buf_size_(max_read_size) { }
 
-BrotliFileIn::~BrotliFileIn() {
+BrotliFileIn::~BrotliFileIn(void) {
   delete[] buf_;
 }
 

data/vendor/brotli/enc/streams.h

@@ -19,7 +19,7 @@ namespace brotli {
 // Input interface for the compression routines.
 class BrotliIn {
  public:
-  virtual ~BrotliIn() {}
+  virtual ~BrotliIn(void) {}
 
   // Return a pointer to the next block of input of at most n bytes.
   // Return the actual length in *nread.
@@ -32,7 +32,7 @@ class BrotliIn {
 // Output interface for the compression routines.
 class BrotliOut {
  public:
-  virtual ~BrotliOut() {}
+  virtual ~BrotliOut(void) {}
 
   // Write n bytes of data from buf.
   // Return true if all written, false otherwise.
@@ -47,7 +47,7 @@ class BrotliMemIn : public BrotliIn {
   void Reset(const void* buf, size_t len);
 
   // returns the amount of data consumed
-  size_t position() const { return pos_; }
+  size_t position(void) const { return pos_; }
 
   const void* Read(size_t n, size_t* OUTPUT);
 
@@ -65,7 +65,7 @@ class BrotliMemOut : public BrotliOut {
   void Reset(void* buf, size_t len);
 
   // returns the amount of data written
-  size_t position() const { return pos_; }
+  size_t position(void) const { return pos_; }
 
   bool Write(const void* buf, size_t n);
 
@@ -96,7 +96,7 @@ class BrotliStringOut : public BrotliOut {
 class BrotliFileIn : public BrotliIn {
  public:
   BrotliFileIn(FILE* f, size_t max_read_size);
-  ~BrotliFileIn();
+  ~BrotliFileIn(void);
 
   const void* Read(size_t n, size_t* bytes_read);
 

data/vendor/brotli/enc/transform.h

@@ -172,15 +172,11 @@ static const Transform kTransforms[] = {
 static const size_t kNumTransforms =
     sizeof(kTransforms) / sizeof(kTransforms[0]);
 
-static const int kOmitFirstNTransforms[10] = {
-  0, 3, 11, 26, 34, 39, 40, 55, 0, 54
-};
-
-static const int kOmitLastNTransforms[10] = {
+static const size_t kOmitLastNTransforms[10] = {
   0, 12, 27, 23, 42, 63, 56, 48, 59, 64,
 };
 
-static int ToUpperCase(uint8_t *p, int len) {
+static size_t ToUpperCase(uint8_t *p, size_t len) {
   if (len == 1 || p[0] < 0xc0) {
     if (p[0] >= 'a' && p[0] <= 'z') {
       p[0] ^= 32;
@@ -198,41 +194,50 @@ static int ToUpperCase(uint8_t *p, int len) {
   return 3;
 }
 
-inline std::string ApplyTransform(
-    const Transform& t, const uint8_t* word, int len) {
-  std::string ret(t.prefix);
-  if (t.word_transform <= kOmitLast9) {
-    len -= t.word_transform;
+inline std::string TransformWord(
+    WordTransformType transform_type, const uint8_t* word, size_t len) {
+  if (transform_type <= kOmitLast9) {
+    if (len <= static_cast<size_t>(transform_type)) {
+      return std::string();
+    }
+    return std::string(word, word + len - transform_type);
   }
-  if (len > 0) {
-    if (t.word_transform >= kOmitFirst1) {
-      const int skip = t.word_transform - (kOmitFirst1 - 1);
-      if (len > skip) {
-        ret += std::string(word + skip, word + len);
-      }
-    } else {
-      ret += std::string(word, word + len);
-      uint8_t *uppercase = reinterpret_cast<uint8_t*>(&ret[ret.size() - len]);
-      if (t.word_transform == kUppercaseFirst) {
-        ToUpperCase(uppercase, len);
-      } else if (t.word_transform == kUppercaseAll) {
-        while (len > 0) {
-          int step = ToUpperCase(uppercase, len);
-          uppercase += step;
-          len -= step;
-        }
-      }
+
+  if (transform_type >= kOmitFirst1) {
+    const size_t skip = transform_type - (kOmitFirst1 - 1);
+    if (len <= skip) {
+      return std::string();
+    }
+    return std::string(word + skip, word + len);
+  }
+
+  std::string ret = std::string(word, word + len);
+  uint8_t *uppercase = reinterpret_cast<uint8_t*>(&ret[0]);
+  if (transform_type == kUppercaseFirst) {
+    ToUpperCase(uppercase, len);
+  } else if (transform_type == kUppercaseAll) {
+    size_t position = 0;
+    while (position < len) {
+      size_t step = ToUpperCase(uppercase, len - position);
+      uppercase += step;
+      position += step;
     }
   }
-  ret += std::string(t.suffix);
   return ret;
 }
 
-inline std::string GetTransformedDictionaryWord(int len_code, int word_id) {
-  int num_words = 1 << kBrotliDictionarySizeBitsByLength[len_code];
-  int offset = kBrotliDictionaryOffsetsByLength[len_code];
-  int t = word_id / num_words;
-  int word_idx = word_id % num_words;
+inline std::string ApplyTransform(
+    const Transform& t, const uint8_t* word, size_t len) {
+  return std::string(t.prefix) +
+      TransformWord(t.word_transform, word, len) + std::string(t.suffix);
+}
+
+inline std::string GetTransformedDictionaryWord(size_t len_code,
+                                                size_t word_id) {
+  size_t num_words = 1u << kBrotliDictionarySizeBitsByLength[len_code];
+  size_t offset = kBrotliDictionaryOffsetsByLength[len_code];
+  size_t t = word_id / num_words;
+  size_t word_idx = word_id % num_words;
   offset += len_code * word_idx;
   const uint8_t* word = &kBrotliDictionary[offset];
   return ApplyTransform(kTransforms[t], word, len_code);

data/vendor/brotli/enc/types.h

@@ -24,4 +24,6 @@ typedef __int64 int64_t;
 #include <stdint.h>
 #endif  /* defined(_MSC_VER) && (_MSC_VER < 1600) */
 
+#define MAKE_UINT64_T(high, low) ((((uint64_t)(high)) << 32) | low)
+
 #endif  /* BROTLI_ENC_TYPES_H_ */

data/vendor/brotli/enc/utf8_util.cc

@@ -14,7 +14,7 @@ namespace brotli {
 
 namespace {
 
-int ParseAsUTF8(int* symbol, const uint8_t* input, size_t size) {
+size_t ParseAsUTF8(int* symbol, const uint8_t* input, size_t size) {
   // ASCII
   if ((input[0] & 0x80) == 0) {
     *symbol = input[0];
@@ -72,7 +72,8 @@ bool IsMostlyUTF8(const uint8_t* data, const size_t pos, const size_t mask,
   size_t i = 0;
   while (i < length) {
     int symbol;
-    int bytes_read = ParseAsUTF8(&symbol, &data[(pos + i) & mask], length - i);
+    size_t bytes_read = ParseAsUTF8(
+        &symbol, &data[(pos + i) & mask], length - i);
     i += bytes_read;
     if (symbol < 0x110000) size_utf8 += bytes_read;
   }

data/vendor/brotli/enc/write_bits.h

@@ -34,9 +34,9 @@ namespace brotli {
 //
 // For n bits, we take the last 5 bits, OR that with high bits in BYTE-0,
 // and locate the rest in BYTE+1, BYTE+2, etc.
-inline void WriteBits(int n_bits,
+inline void WriteBits(size_t n_bits,
                       uint64_t bits,
-                      int * __restrict pos,
+                      size_t * __restrict pos,
                       uint8_t * __restrict array) {
 #ifdef BIT_WRITER_DEBUG
   printf("WriteBits  %2d  0x%016llx  %10d\n", n_bits, bits, *pos);
@@ -57,11 +57,11 @@ inline void WriteBits(int n_bits,
 #else
   // implicit & 0xff is assumed for uint8_t arithmetics
   uint8_t *array_pos = &array[*pos >> 3];
-  const int bits_reserved_in_first_byte = (*pos & 7);
+  const size_t bits_reserved_in_first_byte = (*pos & 7);
   bits <<= bits_reserved_in_first_byte;
   *array_pos++ |= static_cast<uint8_t>(bits);
-  for (int bits_left_to_write = n_bits - 8 + bits_reserved_in_first_byte;
-       bits_left_to_write >= 1;
+  for (size_t bits_left_to_write = n_bits + bits_reserved_in_first_byte;
+       bits_left_to_write >= 9;
        bits_left_to_write -= 8) {
     bits >>= 8;
     *array_pos++ = static_cast<uint8_t>(bits);
@@ -71,7 +71,7 @@ inline void WriteBits(int n_bits,
 #endif
 }
 
-inline void WriteBitsPrepareStorage(int pos, uint8_t *array) {
+inline void WriteBitsPrepareStorage(size_t pos, uint8_t *array) {
 #ifdef BIT_WRITER_DEBUG
   printf("WriteBitsPrepareStorage            %10d\n", pos);
 #endif

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brotli
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - miyucy
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-12-29 00:00:00.000000000 Z
+date: 2016-06-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -104,8 +104,6 @@ files:
 - vendor/brotli/dec/prefix.h
 - vendor/brotli/dec/state.c
 - vendor/brotli/dec/state.h
-- vendor/brotli/dec/streams.c
-- vendor/brotli/dec/streams.h
 - vendor/brotli/dec/transform.h
 - vendor/brotli/dec/types.h
 - vendor/brotli/enc/Makefile
@@ -118,6 +116,11 @@ files:
 - vendor/brotli/enc/brotli_bit_stream.h
 - vendor/brotli/enc/cluster.h
 - vendor/brotli/enc/command.h
+- vendor/brotli/enc/compress_fragment.cc
+- vendor/brotli/enc/compress_fragment.h
+- vendor/brotli/enc/compress_fragment_two_pass.cc
+- vendor/brotli/enc/compress_fragment_two_pass.h
+- vendor/brotli/enc/compressor.h
 - vendor/brotli/enc/context.h
 - vendor/brotli/enc/dictionary.cc
 - vendor/brotli/enc/dictionary.h
@@ -128,6 +131,7 @@ files:
 - vendor/brotli/enc/encode_parallel.h
 - vendor/brotli/enc/entropy_encode.cc
 - vendor/brotli/enc/entropy_encode.h
+- vendor/brotli/enc/entropy_encode_static.h
 - vendor/brotli/enc/fast_log.h
 - vendor/brotli/enc/find_match_length.h
 - vendor/brotli/enc/hash.h
@@ -169,7 +173,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.6.4
 signing_key: 
 specification_version: 4
 summary: Brotli compressor/decompressor