brotli 0.1.0 → 0.1.1

data/vendor/brotli/enc/streams.cc

@@ -1,17 +1,9 @@
-// Copyright 2009 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
+/* Copyright 2009 Google Inc. All Rights Reserved.
+
+   Distributed under MIT license.
+   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+*/
+
 // Convience routines to make Brotli I/O classes from some memory containers and
 // files.
 
@@ -23,12 +15,12 @@
 
 namespace brotli {
 
-BrotliMemOut::BrotliMemOut(void* buf, int len)
+BrotliMemOut::BrotliMemOut(void* buf, size_t len)
     : buf_(buf),
       len_(len),
       pos_(0) {}
 
-void BrotliMemOut::Reset(void* buf, int len) {
+void BrotliMemOut::Reset(void* buf, size_t len) {
   buf_ = buf;
   len_ = len;
   pos_ = 0;
@@ -44,13 +36,13 @@ bool BrotliMemOut::Write(const void *buf, size_t n) {
   return true;
 }
 
-BrotliStringOut::BrotliStringOut(std::string* buf, int max_size)
+BrotliStringOut::BrotliStringOut(std::string* buf, size_t max_size)
     : buf_(buf),
       max_size_(max_size) {
   assert(buf->empty());
 }
 
-void BrotliStringOut::Reset(std::string* buf, int max_size) {
+void BrotliStringOut::Reset(std::string* buf, size_t max_size) {
   buf_ = buf;
   max_size_ = max_size;
 }
@@ -63,12 +55,12 @@ bool BrotliStringOut::Write(const void *buf, size_t n) {
   return true;
 }
 
-BrotliMemIn::BrotliMemIn(const void* buf, int len)
+BrotliMemIn::BrotliMemIn(const void* buf, size_t len)
     : buf_(buf),
       len_(len),
       pos_(0) {}
 
-void BrotliMemIn::Reset(const void* buf, int len) {
+void BrotliMemIn::Reset(const void* buf, size_t len) {
   buf_ = buf;
   len_ = len;
   pos_ = 0;
@@ -89,18 +81,14 @@ const void* BrotliMemIn::Read(size_t n, size_t* output) {
 
 BrotliFileIn::BrotliFileIn(FILE* f, size_t max_read_size)
     : f_(f),
-      buf_(malloc(max_read_size)),
-      buf_size_(max_read_size) {}
+      buf_(new char[max_read_size]),
+      buf_size_(max_read_size) { }
 
 BrotliFileIn::~BrotliFileIn() {
-  if (buf_) free(buf_);
+  delete[] buf_;
 }
 
 const void* BrotliFileIn::Read(size_t n, size_t* bytes_read) {
-  if (buf_ == NULL) {
-    *bytes_read = 0;
-    return NULL;
-  }
   if (n > buf_size_) {
     n = buf_size_;
   } else if (n == 0) {
@@ -123,5 +111,4 @@ bool BrotliFileOut::Write(const void* buf, size_t n) {
   return true;
 }
 
-
 }  // namespace brotli

data/vendor/brotli/enc/streams.h

@@ -1,25 +1,18 @@
-// Copyright 2009 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
+/* Copyright 2009 Google Inc. All Rights Reserved.
+
+   Distributed under MIT license.
+   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+*/
+
 // Input and output classes for streaming brotli compression.
 
 #ifndef BROTLI_ENC_STREAMS_H_
 #define BROTLI_ENC_STREAMS_H_
 
-#include <stddef.h>
 #include <stdio.h>
 #include <string>
+#include "./port.h"
+#include "./types.h"
 
 namespace brotli {
 
@@ -49,37 +42,37 @@ class BrotliOut {
 // Adapter class to make BrotliIn objects from raw memory.
 class BrotliMemIn : public BrotliIn {
  public:
-  BrotliMemIn(const void* buf, int len);
+  BrotliMemIn(const void* buf, size_t len);
 
-  void Reset(const void* buf, int len);
+  void Reset(const void* buf, size_t len);
 
   // returns the amount of data consumed
-  int position() const { return pos_; }
+  size_t position() const { return pos_; }
 
-  const void* Read(size_t n, size_t* OUTPUT) override;
+  const void* Read(size_t n, size_t* OUTPUT);
 
  private:
   const void* buf_;  // start of input buffer
-  int len_;  // length of input
-  int pos_;  // current read position within input
+  size_t len_;  // length of input
+  size_t pos_;  // current read position within input
 };
 
 // Adapter class to make BrotliOut objects from raw memory.
 class BrotliMemOut : public BrotliOut {
  public:
-  BrotliMemOut(void* buf, int len);
+  BrotliMemOut(void* buf, size_t len);
 
-  void Reset(void* buf, int len);
+  void Reset(void* buf, size_t len);
 
   // returns the amount of data written
-  int position() const { return pos_; }
+  size_t position() const { return pos_; }
 
-  bool Write(const void* buf, size_t n) override;
+  bool Write(const void* buf, size_t n);
 
  private:
   void* buf_;  // start of output buffer
-  int len_;  // length of output
-  int pos_;  // current write position within output
+  size_t len_;  // length of output
+  size_t pos_;  // current write position within output
 };
 
 // Adapter class to make BrotliOut objects from a string.
@@ -88,15 +81,15 @@ class BrotliStringOut : public BrotliOut {
   // Create a writer that appends its data to buf.
   // buf->size() will grow to at most max_size
   // buf is expected to be empty when constructing BrotliStringOut.
-  BrotliStringOut(std::string* buf, int max_size);
+  BrotliStringOut(std::string* buf, size_t max_size);
 
-  void Reset(std::string* buf, int max_len);
+  void Reset(std::string* buf, size_t max_len);
 
-  bool Write(const void* buf, size_t n) override;
+  bool Write(const void* buf, size_t n);
 
  private:
   std::string* buf_;  // start of output buffer
-  int max_size_;  // max length of output
+  size_t max_size_;  // max length of output
 };
 
 // Adapter class to make BrotliIn object from a file.
@@ -105,11 +98,11 @@ class BrotliFileIn : public BrotliIn {
   BrotliFileIn(FILE* f, size_t max_read_size);
   ~BrotliFileIn();
 
-  const void* Read(size_t n, size_t* bytes_read) override;
+  const void* Read(size_t n, size_t* bytes_read);
 
  private:
   FILE* f_;
-  void* buf_;
+  char* buf_;
   size_t buf_size_;
 };
 
@@ -118,12 +111,11 @@ class BrotliFileOut : public BrotliOut {
  public:
   explicit BrotliFileOut(FILE* f);
 
-  bool Write(const void* buf, size_t n) override;
+  bool Write(const void* buf, size_t n);
  private:
   FILE* f_;
 };
 
-
 }  // namespace brotli
 
 #endif  // BROTLI_ENC_STREAMS_H_

data/vendor/brotli/enc/transform.h

@@ -1,17 +1,9 @@
-// Copyright 2010 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
+/* Copyright 2010 Google Inc. All Rights Reserved.
+
+   Distributed under MIT license.
+   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+*/
+
 // Transformations on dictionary words.
 
 #ifndef BROTLI_ENC_TRANSFORM_H_
@@ -44,7 +36,7 @@ enum WordTransformType {
   kOmitFirst6     = 17,
   kOmitFirst7     = 18,
   kOmitFirst8     = 19,
-  kOmitFirst9     = 20,
+  kOmitFirst9     = 20
 };
 
 struct Transform {
@@ -177,7 +169,8 @@ static const Transform kTransforms[] = {
      {        " ", kUppercaseFirst, "='"         },
 };
 
-static const int kNumTransforms = sizeof(kTransforms) / sizeof(kTransforms[0]);
+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

data/vendor/brotli/enc/types.h

@@ -0,0 +1,27 @@
+/* Copyright 2013 Google Inc. All Rights Reserved.
+
+   Distributed under MIT license.
+   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+*/
+
+/* Common types */
+
+#ifndef BROTLI_ENC_TYPES_H_
+#define BROTLI_ENC_TYPES_H_
+
+#include <stddef.h>  /* for size_t */
+
+#if defined(_MSC_VER) && (_MSC_VER < 1600)
+typedef __int8 int8_t;
+typedef unsigned __int8 uint8_t;
+typedef __int16 int16_t;
+typedef unsigned __int16 uint16_t;
+typedef __int32 int32_t;
+typedef unsigned __int32 uint32_t;
+typedef unsigned __int64 uint64_t;
+typedef __int64 int64_t;
+#else
+#include <stdint.h>
+#endif  /* defined(_MSC_VER) && (_MSC_VER < 1600) */
+
+#endif  /* BROTLI_ENC_TYPES_H_ */

data/vendor/brotli/enc/utf8_util.cc

@@ -0,0 +1,82 @@
+/* Copyright 2013 Google Inc. All Rights Reserved.
+
+   Distributed under MIT license.
+   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+*/
+
+// Heuristics for deciding about the UTF8-ness of strings.
+
+#include "./utf8_util.h"
+
+#include "./types.h"
+
+namespace brotli {
+
+namespace {
+
+int ParseAsUTF8(int* symbol, const uint8_t* input, size_t size) {
+  // ASCII
+  if ((input[0] & 0x80) == 0) {
+    *symbol = input[0];
+    if (*symbol > 0) {
+      return 1;
+    }
+  }
+  // 2-byte UTF8
+  if (size > 1u &&
+      (input[0] & 0xe0) == 0xc0 &&
+      (input[1] & 0xc0) == 0x80) {
+    *symbol = (((input[0] & 0x1f) << 6) |
+               (input[1] & 0x3f));
+    if (*symbol > 0x7f) {
+      return 2;
+    }
+  }
+  // 3-byte UFT8
+  if (size > 2u &&
+      (input[0] & 0xf0) == 0xe0 &&
+      (input[1] & 0xc0) == 0x80 &&
+      (input[2] & 0xc0) == 0x80) {
+    *symbol = (((input[0] & 0x0f) << 12) |
+               ((input[1] & 0x3f) << 6) |
+               (input[2] & 0x3f));
+    if (*symbol > 0x7ff) {
+      return 3;
+    }
+  }
+  // 4-byte UFT8
+  if (size > 3u &&
+      (input[0] & 0xf8) == 0xf0 &&
+      (input[1] & 0xc0) == 0x80 &&
+      (input[2] & 0xc0) == 0x80 &&
+      (input[3] & 0xc0) == 0x80) {
+    *symbol = (((input[0] & 0x07) << 18) |
+               ((input[1] & 0x3f) << 12) |
+               ((input[2] & 0x3f) << 6) |
+               (input[3] & 0x3f));
+    if (*symbol > 0xffff && *symbol <= 0x10ffff) {
+      return 4;
+    }
+  }
+  // Not UTF8, emit a special symbol above the UTF8-code space
+  *symbol = 0x110000 | input[0];
+  return 1;
+}
+
+}  // namespace
+
+// Returns true if at least min_fraction of the data is UTF8-encoded.
+bool IsMostlyUTF8(const uint8_t* data, const size_t pos, const size_t mask,
+                  const size_t length, const double min_fraction) {
+  size_t size_utf8 = 0;
+  size_t i = 0;
+  while (i < length) {
+    int symbol;
+    int bytes_read = ParseAsUTF8(&symbol, &data[(pos + i) & mask], length - i);
+    i += bytes_read;
+    if (symbol < 0x110000) size_utf8 += bytes_read;
+  }
+  return size_utf8 > min_fraction * static_cast<double>(length);
+}
+
+}  // namespace brotli

data/vendor/brotli/enc/utf8_util.h

@@ -0,0 +1,25 @@
+/* Copyright 2013 Google Inc. All Rights Reserved.
+
+   Distributed under MIT license.
+   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+*/
+
+// Heuristics for deciding about the UTF8-ness of strings.
+
+#ifndef BROTLI_ENC_UTF8_UTIL_H_
+#define BROTLI_ENC_UTF8_UTIL_H_
+
+#include "./types.h"
+
+namespace brotli {
+
+static const double kMinUTF8Ratio = 0.75;
+
+// Returns true if at least min_fraction of the bytes between pos and
+// pos + length in the (data, mask) ringbuffer is UTF8-encoded.
+bool IsMostlyUTF8(const uint8_t* data, const size_t pos, const size_t mask,
+                  const size_t length, const double min_fraction);
+
+}  // namespace brotli
+
+#endif  // BROTLI_ENC_UTF8_UTIL_H_

data/vendor/brotli/enc/write_bits.h

@@ -1,27 +1,19 @@
-// Copyright 2010 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
+/* Copyright 2010 Google Inc. All Rights Reserved.
+
+   Distributed under MIT license.
+   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+*/
+
 // Write bits into a byte array.
 
 #ifndef BROTLI_ENC_WRITE_BITS_H_
 #define BROTLI_ENC_WRITE_BITS_H_
 
 #include <assert.h>
-#include <stdint.h>
 #include <stdio.h>
 
 #include "./port.h"
+#include "./types.h"
 
 namespace brotli {
 
@@ -49,7 +41,8 @@ inline void WriteBits(int n_bits,
 #ifdef BIT_WRITER_DEBUG
   printf("WriteBits  %2d  0x%016llx  %10d\n", n_bits, bits, *pos);
 #endif
-  assert(bits < 1ULL << n_bits);
+  assert((bits >> n_bits) == 0);
+  assert(n_bits <= 56);
 #ifdef IS_LITTLE_ENDIAN
   // This branch of the code can write up to 56 bits at a time,
   // 7 bits are lost by being perhaps already in *p and at least
@@ -66,12 +59,12 @@ inline void WriteBits(int n_bits,
   uint8_t *array_pos = &array[*pos >> 3];
   const int bits_reserved_in_first_byte = (*pos & 7);
   bits <<= bits_reserved_in_first_byte;
-  *array_pos++ |= bits;
+  *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;
        bits_left_to_write -= 8) {
     bits >>= 8;
-    *array_pos++ = bits;
+    *array_pos++ = static_cast<uint8_t>(bits);
   }
   *array_pos = 0;
   *pos += n_bits;

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brotli
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - miyucy
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-09-24 00:00:00.000000000 Z
+date: 2015-12-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -96,6 +96,7 @@ files:
 - vendor/brotli/dec/context.h
 - vendor/brotli/dec/decode.c
 - vendor/brotli/dec/decode.h
+- vendor/brotli/dec/dictionary.c
 - vendor/brotli/dec/dictionary.h
 - vendor/brotli/dec/huffman.c
 - vendor/brotli/dec/huffman.h
@@ -118,6 +119,7 @@ files:
 - vendor/brotli/enc/cluster.h
 - vendor/brotli/enc/command.h
 - vendor/brotli/enc/context.h
+- vendor/brotli/enc/dictionary.cc
 - vendor/brotli/enc/dictionary.h
 - vendor/brotli/enc/dictionary_hash.h
 - vendor/brotli/enc/encode.cc
@@ -144,6 +146,9 @@ files:
 - vendor/brotli/enc/streams.cc
 - vendor/brotli/enc/streams.h
 - vendor/brotli/enc/transform.h
+- vendor/brotli/enc/types.h
+- vendor/brotli/enc/utf8_util.cc
+- vendor/brotli/enc/utf8_util.h
 - vendor/brotli/enc/write_bits.h
 homepage: https://github.com/miyucy/brotli
 licenses: []