You are viewing a plain text version of this content. The canonical link for it is here.
Posted to dev@couchdb.apache.org by Benoit Chesneau <bc...@gmail.com> on 2014/03/13 14:08:43 UTC
Re: [3/3] couchdb commit: updated refs/heads/2200-feature-support-erlang-17.0
to 9a78372
there is couchdb-snappy. that just does that with our history :/
On Thu, Mar 13, 2014 at 2:01 PM, <dc...@apache.org> wrote:
> snappy: bump to 1.1.1
>
> - use same OTP aligned layout as original fdmanana/snappy/erlang-nif
>
>
> Project: http://git-wip-us.apache.org/repos/asf/couchdb/repo
> Commit: http://git-wip-us.apache.org/repos/asf/couchdb/commit/9a783720
> Tree: http://git-wip-us.apache.org/repos/asf/couchdb/tree/9a783720
> Diff: http://git-wip-us.apache.org/repos/asf/couchdb/diff/9a783720
>
> Branch: refs/heads/2200-feature-support-erlang-17.0
> Commit: 9a783720ed5f4ddbc5966ea7370a0c8f823461f4
> Parents: 1ee4aca
> Author: Dave Cottlehuber <dc...@apache.org>
> Authored: Thu Mar 13 11:36:39 2014 +0100
> Committer: Dave Cottlehuber <dc...@apache.org>
> Committed: Thu Mar 13 14:00:45 2014 +0100
>
> ----------------------------------------------------------------------
> .gitignore | 6 +-
> configure.ac | 8 +-
> src/snappy/Makefile.am | 56 +-
> src/snappy/c_src/erl_nif_compat.h | 129 ++
> src/snappy/c_src/snappy/AUTHORS | 1 +
> src/snappy/c_src/snappy/COPYING | 28 +
> src/snappy/c_src/snappy/NEWS | 46 +
> src/snappy/c_src/snappy/README | 135 +++
> src/snappy/c_src/snappy/config.h.in | 125 ++
> src/snappy/c_src/snappy/snappy-internal.h | 150 +++
> src/snappy/c_src/snappy/snappy-sinksource.cc | 72 ++
> src/snappy/c_src/snappy/snappy-sinksource.h | 136 +++
> .../c_src/snappy/snappy-stubs-internal.cc | 42 +
> src/snappy/c_src/snappy/snappy-stubs-internal.h | 477 ++++++++
> .../c_src/snappy/snappy-stubs-public.h.in | 85 ++
> src/snappy/c_src/snappy/snappy.cc | 1021 ++++++++++++++++
> src/snappy/c_src/snappy/snappy.h | 155 +++
> src/snappy/c_src/snappy_nif.cc | 265 +++++
> src/snappy/erl_nif_compat.h | 129 --
> src/snappy/google-snappy/AUTHORS | 1 -
> src/snappy/google-snappy/COPYING | 28 -
> src/snappy/google-snappy/config.h.in | 125 --
> src/snappy/google-snappy/snappy-internal.h | 150 ---
> src/snappy/google-snappy/snappy-sinksource.cc | 71 --
> src/snappy/google-snappy/snappy-sinksource.h | 137 ---
> .../google-snappy/snappy-stubs-internal.cc | 42 -
> .../google-snappy/snappy-stubs-internal.h | 571 ---------
> .../google-snappy/snappy-stubs-public.h.in | 85 --
> src/snappy/google-snappy/snappy.cc | 1111 ------------------
> src/snappy/google-snappy/snappy.h | 155 ---
> src/snappy/snappy.app.in | 12 -
> src/snappy/snappy.erl | 56 -
> src/snappy/snappy_nif.cc | 265 -----
> src/snappy/src/snappy.app.in | 12 +
> src/snappy/src/snappy.erl | 56 +
> src/snappy/test/snappy_tests.erl | 74 ++
> 36 files changed, 3044 insertions(+), 2973 deletions(-)
> ----------------------------------------------------------------------
>
>
> http://git-wip-us.apache.org/repos/asf/couchdb/blob/9a783720/.gitignore
> ----------------------------------------------------------------------
> diff --git a/.gitignore b/.gitignore
> index 5e4d220..9d47996 100644
> --- a/.gitignore
> +++ b/.gitignore
> @@ -119,9 +119,9 @@ src/mochiweb/mochiweb.app
> !src/my-first-couchdb-plugin/Makefile
> src/snappy/.deps/
> src/snappy/.libs/
> -src/snappy/google-snappy/.deps/
> -src/snappy/google-snappy/snappy-stubs-public.h
> -src/snappy/google-snappy/stamp-h2
> +src/snappy/c_src/snappy/.deps/
> +src/snappy/c_src/snappy/snappy-stubs-public.h
> +src/snappy/c_src/snappy/stamp-h2
> src/snappy/priv
> src/snappy/snappy.app
> stamp-h1
>
> http://git-wip-us.apache.org/repos/asf/couchdb/blob/9a783720/configure.ac
> ----------------------------------------------------------------------
> diff --git a/configure.ac b/configure.ac
> index 6a04f68..3ce0495 100644
> --- a/configure.ac
> +++ b/configure.ac
> @@ -22,7 +22,7 @@ AC_CONFIG_AUX_DIR([build-aux])
> AC_CONFIG_MACRO_DIR([m4])
>
> AC_CONFIG_HEADERS([config.h])
> -AC_CONFIG_HEADERS([src/snappy/google-snappy/config.h])
> +AC_CONFIG_HEADERS([src/snappy/c_src/snappy/config.h])
>
> AM_INIT_AUTOMAKE([1.6.3 foreign tar-ustar])
>
> @@ -39,8 +39,8 @@ PKG_PROG_PKG_CONFIG
>
> dnl Config for google snappy
> m4_define([snappy_major], [1])
> -m4_define([snappy_minor], [0])
> -m4_define([snappy_patchlevel], [5])
> +m4_define([snappy_minor], [1])
> +m4_define([snappy_patchlevel], [1])
>
> AC_PROG_CXX
> AC_LANG([C++])
> @@ -746,7 +746,7 @@ AC_CONFIG_FILES([src/etap/Makefile])
> AC_CONFIG_FILES([src/ibrowse/Makefile])
> AC_CONFIG_FILES([src/mochiweb/Makefile])
> AC_CONFIG_FILES([src/snappy/Makefile])
> -AC_CONFIG_FILES([src/snappy/google-snappy/snappy-stubs-public.h])
> +AC_CONFIG_FILES([src/snappy/c_src/snappy/snappy-stubs-public.h])
> AC_CONFIG_FILES([src/ejson/Makefile])
> AC_CONFIG_FILES([test/Makefile])
> AC_CONFIG_FILES([test/bench/Makefile])
>
> http://git-wip-us.apache.org/repos/asf/couchdb/blob/9a783720/src/snappy/Makefile.am
> ----------------------------------------------------------------------
> diff --git a/src/snappy/Makefile.am b/src/snappy/Makefile.am
> index ff75f07..b9fdd08 100644
> --- a/src/snappy/Makefile.am
> +++ b/src/snappy/Makefile.am
> @@ -10,56 +10,56 @@
> ## License for the specific language governing permissions and limitations under
> ## the License.
>
> -snappyebindir = $(localerlanglibdir)/snappy-1.0.5/ebin
> -snappyprivdir = $(localerlanglibdir)/snappy-1.0.5/priv
> +snappyebindir = $(localerlanglibdir)/snappy-1.1.1/ebin
> +snappyprivdir = $(localerlanglibdir)/snappy-1.1.1/priv
>
> snappy_cxx_srcs = \
> snappy_nif.cc \
> - google-snappy/snappy.cc \
> - google-snappy/snappy-sinksource.cc \
> - google-snappy/snappy-stubs-internal.cc
> + c_src/snappy/snappy.cc \
> + c_src/snappy/snappy-sinksource.cc \
> + c_src/snappy/snappy-stubs-internal.cc
>
> snappy_cxx_hdrs = \
> - erl_nif_compat.h \
> - google-snappy/snappy.h \
> - google-snappy/snappy-internal.h \
> - google-snappy/snappy-sinksource.h \
> - google-snappy/snappy-stubs-internal.h \
> - google-snappy/snappy-stubs-public.h.in
> + c_src/erl_nif_compat.h \
> + c_src/snappy/snappy.h \
> + c_src/snappy/snappy-internal.h \
> + c_src/snappy/snappy-sinksource.h \
> + c_src/snappy/snappy-stubs-internal.h \
> + c_src/snappy/snappy-stubs-public.h.in
>
> snappy_file_collection = \
> - snappy.app.in \
> - snappy.erl
> + snappy.app.in \
> + snappy.erl
>
> snappyebin_make_generated_file_list = \
> - snappy.app \
> - snappy.beam
> + snappy.app \
> + snappy.beam
>
> EXTRA_DIST = \
> - google-snappy/AUTHORS \
> - google-snappy/COPYING \
> + c_src/snappy/AUTHORS \
> + c_src/snappy/COPYING \
> $(snappy_cxx_hdrs) \
> - $(snappy_file_collection)
> + $(snappy_file_collection)
>
> CLEANFILES = \
> - $(snappyebin_make_generated_file_list) \
> + $(snappyebin_make_generated_file_list) \
> priv/snappy_nif.so
>
> snappyebin_DATA = \
> - $(snappyebin_make_generated_file_list)
> + $(snappyebin_make_generated_file_list)
>
> if USE_OTP_NIFS
> -snappypriv_LTLIBRARIES = snappy_nif.la
> -snappy_nif_la_SOURCES = $(snappy_cxx_srcs)
> -snappy_nif_la_CXXFLAGS = $(ERLANG_FLAGS)
> -snappy_nif_la_LDFLAGS = -module -avoid-version
> + snappypriv_LTLIBRARIES = snappy_nif.la
> + snappy_nif_la_SOURCES = $(snappy_cxx_srcs)
> + snappy_nif_la_CXXFLAGS = $(ERLANG_FLAGS)
> + snappy_nif_la_LDFLAGS = -module -avoid-version
>
> if WINDOWS
> -snappy_nif_la_LDFLAGS += -no-undefined
> -snappy_nif_la_CXXFLAGS += -EHsc -Ox
> -SNAPPY_SO_NAME = snappy_nif.dll
> + snappy_nif_la_LDFLAGS += -no-undefined
> + snappy_nif_la_CXXFLAGS += -EHsc -Ox
> + SNAPPY_SO_NAME = snappy_nif.dll
> else
> -SNAPPY_SO_NAME = snappy_nif.so
> + SNAPPY_SO_NAME = snappy_nif.so
> endif
>
> priv/$(SNAPPY_SO_NAME): snappy_nif.la
>
> http://git-wip-us.apache.org/repos/asf/couchdb/blob/9a783720/src/snappy/c_src/erl_nif_compat.h
> ----------------------------------------------------------------------
> diff --git a/src/snappy/c_src/erl_nif_compat.h b/src/snappy/c_src/erl_nif_compat.h
> new file mode 100644
> index 0000000..b8eb9b0
> --- /dev/null
> +++ b/src/snappy/c_src/erl_nif_compat.h
> @@ -0,0 +1,129 @@
> +/* Copyright (c) 2010-2011 Basho Technologies, Inc.
> + * With some minor modifications by Filipe David Manana
> + * <fd...@apache.org>
> + *
> + * This file is provided to you 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.
> +*/
> +
> +#ifndef ERL_NIF_COMPAT_H_
> +#define ERL_NIF_COMPAT_H_
> +
> +#ifdef __cplusplus
> +extern "C" {
> +#endif /* __cplusplus */
> +
> +#include "erl_nif.h"
> +
> +
> +#if ERL_NIF_MAJOR_VERSION == 0 && ERL_NIF_MINOR_VERSION == 1
> +#define OTP_R13B03
> +#elif ERL_NIF_MAJOR_VERSION == 1 && ERL_NIF_MINOR_VERSION == 0
> +#define OTP_R13B04
> +#elif ERL_NIF_MAJOR_VERSION == 2 && ERL_NIF_MINOR_VERSION == 0
> +#define OTP_R14A
> +#define OTP_R14B
> +#define OTP_R14B01
> +#elif ERL_NIF_MAJOR_VERSION == 2 && ERL_NIF_MINOR_VERSION == 1
> +#define OTP_R14B02
> +#endif
> +
> +
> +#ifdef OTP_R13B03
> +
> +#define enif_open_resource_type_compat enif_open_resource_type
> +#define enif_alloc_resource_compat enif_alloc_resource
> +#define enif_release_resource_compat enif_release_resource
> +#define enif_alloc_binary_compat enif_alloc_binary
> +#define enif_alloc_compat enif_alloc
> +#define enif_release_binary_compat enif_release_binary
> +#define enif_free_compat enif_free
> +#define enif_get_atom_compat enif_get_atom
> +#define enif_priv_data_compat enif_get_data
> +#define enif_make_uint_compat enif_make_ulong
> +
> +#define enif_make_existing_atom_compat(E, N, R, Enc) \
> + enif_make_existing_atom(E, N, R)
> +
> +#define enif_make_string_compat(E, B, Enc) \
> + enif_make_string(E, B)
> +
> +#endif /* R13B03 */
> +
> +
> +#ifdef OTP_R13B04
> +
> +#define enif_open_resource_type_compat enif_open_resource_type
> +#define enif_alloc_resource_compat enif_alloc_resource
> +#define enif_release_resource_compat enif_release_resource
> +#define enif_alloc_binary_compat enif_alloc_binary
> +#define enif_realloc_binary_compat enif_realloc_binary
> +#define enif_release_binary_compat enif_release_binary
> +#define enif_alloc_compat enif_alloc
> +#define enif_free_compat enif_free
> +#define enif_get_atom_compat enif_get_atom
> +#define enif_priv_data_compat enif_priv_data
> +#define enif_make_string_compat enif_make_string
> +#define enif_make_uint_compat enif_make_uint
> +
> +#define enif_make_existing_atom_compat(E, N, R, Enc) \
> + enif_make_existing_atom(E, N, R)
> +
> +
> +#endif /* R13B04 */
> +
> +
> +/* OTP R14A and future releases */
> +#if !defined(OTP_R13B03) && !defined(OTP_R13B04)
> +
> +#define enif_open_resource_type_compat(E, N, D, F, T) \
> + enif_open_resource_type(E, NULL, N, D, F, T)
> +
> +#define enif_alloc_resource_compat(E, T, S) \
> + enif_alloc_resource(T, S)
> +
> +#define enif_release_resource_compat(E, H) \
> + enif_release_resource(H)
> +
> +#define enif_alloc_binary_compat(E, S, B) \
> + enif_alloc_binary(S, B)
> +
> +#define enif_realloc_binary_compat(E, S, B) \
> + enif_realloc_binary(S, B)
> +
> +#define enif_release_binary_compat(E, B) \
> + enif_release_binary(B)
> +
> +#define enif_alloc_compat(E, S) \
> + enif_alloc(S)
> +
> +#define enif_free_compat(E, P) \
> + enif_free(P)
> +
> +#define enif_get_atom_compat(E, T, B, S) \
> + enif_get_atom(E, T, B, S, ERL_NIF_LATIN1)
> +
> +#define enif_priv_data_compat enif_priv_data
> +#define enif_make_string_compat enif_make_string
> +#define enif_make_existing_atom_compat enif_make_existing_atom
> +#define enif_make_uint_compat enif_make_uint
> +
> +#endif /* R14 and future releases */
> +
> +
> +#ifdef __cplusplus
> +}
> +#endif /* __cplusplus */
> +
> +#endif /* ERL_NIF_COMPAT_H_ */
>
> http://git-wip-us.apache.org/repos/asf/couchdb/blob/9a783720/src/snappy/c_src/snappy/AUTHORS
> ----------------------------------------------------------------------
> diff --git a/src/snappy/c_src/snappy/AUTHORS b/src/snappy/c_src/snappy/AUTHORS
> new file mode 100644
> index 0000000..4858b37
> --- /dev/null
> +++ b/src/snappy/c_src/snappy/AUTHORS
> @@ -0,0 +1 @@
> +opensource@google.com
>
> http://git-wip-us.apache.org/repos/asf/couchdb/blob/9a783720/src/snappy/c_src/snappy/COPYING
> ----------------------------------------------------------------------
> diff --git a/src/snappy/c_src/snappy/COPYING b/src/snappy/c_src/snappy/COPYING
> new file mode 100644
> index 0000000..8d6bd9f
> --- /dev/null
> +++ b/src/snappy/c_src/snappy/COPYING
> @@ -0,0 +1,28 @@
> +Copyright 2011, Google Inc.
> +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 with the
> +distribution.
> + * Neither the name of Google Inc. nor the names of its
> +contributors may be used to endorse or promote products derived from
> +this software without specific prior written permission.
> +
> +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
> +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
> +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
> +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
> +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
> +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
> +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
> +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
> +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
> +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
> +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>
> http://git-wip-us.apache.org/repos/asf/couchdb/blob/9a783720/src/snappy/c_src/snappy/NEWS
> ----------------------------------------------------------------------
> diff --git a/src/snappy/c_src/snappy/NEWS b/src/snappy/c_src/snappy/NEWS
> new file mode 100644
> index 0000000..d514787
> --- /dev/null
> +++ b/src/snappy/c_src/snappy/NEWS
> @@ -0,0 +1,46 @@
> +Snappy v1.0.3, June 2nd 2011:
> +
> + * Speeded up the decompressor somewhat; about 3-6% for Core 2,
> + 6-13% for Core i7, and 5-12% for Opteron (all in 64-bit mode).
> +
> + * Added compressed format documentation. This text is new,
> + but an earlier version from Zeev Tarantov was used as reference.
> +
> + * Only link snappy_unittest against -lz and other autodetected
> + libraries, not libsnappy.so (which doesn't need any such dependency).
> +
> + * Fixed some display issues in the microbenchmarks, one of which would
> + frequently make the test crash on GNU/Hurd.
> +
> +
> +Snappy v1.0.2, April 29th 2011:
> +
> + * Relicense to a BSD-type license.
> +
> + * Added C bindings, contributed by Martin Gieseking.
> +
> + * More Win32 fixes, in particular for MSVC.
> +
> + * Replace geo.protodata with a newer version.
> +
> + * Fix timing inaccuracies in the unit test when comparing Snappy
> + to other algorithms.
> +
> +
> +Snappy v1.0.1, March 25th 2011:
> +
> +This is a maintenance release, mostly containing minor fixes.
> +There is no new functionality. The most important fixes include:
> +
> + * The COPYING file and all licensing headers now correctly state that
> + Snappy is licensed under the Apache 2.0 license.
> +
> + * snappy_unittest should now compile natively under Windows,
> + as well as on embedded systems with no mmap().
> +
> + * Various autotools nits have been fixed.
> +
> +
> +Snappy v1.0, March 17th 2011:
> +
> + * Initial version.
>
> http://git-wip-us.apache.org/repos/asf/couchdb/blob/9a783720/src/snappy/c_src/snappy/README
> ----------------------------------------------------------------------
> diff --git a/src/snappy/c_src/snappy/README b/src/snappy/c_src/snappy/README
> new file mode 100644
> index 0000000..df8f0e1
> --- /dev/null
> +++ b/src/snappy/c_src/snappy/README
> @@ -0,0 +1,135 @@
> +Snappy, a fast compressor/decompressor.
> +
> +
> +Introduction
> +============
> +
> +Snappy is a compression/decompression library. It does not aim for maximum
> +compression, or compatibility with any other compression library; instead,
> +it aims for very high speeds and reasonable compression. For instance,
> +compared to the fastest mode of zlib, Snappy is an order of magnitude faster
> +for most inputs, but the resulting compressed files are anywhere from 20% to
> +100% bigger. (For more information, see "Performance", below.)
> +
> +Snappy has the following properties:
> +
> + * Fast: Compression speeds at 250 MB/sec and beyond, with no assembler code.
> + See "Performance" below.
> + * Stable: Over the last few years, Snappy has compressed and decompressed
> + petabytes of data in Google's production environment. The Snappy bitstream
> + format is stable and will not change between versions.
> + * Robust: The Snappy decompressor is designed not to crash in the face of
> + corrupted or malicious input.
> + * Free and open source software: Snappy is licensed under a BSD-type license.
> + For more information, see the included COPYING file.
> +
> +Snappy has previously been called "Zippy" in some Google presentations
> +and the like.
> +
> +
> +Performance
> +===========
> +
> +Snappy is intended to be fast. On a single core of a Core i7 processor
> +in 64-bit mode, it compresses at about 250 MB/sec or more and decompresses at
> +about 500 MB/sec or more. (These numbers are for the slowest inputs in our
> +benchmark suite; others are much faster.) In our tests, Snappy usually
> +is faster than algorithms in the same class (e.g. LZO, LZF, FastLZ, QuickLZ,
> +etc.) while achieving comparable compression ratios.
> +
> +Typical compression ratios (based on the benchmark suite) are about 1.5-1.7x
> +for plain text, about 2-4x for HTML, and of course 1.0x for JPEGs, PNGs and
> +other already-compressed data. Similar numbers for zlib in its fastest mode
> +are 2.6-2.8x, 3-7x and 1.0x, respectively. More sophisticated algorithms are
> +capable of achieving yet higher compression rates, although usually at the
> +expense of speed. Of course, compression ratio will vary significantly with
> +the input.
> +
> +Although Snappy should be fairly portable, it is primarily optimized
> +for 64-bit x86-compatible processors, and may run slower in other environments.
> +In particular:
> +
> + - Snappy uses 64-bit operations in several places to process more data at
> + once than would otherwise be possible.
> + - Snappy assumes unaligned 32- and 64-bit loads and stores are cheap.
> + On some platforms, these must be emulated with single-byte loads
> + and stores, which is much slower.
> + - Snappy assumes little-endian throughout, and needs to byte-swap data in
> + several places if running on a big-endian platform.
> +
> +Experience has shown that even heavily tuned code can be improved.
> +Performance optimizations, whether for 64-bit x86 or other platforms,
> +are of course most welcome; see "Contact", below.
> +
> +
> +Usage
> +=====
> +
> +Note that Snappy, both the implementation and the main interface,
> +is written in C++. However, several third-party bindings to other languages
> +are available; see the Google Code page at http://code.google.com/p/snappy/
> +for more information. Also, if you want to use Snappy from C code, you can
> +use the included C bindings in snappy-c.h.
> +
> +To use Snappy from your own C++ program, include the file "snappy.h" from
> +your calling file, and link against the compiled library.
> +
> +There are many ways to call Snappy, but the simplest possible is
> +
> + snappy::Compress(input, &output);
> +
> +and similarly
> +
> + snappy::Uncompress(input, &output);
> +
> +where "input" and "output" are both instances of std::string.
> +
> +There are other interfaces that are more flexible in various ways, including
> +support for custom (non-array) input sources. See the header file for more
> +information.
> +
> +
> +Tests and benchmarks
> +====================
> +
> +When you compile Snappy, snappy_unittest is compiled in addition to the
> +library itself. You do not need it to use the compressor from your own library,
> +but it contains several useful components for Snappy development.
> +
> +First of all, it contains unit tests, verifying correctness on your machine in
> +various scenarios. If you want to change or optimize Snappy, please run the
> +tests to verify you have not broken anything. Note that if you have the
> +Google Test library installed, unit test behavior (especially failures) will be
> +significantly more user-friendly. You can find Google Test at
> +
> + http://code.google.com/p/googletest/
> +
> +You probably also want the gflags library for handling of command-line flags;
> +you can find it at
> +
> + http://code.google.com/p/google-gflags/
> +
> +In addition to the unit tests, snappy contains microbenchmarks used to
> +tune compression and decompression performance. These are automatically run
> +before the unit tests, but you can disable them using the flag
> +--run_microbenchmarks=false if you have gflags installed (otherwise you will
> +need to edit the source).
> +
> +Finally, snappy can benchmark Snappy against a few other compression libraries
> +(zlib, LZO, LZF, FastLZ and QuickLZ), if they were detected at configure time.
> +To benchmark using a given file, give the compression algorithm you want to test
> +Snappy against (e.g. --zlib) and then a list of one or more file names on the
> +command line. The testdata/ directory contains the files used by the
> +microbenchmark, which should provide a reasonably balanced starting point for
> +benchmarking. (Note that baddata[1-3].snappy are not intended as benchmarks; they
> +are used to verify correctness in the presence of corrupted data in the unit
> +test.)
> +
> +
> +Contact
> +=======
> +
> +Snappy is distributed through Google Code. For the latest version, a bug tracker,
> +and other information, see
> +
> + http://code.google.com/p/snappy/
>
> http://git-wip-us.apache.org/repos/asf/couchdb/blob/9a783720/src/snappy/c_src/snappy/config.h.in
> ----------------------------------------------------------------------
> diff --git a/src/snappy/c_src/snappy/config.h.in b/src/snappy/c_src/snappy/config.h.in
> new file mode 100644
> index 0000000..28f57c2
> --- /dev/null
> +++ b/src/snappy/c_src/snappy/config.h.in
> @@ -0,0 +1,125 @@
> +/* config.h.in. Generated from configure.ac by autoheader. */
> +
> +/* Define if building universal (internal helper macro) */
> +#undef AC_APPLE_UNIVERSAL_BUILD
> +
> +/* Define to 1 if the compiler supports __builtin_ctz and friends. */
> +#undef HAVE_BUILTIN_CTZ
> +
> +/* Define to 1 if the compiler supports __builtin_expect. */
> +#undef HAVE_BUILTIN_EXPECT
> +
> +/* Define to 1 if you have the <byteswap.h> header file. */
> +#undef HAVE_BYTESWAP_H
> +
> +/* Define to 1 if you have the <dlfcn.h> header file. */
> +#undef HAVE_DLFCN_H
> +
> +/* Use the gflags package for command-line parsing. */
> +#undef HAVE_GFLAGS
> +
> +/* Defined when Google Test is available. */
> +#undef HAVE_GTEST
> +
> +/* Define to 1 if you have the <inttypes.h> header file. */
> +#undef HAVE_INTTYPES_H
> +
> +/* Define to 1 if you have the `fastlz' library (-lfastlz). */
> +#undef HAVE_LIBFASTLZ
> +
> +/* Define to 1 if you have the `lzf' library (-llzf). */
> +#undef HAVE_LIBLZF
> +
> +/* Define to 1 if you have the `lzo2' library (-llzo2). */
> +#undef HAVE_LIBLZO2
> +
> +/* Define to 1 if you have the `quicklz' library (-lquicklz). */
> +#undef HAVE_LIBQUICKLZ
> +
> +/* Define to 1 if you have the `z' library (-lz). */
> +#undef HAVE_LIBZ
> +
> +/* Define to 1 if you have the <memory.h> header file. */
> +#undef HAVE_MEMORY_H
> +
> +/* Define to 1 if you have the <stddef.h> header file. */
> +#undef HAVE_STDDEF_H
> +
> +/* Define to 1 if you have the <stdint.h> header file. */
> +#undef HAVE_STDINT_H
> +
> +/* Define to 1 if you have the <stdlib.h> header file. */
> +#undef HAVE_STDLIB_H
> +
> +/* Define to 1 if you have the <strings.h> header file. */
> +#undef HAVE_STRINGS_H
> +
> +/* Define to 1 if you have the <string.h> header file. */
> +#undef HAVE_STRING_H
> +
> +/* Define to 1 if you have the <sys/byteswap.h> header file. */
> +#undef HAVE_SYS_BYTESWAP_H
> +
> +/* Define to 1 if you have the <sys/endian.h> header file. */
> +#undef HAVE_SYS_ENDIAN_H
> +
> +/* Define to 1 if you have the <sys/mman.h> header file. */
> +#undef HAVE_SYS_MMAN_H
> +
> +/* Define to 1 if you have the <sys/resource.h> header file. */
> +#undef HAVE_SYS_RESOURCE_H
> +
> +/* Define to 1 if you have the <sys/stat.h> header file. */
> +#undef HAVE_SYS_STAT_H
> +
> +/* Define to 1 if you have the <sys/types.h> header file. */
> +#undef HAVE_SYS_TYPES_H
> +
> +/* Define to 1 if you have the <unistd.h> header file. */
> +#undef HAVE_UNISTD_H
> +
> +/* Define to 1 if you have the <windows.h> header file. */
> +#undef HAVE_WINDOWS_H
> +
> +/* Define to the sub-directory in which libtool stores uninstalled libraries.
> + */
> +#undef LT_OBJDIR
> +
> +/* Name of package */
> +#undef PACKAGE
> +
> +/* Define to the address where bug reports for this package should be sent. */
> +#undef PACKAGE_BUGREPORT
> +
> +/* Define to the full name of this package. */
> +#undef PACKAGE_NAME
> +
> +/* Define to the full name and version of this package. */
> +#undef PACKAGE_STRING
> +
> +/* Define to the one symbol short name of this package. */
> +#undef PACKAGE_TARNAME
> +
> +/* Define to the home page for this package. */
> +#undef PACKAGE_URL
> +
> +/* Define to the version of this package. */
> +#undef PACKAGE_VERSION
> +
> +/* Define to 1 if you have the ANSI C header files. */
> +#undef STDC_HEADERS
> +
> +/* Version number of package */
> +#undef VERSION
> +
> +/* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most
> + significant byte first (like Motorola and SPARC, unlike Intel). */
> +#if defined AC_APPLE_UNIVERSAL_BUILD
> +# if defined __BIG_ENDIAN__
> +# define WORDS_BIGENDIAN 1
> +# endif
> +#else
> +# ifndef WORDS_BIGENDIAN
> +# undef WORDS_BIGENDIAN
> +# endif
> +#endif
>
> http://git-wip-us.apache.org/repos/asf/couchdb/blob/9a783720/src/snappy/c_src/snappy/snappy-internal.h
> ----------------------------------------------------------------------
> diff --git a/src/snappy/c_src/snappy/snappy-internal.h b/src/snappy/c_src/snappy/snappy-internal.h
> new file mode 100644
> index 0000000..a32eda5
> --- /dev/null
> +++ b/src/snappy/c_src/snappy/snappy-internal.h
> @@ -0,0 +1,150 @@
> +// Copyright 2008 Google Inc. 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 with the
> +// distribution.
> +// * Neither the name of Google Inc. nor the names of its
> +// contributors may be used to endorse or promote products derived from
> +// this software without specific prior written permission.
> +//
> +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
> +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
> +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
> +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
> +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
> +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
> +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
> +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
> +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
> +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
> +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
> +//
> +// Internals shared between the Snappy implementation and its unittest.
> +
> +#ifndef UTIL_SNAPPY_SNAPPY_INTERNAL_H_
> +#define UTIL_SNAPPY_SNAPPY_INTERNAL_H_
> +
> +#include "snappy-stubs-internal.h"
> +
> +namespace snappy {
> +namespace internal {
> +
> +class WorkingMemory {
> + public:
> + WorkingMemory() : large_table_(NULL) { }
> + ~WorkingMemory() { delete[] large_table_; }
> +
> + // Allocates and clears a hash table using memory in "*this",
> + // stores the number of buckets in "*table_size" and returns a pointer to
> + // the base of the hash table.
> + uint16* GetHashTable(size_t input_size, int* table_size);
> +
> + private:
> + uint16 small_table_[1<<10]; // 2KB
> + uint16* large_table_; // Allocated only when needed
> +
> + DISALLOW_COPY_AND_ASSIGN(WorkingMemory);
> +};
> +
> +// Flat array compression that does not emit the "uncompressed length"
> +// prefix. Compresses "input" string to the "*op" buffer.
> +//
> +// REQUIRES: "input_length <= kBlockSize"
> +// REQUIRES: "op" points to an array of memory that is at least
> +// "MaxCompressedLength(input_length)" in size.
> +// REQUIRES: All elements in "table[0..table_size-1]" are initialized to zero.
> +// REQUIRES: "table_size" is a power of two
> +//
> +// Returns an "end" pointer into "op" buffer.
> +// "end - op" is the compressed size of "input".
> +char* CompressFragment(const char* input,
> + size_t input_length,
> + char* op,
> + uint16* table,
> + const int table_size);
> +
> +// Return the largest n such that
> +//
> +// s1[0,n-1] == s2[0,n-1]
> +// and n <= (s2_limit - s2).
> +//
> +// Does not read *s2_limit or beyond.
> +// Does not read *(s1 + (s2_limit - s2)) or beyond.
> +// Requires that s2_limit >= s2.
> +//
> +// Separate implementation for x86_64, for speed. Uses the fact that
> +// x86_64 is little endian.
> +#if defined(ARCH_K8)
> +static inline int FindMatchLength(const char* s1,
> + const char* s2,
> + const char* s2_limit) {
> + DCHECK_GE(s2_limit, s2);
> + int matched = 0;
> +
> + // Find out how long the match is. We loop over the data 64 bits at a
> + // time until we find a 64-bit block that doesn't match; then we find
> + // the first non-matching bit and use that to calculate the total
> + // length of the match.
> + while (PREDICT_TRUE(s2 <= s2_limit - 8)) {
> + if (PREDICT_FALSE(UNALIGNED_LOAD64(s2) == UNALIGNED_LOAD64(s1 + matched))) {
> + s2 += 8;
> + matched += 8;
> + } else {
> + // On current (mid-2008) Opteron models there is a 3% more
> + // efficient code sequence to find the first non-matching byte.
> + // However, what follows is ~10% better on Intel Core 2 and newer,
> + // and we expect AMD's bsf instruction to improve.
> + uint64 x = UNALIGNED_LOAD64(s2) ^ UNALIGNED_LOAD64(s1 + matched);
> + int matching_bits = Bits::FindLSBSetNonZero64(x);
> + matched += matching_bits >> 3;
> + return matched;
> + }
> + }
> + while (PREDICT_TRUE(s2 < s2_limit)) {
> + if (PREDICT_TRUE(s1[matched] == *s2)) {
> + ++s2;
> + ++matched;
> + } else {
> + return matched;
> + }
> + }
> + return matched;
> +}
> +#else
> +static inline int FindMatchLength(const char* s1,
> + const char* s2,
> + const char* s2_limit) {
> + // Implementation based on the x86-64 version, above.
> + DCHECK_GE(s2_limit, s2);
> + int matched = 0;
> +
> + while (s2 <= s2_limit - 4 &&
> + UNALIGNED_LOAD32(s2) == UNALIGNED_LOAD32(s1 + matched)) {
> + s2 += 4;
> + matched += 4;
> + }
> + if (LittleEndian::IsLittleEndian() && s2 <= s2_limit - 4) {
> + uint32 x = UNALIGNED_LOAD32(s2) ^ UNALIGNED_LOAD32(s1 + matched);
> + int matching_bits = Bits::FindLSBSetNonZero(x);
> + matched += matching_bits >> 3;
> + } else {
> + while ((s2 < s2_limit) && (s1[matched] == *s2)) {
> + ++s2;
> + ++matched;
> + }
> + }
> + return matched;
> +}
> +#endif
> +
> +} // end namespace internal
> +} // end namespace snappy
> +
> +#endif // UTIL_SNAPPY_SNAPPY_INTERNAL_H_
>
> http://git-wip-us.apache.org/repos/asf/couchdb/blob/9a783720/src/snappy/c_src/snappy/snappy-sinksource.cc
> ----------------------------------------------------------------------
> diff --git a/src/snappy/c_src/snappy/snappy-sinksource.cc b/src/snappy/c_src/snappy/snappy-sinksource.cc
> new file mode 100644
> index 0000000..1017895
> --- /dev/null
> +++ b/src/snappy/c_src/snappy/snappy-sinksource.cc
> @@ -0,0 +1,72 @@
> +// Copyright 2011 Google Inc. 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 with the
> +// distribution.
> +// * Neither the name of Google Inc. nor the names of its
> +// contributors may be used to endorse or promote products derived from
> +// this software without specific prior written permission.
> +//
> +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
> +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
> +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
> +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
> +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
> +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
> +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
> +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
> +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
> +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
> +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
> +
> +#include <string.h>
> +
> +#include "snappy-sinksource.h"
> +
> +namespace snappy {
> +
> +Source::~Source() { }
> +
> +Sink::~Sink() { }
> +
> +char* Sink::GetAppendBuffer(size_t length, char* scratch) {
> + return scratch;
> +}
> +
> +ByteArraySource::~ByteArraySource() { }
> +
> +size_t ByteArraySource::Available() const { return left_; }
> +
> +const char* ByteArraySource::Peek(size_t* len) {
> + *len = left_;
> + return ptr_;
> +}
> +
> +void ByteArraySource::Skip(size_t n) {
> + left_ -= n;
> + ptr_ += n;
> +}
> +
> +UncheckedByteArraySink::~UncheckedByteArraySink() { }
> +
> +void UncheckedByteArraySink::Append(const char* data, size_t n) {
> + // Do no copying if the caller filled in the result of GetAppendBuffer()
> + if (data != dest_) {
> + memcpy(dest_, data, n);
> + }
> + dest_ += n;
> +}
> +
> +char* UncheckedByteArraySink::GetAppendBuffer(size_t len, char* scratch) {
> + return dest_;
> +}
> +
> +
> +}
>
> http://git-wip-us.apache.org/repos/asf/couchdb/blob/9a783720/src/snappy/c_src/snappy/snappy-sinksource.h
> ----------------------------------------------------------------------
> diff --git a/src/snappy/c_src/snappy/snappy-sinksource.h b/src/snappy/c_src/snappy/snappy-sinksource.h
> new file mode 100644
> index 0000000..430baea
> --- /dev/null
> +++ b/src/snappy/c_src/snappy/snappy-sinksource.h
> @@ -0,0 +1,136 @@
> +// Copyright 2011 Google Inc. 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 with the
> +// distribution.
> +// * Neither the name of Google Inc. nor the names of its
> +// contributors may be used to endorse or promote products derived from
> +// this software without specific prior written permission.
> +//
> +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
> +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
> +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
> +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
> +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
> +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
> +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
> +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
> +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
> +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
> +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
> +
> +#ifndef UTIL_SNAPPY_SNAPPY_SINKSOURCE_H_
> +#define UTIL_SNAPPY_SNAPPY_SINKSOURCE_H_
> +
> +#include <stddef.h>
> +
> +
> +namespace snappy {
> +
> +// A Sink is an interface that consumes a sequence of bytes.
> +class Sink {
> + public:
> + Sink() { }
> + virtual ~Sink();
> +
> + // Append "bytes[0,n-1]" to this.
> + virtual void Append(const char* bytes, size_t n) = 0;
> +
> + // Returns a writable buffer of the specified length for appending.
> + // May return a pointer to the caller-owned scratch buffer which
> + // must have at least the indicated length. The returned buffer is
> + // only valid until the next operation on this Sink.
> + //
> + // After writing at most "length" bytes, call Append() with the
> + // pointer returned from this function and the number of bytes
> + // written. Many Append() implementations will avoid copying
> + // bytes if this function returned an internal buffer.
> + //
> + // If a non-scratch buffer is returned, the caller may only pass a
> + // prefix of it to Append(). That is, it is not correct to pass an
> + // interior pointer of the returned array to Append().
> + //
> + // The default implementation always returns the scratch buffer.
> + virtual char* GetAppendBuffer(size_t length, char* scratch);
> +
> + private:
> + // No copying
> + Sink(const Sink&);
> + void operator=(const Sink&);
> +};
> +
> +// A Source is an interface that yields a sequence of bytes
> +class Source {
> + public:
> + Source() { }
> + virtual ~Source();
> +
> + // Return the number of bytes left to read from the source
> + virtual size_t Available() const = 0;
> +
> + // Peek at the next flat region of the source. Does not reposition
> + // the source. The returned region is empty iff Available()==0.
> + //
> + // Returns a pointer to the beginning of the region and store its
> + // length in *len.
> + //
> + // The returned region is valid until the next call to Skip() or
> + // until this object is destroyed, whichever occurs first.
> + //
> + // The returned region may be larger than Available() (for example
> + // if this ByteSource is a view on a substring of a larger source).
> + // The caller is responsible for ensuring that it only reads the
> + // Available() bytes.
> + virtual const char* Peek(size_t* len) = 0;
> +
> + // Skip the next n bytes. Invalidates any buffer returned by
> + // a previous call to Peek().
> + // REQUIRES: Available() >= n
> + virtual void Skip(size_t n) = 0;
> +
> + private:
> + // No copying
> + Source(const Source&);
> + void operator=(const Source&);
> +};
> +
> +// A Source implementation that yields the contents of a flat array
> +class ByteArraySource : public Source {
> + public:
> + ByteArraySource(const char* p, size_t n) : ptr_(p), left_(n) { }
> + virtual ~ByteArraySource();
> + virtual size_t Available() const;
> + virtual const char* Peek(size_t* len);
> + virtual void Skip(size_t n);
> + private:
> + const char* ptr_;
> + size_t left_;
> +};
> +
> +// A Sink implementation that writes to a flat array without any bound checks.
> +class UncheckedByteArraySink : public Sink {
> + public:
> + explicit UncheckedByteArraySink(char* dest) : dest_(dest) { }
> + virtual ~UncheckedByteArraySink();
> + virtual void Append(const char* data, size_t n);
> + virtual char* GetAppendBuffer(size_t len, char* scratch);
> +
> + // Return the current output pointer so that a caller can see how
> + // many bytes were produced.
> + // Note: this is not a Sink method.
> + char* CurrentDestination() const { return dest_; }
> + private:
> + char* dest_;
> +};
> +
> +
> +}
> +
> +#endif // UTIL_SNAPPY_SNAPPY_SINKSOURCE_H_
>
> http://git-wip-us.apache.org/repos/asf/couchdb/blob/9a783720/src/snappy/c_src/snappy/snappy-stubs-internal.cc
> ----------------------------------------------------------------------
> diff --git a/src/snappy/c_src/snappy/snappy-stubs-internal.cc b/src/snappy/c_src/snappy/snappy-stubs-internal.cc
> new file mode 100644
> index 0000000..6ed3343
> --- /dev/null
> +++ b/src/snappy/c_src/snappy/snappy-stubs-internal.cc
> @@ -0,0 +1,42 @@
> +// Copyright 2011 Google Inc. 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 with the
> +// distribution.
> +// * Neither the name of Google Inc. nor the names of its
> +// contributors may be used to endorse or promote products derived from
> +// this software without specific prior written permission.
> +//
> +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
> +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
> +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
> +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
> +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
> +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
> +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
> +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
> +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
> +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
> +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
> +
> +#include <algorithm>
> +#include <string>
> +
> +#include "snappy-stubs-internal.h"
> +
> +namespace snappy {
> +
> +void Varint::Append32(string* s, uint32 value) {
> + char buf[Varint::kMax32];
> + const char* p = Varint::Encode32(buf, value);
> + s->append(buf, p - buf);
> +}
> +
> +} // namespace snappy
>
> http://git-wip-us.apache.org/repos/asf/couchdb/blob/9a783720/src/snappy/c_src/snappy/snappy-stubs-internal.h
> ----------------------------------------------------------------------
> diff --git a/src/snappy/c_src/snappy/snappy-stubs-internal.h b/src/snappy/c_src/snappy/snappy-stubs-internal.h
> new file mode 100644
> index 0000000..46ee235
> --- /dev/null
> +++ b/src/snappy/c_src/snappy/snappy-stubs-internal.h
> @@ -0,0 +1,477 @@
> +// Copyright 2011 Google Inc. 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 with the
> +// distribution.
> +// * Neither the name of Google Inc. nor the names of its
> +// contributors may be used to endorse or promote products derived from
> +// this software without specific prior written permission.
> +//
> +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
> +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
> +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
> +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
> +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
> +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
> +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
> +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
> +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
> +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
> +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
> +//
> +// Various stubs for the open-source version of Snappy.
> +
> +#ifndef UTIL_SNAPPY_OPENSOURCE_SNAPPY_STUBS_INTERNAL_H_
> +#define UTIL_SNAPPY_OPENSOURCE_SNAPPY_STUBS_INTERNAL_H_
> +
> +#ifdef HAVE_CONFIG_H
> +#include "config.h"
> +#endif
> +
> +#include <iostream>
> +#include <string>
> +
> +#include <assert.h>
> +#include <stdlib.h>
> +#include <string.h>
> +
> +#ifdef HAVE_SYS_MMAN
> +#include <sys/mman.h>
> +#endif
> +
> +#include "snappy-stubs-public.h"
> +
> +#if defined(__x86_64__)
> +
> +// Enable 64-bit optimized versions of some routines.
> +#define ARCH_K8 1
> +
> +#endif
> +
> +// Needed by OS X, among others.
> +#ifndef MAP_ANONYMOUS
> +#define MAP_ANONYMOUS MAP_ANON
> +#endif
> +
> +// Pull in std::min, std::ostream, and the likes. This is safe because this
> +// header file is never used from any public header files.
> +using namespace std;
> +
> +// The size of an array, if known at compile-time.
> +// Will give unexpected results if used on a pointer.
> +// We undefine it first, since some compilers already have a definition.
> +#ifdef ARRAYSIZE
> +#undef ARRAYSIZE
> +#endif
> +#define ARRAYSIZE(a) (sizeof(a) / sizeof(*(a)))
> +
> +// Static prediction hints.
> +#ifdef HAVE_BUILTIN_EXPECT
> +#define PREDICT_FALSE(x) (__builtin_expect(x, 0))
> +#define PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
> +#else
> +#define PREDICT_FALSE(x) x
> +#define PREDICT_TRUE(x) x
> +#endif
> +
> +// This is only used for recomputing the tag byte table used during
> +// decompression; for simplicity we just remove it from the open-source
> +// version (anyone who wants to regenerate it can just do the call
> +// themselves within main()).
> +#define DEFINE_bool(flag_name, default_value, description) \
> + bool FLAGS_ ## flag_name = default_value;
> +#define DECLARE_bool(flag_name) \
> + extern bool FLAGS_ ## flag_name;
> +#define REGISTER_MODULE_INITIALIZER(name, code)
> +
> +namespace snappy {
> +
> +static const uint32 kuint32max = static_cast<uint32>(0xFFFFFFFF);
> +static const int64 kint64max = static_cast<int64>(0x7FFFFFFFFFFFFFFFLL);
> +
> +// Logging.
> +
> +#define LOG(level) LogMessage()
> +#define VLOG(level) true ? (void)0 : \
> + snappy::LogMessageVoidify() & snappy::LogMessage()
> +
> +class LogMessage {
> + public:
> + LogMessage() { }
> + ~LogMessage() {
> + cerr << endl;
> + }
> +
> + LogMessage& operator<<(const std::string& msg) {
> + cerr << msg;
> + return *this;
> + }
> + LogMessage& operator<<(int x) {
> + cerr << x;
> + return *this;
> + }
> +};
> +
> +// Asserts, both versions activated in debug mode only,
> +// and ones that are always active.
> +
> +#define CRASH_UNLESS(condition) \
> + PREDICT_TRUE(condition) ? (void)0 : \
> + snappy::LogMessageVoidify() & snappy::LogMessageCrash()
> +
> +class LogMessageCrash : public LogMessage {
> + public:
> + LogMessageCrash() { }
> + ~LogMessageCrash() {
> + cerr << endl;
> + abort();
> + }
> +};
> +
> +// This class is used to explicitly ignore values in the conditional
> +// logging macros. This avoids compiler warnings like "value computed
> +// is not used" and "statement has no effect".
> +
> +class LogMessageVoidify {
> + public:
> + LogMessageVoidify() { }
> + // This has to be an operator with a precedence lower than << but
> + // higher than ?:
> + void operator&(const LogMessage&) { }
> +};
> +
> +#define CHECK(cond) CRASH_UNLESS(cond)
> +#define CHECK_LE(a, b) CRASH_UNLESS((a) <= (b))
> +#define CHECK_GE(a, b) CRASH_UNLESS((a) >= (b))
> +#define CHECK_EQ(a, b) CRASH_UNLESS((a) == (b))
> +#define CHECK_NE(a, b) CRASH_UNLESS((a) != (b))
> +#define CHECK_LT(a, b) CRASH_UNLESS((a) < (b))
> +#define CHECK_GT(a, b) CRASH_UNLESS((a) > (b))
> +
> +#ifdef NDEBUG
> +
> +#define DCHECK(cond) CRASH_UNLESS(true)
> +#define DCHECK_LE(a, b) CRASH_UNLESS(true)
> +#define DCHECK_GE(a, b) CRASH_UNLESS(true)
> +#define DCHECK_EQ(a, b) CRASH_UNLESS(true)
> +#define DCHECK_NE(a, b) CRASH_UNLESS(true)
> +#define DCHECK_LT(a, b) CRASH_UNLESS(true)
> +#define DCHECK_GT(a, b) CRASH_UNLESS(true)
> +
> +#else
> +
> +#define DCHECK(cond) CHECK(cond)
> +#define DCHECK_LE(a, b) CHECK_LE(a, b)
> +#define DCHECK_GE(a, b) CHECK_GE(a, b)
> +#define DCHECK_EQ(a, b) CHECK_EQ(a, b)
> +#define DCHECK_NE(a, b) CHECK_NE(a, b)
> +#define DCHECK_LT(a, b) CHECK_LT(a, b)
> +#define DCHECK_GT(a, b) CHECK_GT(a, b)
> +
> +#endif
> +
> +// Potentially unaligned loads and stores.
> +
> +#if defined(__i386__) || defined(__x86_64__) || defined(__powerpc__)
> +
> +#define UNALIGNED_LOAD16(_p) (*reinterpret_cast<const uint16 *>(_p))
> +#define UNALIGNED_LOAD32(_p) (*reinterpret_cast<const uint32 *>(_p))
> +#define UNALIGNED_LOAD64(_p) (*reinterpret_cast<const uint64 *>(_p))
> +
> +#define UNALIGNED_STORE16(_p, _val) (*reinterpret_cast<uint16 *>(_p) = (_val))
> +#define UNALIGNED_STORE32(_p, _val) (*reinterpret_cast<uint32 *>(_p) = (_val))
> +#define UNALIGNED_STORE64(_p, _val) (*reinterpret_cast<uint64 *>(_p) = (_val))
> +
> +#else
> +
> +// These functions are provided for architectures that don't support
> +// unaligned loads and stores.
> +
> +inline uint16 UNALIGNED_LOAD16(const void *p) {
> + uint16 t;
> + memcpy(&t, p, sizeof t);
> + return t;
> +}
> +
> +inline uint32 UNALIGNED_LOAD32(const void *p) {
> + uint32 t;
> + memcpy(&t, p, sizeof t);
> + return t;
> +}
> +
> +inline uint64 UNALIGNED_LOAD64(const void *p) {
> + uint64 t;
> + memcpy(&t, p, sizeof t);
> + return t;
> +}
> +
> +inline void UNALIGNED_STORE16(void *p, uint16 v) {
> + memcpy(p, &v, sizeof v);
> +}
> +
> +inline void UNALIGNED_STORE32(void *p, uint32 v) {
> + memcpy(p, &v, sizeof v);
> +}
> +
> +inline void UNALIGNED_STORE64(void *p, uint64 v) {
> + memcpy(p, &v, sizeof v);
> +}
> +
> +#endif
> +
> +// The following guarantees declaration of the byte swap functions.
> +#ifdef WORDS_BIGENDIAN
> +
> +#ifdef _MSC_VER
> +#include <stdlib.h>
> +#define bswap_16(x) _byteswap_ushort(x)
> +#define bswap_32(x) _byteswap_ulong(x)
> +#define bswap_64(x) _byteswap_uint64(x)
> +
> +#elif defined(__APPLE__)
> +// Mac OS X / Darwin features
> +#include <libkern/OSByteOrder.h>
> +#define bswap_16(x) OSSwapInt16(x)
> +#define bswap_32(x) OSSwapInt32(x)
> +#define bswap_64(x) OSSwapInt64(x)
> +
> +#else
> +#include <byteswap.h>
> +#endif
> +
> +#endif // WORDS_BIGENDIAN
> +
> +// Convert to little-endian storage, opposite of network format.
> +// Convert x from host to little endian: x = LittleEndian.FromHost(x);
> +// convert x from little endian to host: x = LittleEndian.ToHost(x);
> +//
> +// Store values into unaligned memory converting to little endian order:
> +// LittleEndian.Store16(p, x);
> +//
> +// Load unaligned values stored in little endian converting to host order:
> +// x = LittleEndian.Load16(p);
> +class LittleEndian {
> + public:
> + // Conversion functions.
> +#ifdef WORDS_BIGENDIAN
> +
> + static uint16 FromHost16(uint16 x) { return bswap_16(x); }
> + static uint16 ToHost16(uint16 x) { return bswap_16(x); }
> +
> + static uint32 FromHost32(uint32 x) { return bswap_32(x); }
> + static uint32 ToHost32(uint32 x) { return bswap_32(x); }
> +
> + static bool IsLittleEndian() { return false; }
> +
> +#else // !defined(WORDS_BIGENDIAN)
> +
> + static uint16 FromHost16(uint16 x) { return x; }
> + static uint16 ToHost16(uint16 x) { return x; }
> +
> + static uint32 FromHost32(uint32 x) { return x; }
> + static uint32 ToHost32(uint32 x) { return x; }
> +
> + static bool IsLittleEndian() { return true; }
> +
> +#endif // !defined(WORDS_BIGENDIAN)
> +
> + // Functions to do unaligned loads and stores in little-endian order.
> + static uint16 Load16(const void *p) {
> + return ToHost16(UNALIGNED_LOAD16(p));
> + }
> +
> + static void Store16(void *p, uint16 v) {
> + UNALIGNED_STORE16(p, FromHost16(v));
> + }
> +
> + static uint32 Load32(const void *p) {
> + return ToHost32(UNALIGNED_LOAD32(p));
> + }
> +
> + static void Store32(void *p, uint32 v) {
> + UNALIGNED_STORE32(p, FromHost32(v));
> + }
> +};
> +
> +// Some bit-manipulation functions.
> +class Bits {
> + public:
> + // Return floor(log2(n)) for positive integer n. Returns -1 iff n == 0.
> + static int Log2Floor(uint32 n);
> +
> + // Return the first set least / most significant bit, 0-indexed. Returns an
> + // undefined value if n == 0. FindLSBSetNonZero() is similar to ffs() except
> + // that it's 0-indexed.
> + static int FindLSBSetNonZero(uint32 n);
> + static int FindLSBSetNonZero64(uint64 n);
> +
> + private:
> + DISALLOW_COPY_AND_ASSIGN(Bits);
> +};
> +
> +#ifdef HAVE_BUILTIN_CTZ
> +
> +inline int Bits::Log2Floor(uint32 n) {
> + return n == 0 ? -1 : 31 ^ __builtin_clz(n);
> +}
> +
> +inline int Bits::FindLSBSetNonZero(uint32 n) {
> + return __builtin_ctz(n);
> +}
> +
> +inline int Bits::FindLSBSetNonZero64(uint64 n) {
> + return __builtin_ctzll(n);
> +}
> +
> +#else // Portable versions.
> +
> +inline int Bits::Log2Floor(uint32 n) {
> + if (n == 0)
> + return -1;
> + int log = 0;
> + uint32 value = n;
> + for (int i = 4; i >= 0; --i) {
> + int shift = (1 << i);
> + uint32 x = value >> shift;
> + if (x != 0) {
> + value = x;
> + log += shift;
> + }
> + }
> + assert(value == 1);
> + return log;
> +}
> +
> +inline int Bits::FindLSBSetNonZero(uint32 n) {
> + int rc = 31;
> + for (int i = 4, shift = 1 << 4; i >= 0; --i) {
> + const uint32 x = n << shift;
> + if (x != 0) {
> + n = x;
> + rc -= shift;
> + }
> + shift >>= 1;
> + }
> + return rc;
> +}
> +
> +// FindLSBSetNonZero64() is defined in terms of FindLSBSetNonZero().
> +inline int Bits::FindLSBSetNonZero64(uint64 n) {
> + const uint32 bottombits = static_cast<uint32>(n);
> + if (bottombits == 0) {
> + // Bottom bits are zero, so scan in top bits
> + return 32 + FindLSBSetNonZero(static_cast<uint32>(n >> 32));
> + } else {
> + return FindLSBSetNonZero(bottombits);
> + }
> +}
> +
> +#endif // End portable versions.
> +
> +// Variable-length integer encoding.
> +class Varint {
> + public:
> + // Maximum lengths of varint encoding of uint32.
> + static const int kMax32 = 5;
> +
> + // Attempts to parse a varint32 from a prefix of the bytes in [ptr,limit-1].
> + // Never reads a character at or beyond limit. If a valid/terminated varint32
> + // was found in the range, stores it in *OUTPUT and returns a pointer just
> + // past the last byte of the varint32. Else returns NULL. On success,
> + // "result <= limit".
> + static const char* Parse32WithLimit(const char* ptr, const char* limit,
> + uint32* OUTPUT);
> +
> + // REQUIRES "ptr" points to a buffer of length sufficient to hold "v".
> + // EFFECTS Encodes "v" into "ptr" and returns a pointer to the
> + // byte just past the last encoded byte.
> + static char* Encode32(char* ptr, uint32 v);
> +
> + // EFFECTS Appends the varint representation of "value" to "*s".
> + static void Append32(string* s, uint32 value);
> +};
> +
> +inline const char* Varint::Parse32WithLimit(const char* p,
> + const char* l,
> + uint32* OUTPUT) {
> + const unsigned char* ptr = reinterpret_cast<const unsigned char*>(p);
> + const unsigned char* limit = reinterpret_cast<const unsigned char*>(l);
> + uint32 b, result;
> + if (ptr >= limit) return NULL;
> + b = *(ptr++); result = b & 127; if (b < 128) goto done;
> + if (ptr >= limit) return NULL;
> + b = *(ptr++); result |= (b & 127) << 7; if (b < 128) goto done;
> + if (ptr >= limit) return NULL;
> + b = *(ptr++); result |= (b & 127) << 14; if (b < 128) goto done;
> + if (ptr >= limit) return NULL;
> + b = *(ptr++); result |= (b & 127) << 21; if (b < 128) goto done;
> + if (ptr >= limit) return NULL;
> + b = *(ptr++); result |= (b & 127) << 28; if (b < 16) goto done;
> + return NULL; // Value is too long to be a varint32
> + done:
> + *OUTPUT = result;
> + return reinterpret_cast<const char*>(ptr);
> +}
> +
> +inline char* Varint::Encode32(char* sptr, uint32 v) {
> + // Operate on characters as unsigneds
> + unsigned char* ptr = reinterpret_cast<unsigned char*>(sptr);
> + static const int B = 128;
> + if (v < (1<<7)) {
> + *(ptr++) = v;
> + } else if (v < (1<<14)) {
> + *(ptr++) = v | B;
> + *(ptr++) = v>>7;
> + } else if (v < (1<<21)) {
> + *(ptr++) = v | B;
> + *(ptr++) = (v>>7) | B;
> + *(ptr++) = v>>14;
> + } else if (v < (1<<28)) {
> + *(ptr++) = v | B;
> + *(ptr++) = (v>>7) | B;
> + *(ptr++) = (v>>14) | B;
> + *(ptr++) = v>>21;
> + } else {
> + *(ptr++) = v | B;
> + *(ptr++) = (v>>7) | B;
> + *(ptr++) = (v>>14) | B;
> + *(ptr++) = (v>>21) | B;
> + *(ptr++) = v>>28;
> + }
> + return reinterpret_cast<char*>(ptr);
> +}
> +
> +// If you know the internal layout of the std::string in use, you can
> +// replace this function with one that resizes the string without
> +// filling the new space with zeros (if applicable) --
> +// it will be non-portable but faster.
> +inline void STLStringResizeUninitialized(string* s, size_t new_size) {
> + s->resize(new_size);
> +}
> +
> +// Return a mutable char* pointing to a string's internal buffer,
> +// which may not be null-terminated. Writing through this pointer will
> +// modify the string.
> +//
> +// string_as_array(&str)[i] is valid for 0 <= i < str.size() until the
> +// next call to a string method that invalidates iterators.
> +//
> +// As of 2006-04, there is no standard-blessed way of getting a
> +// mutable reference to a string's internal buffer. However, issue 530
> +// (http://www.open-std.org/JTC1/SC22/WG21/docs/lwg-defects.html#530)
> +// proposes this as the method. It will officially be part of the standard
> +// for C++0x. This should already work on all current implementations.
> +inline char* string_as_array(string* str) {
> + return str->empty() ? NULL : &*str->begin();
> +}
> +
> +} // namespace snappy
> +
> +#endif // UTIL_SNAPPY_OPENSOURCE_SNAPPY_STUBS_INTERNAL_H_
>
> http://git-wip-us.apache.org/repos/asf/couchdb/blob/9a783720/src/snappy/c_src/snappy/snappy-stubs-public.h.in
> ----------------------------------------------------------------------
> diff --git a/src/snappy/c_src/snappy/snappy-stubs-public.h.in b/src/snappy/c_src/snappy/snappy-stubs-public.h.in
> new file mode 100644
> index 0000000..f0babcb
> --- /dev/null
> +++ b/src/snappy/c_src/snappy/snappy-stubs-public.h.in
> @@ -0,0 +1,85 @@
> +// Copyright 2011 Google Inc. All Rights Reserved.
> +// Author: sesse@google.com (Steinar H. Gunderson)
> +//
> +// 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 with the
> +// distribution.
> +// * Neither the name of Google Inc. nor the names of its
> +// contributors may be used to endorse or promote products derived from
> +// this software without specific prior written permission.
> +//
> +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
> +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
> +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
> +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
> +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
> +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
> +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
> +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
> +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
> +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
> +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
> +//
> +// Various type stubs for the open-source version of Snappy.
> +//
> +// This file cannot include config.h, as it is included from snappy.h,
> +// which is a public header. Instead, snappy-stubs-public.h is generated by
> +// from snappy-stubs-public.h.in at configure time.
> +
> +#ifndef UTIL_SNAPPY_OPENSOURCE_SNAPPY_STUBS_PUBLIC_H_
> +#define UTIL_SNAPPY_OPENSOURCE_SNAPPY_STUBS_PUBLIC_H_
> +
> +#if @ac_cv_have_stdint_h@
> +#include <stdint.h>
> +#endif
> +
> +#if @ac_cv_have_stddef_h@
> +#include <stddef.h>
> +#endif
> +
> +#define SNAPPY_MAJOR @SNAPPY_MAJOR@
> +#define SNAPPY_MINOR @SNAPPY_MINOR@
> +#define SNAPPY_PATCHLEVEL @SNAPPY_PATCHLEVEL@
> +#define SNAPPY_VERSION \
> + ((SNAPPY_MAJOR << 16) | (SNAPPY_MINOR << 8) | SNAPPY_PATCHLEVEL)
> +
> +#include <string>
> +
> +namespace snappy {
> +
> +#if @ac_cv_have_stdint_h@
> +typedef int8_t int8;
> +typedef uint8_t uint8;
> +typedef int16_t int16;
> +typedef uint16_t uint16;
> +typedef int32_t int32;
> +typedef uint32_t uint32;
> +typedef int64_t int64;
> +typedef uint64_t uint64;
> +#else
> +typedef signed char int8;
> +typedef unsigned char uint8;
> +typedef short int16;
> +typedef unsigned short uint16;
> +typedef int int32;
> +typedef unsigned int uint32;
> +typedef long long int64;
> +typedef unsigned long long uint64;
> +#endif
> +
> +typedef std::string string;
> +
> +#define DISALLOW_COPY_AND_ASSIGN(TypeName) \
> + TypeName(const TypeName&); \
> + void operator=(const TypeName&)
> +
> +} // namespace snappy
> +
> +#endif // UTIL_SNAPPY_OPENSOURCE_SNAPPY_STUBS_PUBLIC_H_
>