couchdb-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Benoit Chesneau <bchesn...@gmail.com>
Subject Re: [3/3] couchdb commit: updated refs/heads/2200-feature-support-erlang-17.0 to 9a78372
Date Thu, 13 Mar 2014 13:08:43 GMT
there is couchdb-snappy. that just does that with our history :/

On Thu, Mar 13, 2014 at 2:01 PM,  <dch@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 <dch@apache.org>
> Authored: Thu Mar 13 11:36:39 2014 +0100
> Committer: Dave Cottlehuber <dch@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
> + * <fdmanana@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_
>

Mime
View raw message